---

/Go4Analysis/TGo4AnalysisImp.h

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#ifndef TGO4ANALYSISIMP_H
#define TGO4ANALYSISIMP_H

#include "Go4CommandsBase/TGo4CommandReceiver.h"
#include "TObject.h"
#include "TString.h"
#include "TCut.h"

class TH1;
class TTree;
class TCanvas;
class TFolder;
class TNamed;
class TMutex;
class TStopwatch;
class TFile;

class TGo4AnalysisStepManager;
class TGo4AnalysisObjectManager;
class TGo4AnalysisObjectNames;
class TGo4AnalysisStatus;
class TGo4AnalysisStep;
class TGo4AnalysisClient;
class TGo4HistogramStatus;
class TGo4HistogramEntryStatus;
class TGo4DynamicList;
class TGo4DynamicListStatus;
class TGo4DynamicEntryStatus;
class TGo4Condition;
class TGo4Parameter;
class TGo4Picture;
class TGo4Fitter;
class TGo4CanvasStatus;
class TGo4ObjectStatus;
class TGo4EventStoreParameter;
class TGo4EventSourceParameter;
class TGo4EventProcessorParameter;
class TGo4EventElement;
class TGo4EventStore;
class TGo4EventSource;
class TGo4EventProcessor;
class TGo4TreeStructure;

class TGo4Analysis : public TGo4CommandReceiver, public TObject  {

  friend class TGo4AnalysisStep;
  friend class TGo4AnalysisClient;
  friend class TGo4ComGetCurrentEvent;
  friend class TGo4ComHisGetDir;
  friend class TGo4ComGetNamesList;
  friend class TGo4ComGetDynamicEntryStatus;
  friend class TGo4HisConnectorRunnable;
  friend class TGo4HistogramServer;
  
  public:

    static const Int_t fgiAUTOSAVECOUNTS;        

    static const Int_t fgiGO4VERSION;            

    static const Int_t fgiDYNLISTINTERVAL;       

    static const Int_t fgiMACROSTARTPOLL;

    static const Text_t fgcDEFAULTFILENAME[];    

    static const Text_t fgcDEFAULTSTATUSFILENAME[]; 

    static const Text_t fgcDEFAULTFILESUF[];     

    static const Text_t fgcTOPDYNAMICLIST[];     

    static TGo4Analysis* Instance();

    static Bool_t Exists(); 

    virtual ~TGo4Analysis();

    Int_t MainCycle();

    Int_t PreLoop();

    Int_t PostLoop();

    Int_t Process();


    virtual Int_t UserEventFunc();

    virtual Int_t UserPreLoop();

    virtual Int_t UserPostLoop();

    Int_t RunImplicitLoop(Int_t times);

    virtual void CloseAnalysis();

    virtual Bool_t InitEventClasses();

    TGo4AnalysisObjectManager* ObjectManager() const { return fxObjectManager; }

    Bool_t AddDynamicHistogram(const Text_t* name,
                               const Text_t* histo,
                               const Text_t* hevx, const Text_t* hmemx,
                               const Text_t* hevy=0, const Text_t* hmemy=0,
                               const Text_t* hevz=0, const Text_t* hmemz=0,
                               const Text_t* condition=0,
                               const Text_t* cevx=0, const Text_t* cmemx=0,
                               const Text_t* cevy=0, const Text_t* cmemy=0);


    Bool_t AddDynamicHistogram(TGo4HistogramEntryStatus* settings);

    Bool_t SetDynamicEntryStatus(const Text_t* name, TGo4DynamicEntryStatus* state, const Text_t* listname);

    Bool_t RemoveDynamicEntry(const Text_t* entryname, const Text_t* listname=0);

    Bool_t AddObject(TNamed * anything, const Text_t* subfolder=0, Bool_t replace=kTRUE);

    TNamed * GetObject(const Text_t* name, const Text_t* folder=0);

    Bool_t RemoveObject(const Text_t* name, Bool_t del=kTRUE);

    Bool_t DeleteObjects(const Text_t * name);

    Bool_t ClearObjects(const Text_t* name);

    Bool_t ProtectObjects(const Text_t* name, const Option_t* flags);

    Bool_t ResetBackStores();

    TObject* NextMatchingObject(const Text_t* expr=0,
                                const Text_t* folder=0,
                                Bool_t reset=kFALSE);

    TGo4TreeStructure* CreateTreeStructure(const Text_t* treename);

    Bool_t AddHistogram(TH1* his , const Text_t* subfolder=0, Bool_t replace=kTRUE);

    Bool_t AddTree(TTree* tree, const Text_t* subfolder=0);

    Bool_t RemoveTree(TTree * tree, const Text_t* stepname=0);

    Bool_t AddTreeHistogram(const Text_t * hisname, const Text_t* treename, const Text_t* varexp, TCut selection);

    TH1* GetHistogram(const Text_t* name);

    TTree * GetTree(const Text_t* name);

    Bool_t RemoveHistogram(const Text_t* name, Bool_t del=kTRUE);

    Bool_t AddAnalysisCondition(TGo4Condition * con, const Text_t* subfolder=0);

    Bool_t SetAnalysisCondition(const Text_t* name, TGo4Condition* con, Bool_t counter=kTRUE);

    TGo4Condition * GetAnalysisCondition(const Text_t* name);

    Bool_t RemoveAnalysisCondition(const Text_t* name);

    Bool_t AddParameter(TGo4Parameter * par, const Text_t* subfolder=0);

    Bool_t SetParameter(const Text_t* name, TGo4Parameter * par);

    TGo4Parameter * GetParameter(const Text_t* name);

    Bool_t RemoveParameter(const Text_t* name);

    Bool_t AddPicture(TGo4Picture * pic, const Text_t* subfolder=0);

    Bool_t SetPicture(const Text_t* name, TGo4Picture * pic);

    TGo4Picture * GetPicture(const Text_t* name);

    Bool_t RemovePicture(const Text_t * name);

    Bool_t AddCanvas(TCanvas * can, const Text_t* subfolder=0);

    Bool_t SetCanvas(const Text_t* name, TGo4CanvasStatus * stat);

    TCanvas * GetCanvas(const Text_t* name);

    Bool_t RemoveCanvas(const Text_t * name);

    TGo4AnalysisStatus* CreateStatus();

    TGo4ObjectStatus* CreateObjectStatus(const Text_t * name, const Text_t* folder=0);

    TGo4AnalysisObjectNames * CreateNamesList();

    TFolder * GetObjectFolder();

    void UpdateStatus(TGo4AnalysisStatus* state);

    void SetStatus(TGo4AnalysisStatus * state);

    Bool_t LoadStatus(const Text_t* filename=0);

    Bool_t LoadObjects(const Text_t* filename=0);

    Bool_t SaveStatus(const Text_t* filename=0);

    void SetStepChecking(Bool_t on=kTRUE);

    Bool_t SetFirstStep(const Text_t* name);

    Bool_t SetLastStep(const Text_t* name);

    Bool_t SetStepStorage(const Text_t* name, Bool_t on);

    Bool_t NewStepStore(const Text_t* name, TGo4EventStoreParameter* par);

    Bool_t NewStepSource(const Text_t* name, TGo4EventSourceParameter * par);

    Bool_t NewStepProcessor(const Text_t* name, TGo4EventProcessorParameter * par);

    void SetAutoSaveInterval(Int_t interval=0) { fiAutoSaveInterval=interval; }

    void SetAutoSaveFile(const Text_t* filename=0,
                         Bool_t overwrite=kFALSE,
                         Int_t compression=5);

    Int_t LockAutoSave();

    Int_t UnLockAutoSave();

    void SetAutoSave(Bool_t on=kTRUE) {fbAutoSaveOn=on;}

    Bool_t IsAutoSaveOn() const { return fbAutoSaveOn; }

    void SetAutoSaveFileChange(Bool_t on=kTRUE) {fbAutoSaveFileChange=on;}

    Bool_t IsAutoSaveFileChange() const { return fbAutoSaveFileChange; }

    Bool_t IsInitDone() const { return fbInitIsDone; }

    Bool_t& IsRunning(); 


    void SetRunning(Bool_t on=kTRUE);

    Int_t WaitForStart();
    
    void StopWaiting();
    

//    /** Explicit lock of go4 main mutex. Required from CINT session,
//     * since the usual TGo4Lockguard mechanism fails here due to
//     * different scoping policy of interpreter.. */
//    void LockMutex();
//    
//    /** Explicit lock of go4 main mutex. Required from CINT session,
//     * since the usual TGo4Lockguard mechanism fails here due to
//     * different scoping policy of interpreter. */
//    void UnLockMutex();


    Int_t IsErrorStopEnabled();

    void SetNewInputFile(Bool_t on=kTRUE) {fbNewInputFile=on;}

    Bool_t IsNewInputFile() const { return fbNewInputFile; }

    void SetDynListInterval(Int_t val);

    Int_t GetDynListInterval();

    /* True if number of events reaches dynlistinterval modulo */
    Bool_t CheckDynListInterval();

    TGo4EventElement* GetInputEvent(const char* stepname);

    TGo4EventElement* GetInputEvent(Int_t stepindex);

    TGo4EventElement* GetOutputEvent(const char* stepname);

    TGo4EventElement* GetOutputEvent(Int_t stepindex);
   
    TGo4EventElement* GetOutputEvent();

    TGo4EventElement * GetEventStructure(const Text_t * name);

    void Message(Int_t prio, const Text_t* text,...);

    void SendObjectToGUI(TNamed* ob);

    void StartObjectServer(const Text_t* basename,  const Text_t* passwd);

    void StopObjectServer();


   void SetAdministratorPassword(const char* passwd);
   
   void SetControllerPassword(const char* passwd);
 
   void SetObserverPassword(const char* passwd);
 

    virtual void Print(Option_t* opt="") const;

    void PrintHistograms(const Text_t* expression=0);

    void PrintConditions(const Text_t* expression=0);

    void PrintDynamicList();

    void ShowEvent(const Text_t* stepname, Bool_t isoutput=kTRUE);

    Int_t StoreParameter(const Text_t * name, TGo4Parameter* par);

    Int_t StoreCondition(const Text_t * name, TGo4Condition* con);

    Int_t StoreFitter(const Text_t * name, TGo4Fitter* fit);

    Int_t StoreFolder(const Text_t * stepname, TFolder* folder);

    Int_t StoreFolder(const Text_t * stepname, const Text_t* foldername);

    void AutoSave();

    Bool_t AddAnalysisStep(TGo4AnalysisStep* next);

    TGo4AnalysisStep* GetAnalysisStep(const Text_t* name);

  protected:

    Bool_t fbInitIsDone;

    Bool_t fbAutoSaveOn;

    TGo4Analysis();

    Int_t ProcessAnalysisSteps();

  private:

    TTree* CreateSingleEventTree(const Text_t* name, Bool_t isoutput=kTRUE);

    TTree* CreateSingleEventTree(TGo4EventElement* event);

    void UpdateNamesList();

    TGo4DynamicList* GetDynamicList(const Text_t* listname);
    
    TGo4AnalysisObjectNames * GetNamesList() const { return fxObjectNames; }
   
    void SetOutputEvent(TGo4EventElement * event);

    Bool_t AddEventStore(TGo4EventStore * store);

    Bool_t RemoveEventStore(TGo4EventStore * store);

    Bool_t AddEventSource(TGo4EventSource * source);

    Bool_t RemoveEventSource(TGo4EventSource* source);

    Bool_t AddEventProcessor(TGo4EventProcessor * pro);

    Bool_t RemoveEventProcessor(TGo4EventProcessor * pro);

    Bool_t AddEventStructure(TGo4EventElement * ev);

    Bool_t RemoveEventStructure(TGo4EventElement * ev);

    void SetAnalysisClient(TGo4AnalysisClient* cli) { fxAnalysisSlave=cli; }

    void SendMessageToGUI(Int_t level, Bool_t printout, const char* text);

    void OpenAutoSaveFile();

    void CloseAutoSaveFile();

    static TGo4Analysis* fxInstance;             

    static Bool_t fbExists; 

    TGo4AnalysisClient* fxAnalysisSlave;            

    TGo4AnalysisStepManager* fxStepManager;      

    TGo4AnalysisObjectManager* fxObjectManager;  

    TGo4DynamicListStatus * fxDynamicListStatus; 

    Int_t fiAutoSaveCount;                       

    TStopwatch* fxAutoSaveClock;                

    Int_t fiAutoSaveInterval;                    

    Int_t fiAutoSaveCompression;                 

    TMutex* fxAutoSaveMutex;                     

    TFile* fxAutoFile;                           

    TString fxAutoFileName;                      

    Bool_t fbAutoSaveOverwrite;                  

    TString fxConfigFilename;                    

    Bool_t fbNewInputFile;                       

    Bool_t fbAutoSaveFileChange;                 

    TGo4EventElement* fxSampleEvent;             

    TGo4AnalysisObjectNames * fxObjectNames;     
    
    Bool_t fbStopWatingFlag; 

  ClassDef(TGo4Analysis,3)
};

#endif

//----------------------------END OF GO4 SOURCE FILE ---------------------

---