TGo4AnalysisImp.h

Go to the documentation of this file.

// $Id: TGo4AnalysisImp.h 1905 2016-04-27 07:54:31Z adamczew $
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum f�r Schwerionenforschung GmbH
//                     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 "TGo4CommandReceiver.h"
#include "TObject.h"
#include "TString.h"

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

class TGo4AnalysisStepManager;
class TGo4AnalysisObjectManager;
class TGo4AnalysisObjectNames;
class TGo4AnalysisSniffer;
class TGo4AnalysisStatus;
class TGo4AnalysisWebStatus;
class TGo4AnalysisStep;
class TGo4AnalysisClient;
class TGo4HistogramStatus;
class TGo4DynamicEntry;
class TGo4Condition;
class TGo4WinCond;
class TGo4PolyCond;
class TGo4ShapedCond;
class TGo4Parameter;
class TGo4ParameterStatus;
class TGo4Picture;
class TGo4Fitter;
class TGo4ObjectStatus;
class TGo4EventStoreParameter;
class TGo4EventSourceParameter;
class TGo4EventProcessorParameter;
class TGo4EventElement;
class TGo4EventStore;
class TGo4EventSource;
class TGo4EventProcessor;
class TGo4TreeStructure;
class TGo4InterruptHandler;
class TGo4AnalysisWebStatus;
class TGo4Sniffer;
class TGo4Ratemeter;

class TGo4Analysis : public TObject, public TGo4CommandReceiver  {

  friend class TGo4AnalysisStep;
  friend class TGo4AnalysisClient;
  friend class TGo4ComGetCurrentEvent;
  friend class TGo4ComGetNamesList;
  friend class TGo4ComGetEnvelope;
  friend class TGo4ComSetObject;
  friend class TGo4HisConnectorRunnable;
  friend class TGo4HistogramServer;
  friend class TGo4AnalysisWebStatus;
  friend class TGo4Sniffer;

  public:

    static const Int_t fgiAUTOSAVECOUNTS;        

    static const Int_t fgiDYNLISTINTERVAL;       

    static const Int_t fgiMACROSTARTPOLL;

    static const char* fgcDEFAULTFILENAME;    

    static const char* fgcDEFAULTSTATUSFILENAME; 

    static const char* fgcDEFAULTFILESUF;     

    static const char* fgcTOPDYNAMICLIST;     

    static const char fgcPYPROMPT;

    static const char* fgcPYINIT;

    static TGo4Analysis* Instance();

    static Bool_t Exists();

    static Bool_t IsBatchMode();

    static Bool_t IsClientMode();

    static Bool_t IsServerMode();

    static void SetRunningMode(int mode);

    virtual ~TGo4Analysis();

    virtual const char* GetName() const { return fAnalysisName.Data(); }

    void SetAnalysisName(const char* name) { fAnalysisName = name; }

    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, Bool_t showrate = kFALSE, Double_t process_event_interval = -1., Bool_t iswebserver=kFALSE);

    virtual void CloseAnalysis();

    virtual Bool_t InitEventClasses();

    TGo4AnalysisObjectManager* ObjectManager() const { return fxObjectManager; }

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

    Bool_t AddDynamicEntry(TGo4DynamicEntry* entry);

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

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

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

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

    Bool_t DeleteObjects(const char * name);

    Bool_t ClearObjects(const char* name);

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

    Bool_t ResetBackStores(Bool_t clearflag=kFALSE);

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

    TGo4TreeStructure* CreateTreeStructure(const char* treename);

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

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

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

    Bool_t AddTreeHistogram(const char* hisname, const char* treename, const char* varexp, const char* cutexp);

    TH1* GetHistogram(const char* name);

    TTree * GetTree(const char* name);

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

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

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

    TGo4Condition * GetAnalysisCondition(const char* name, const char* cond_cl = 0);

    Bool_t RemoveAnalysisCondition(const char* name);

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

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

    Bool_t SetParameterStatus(const char* name, TGo4ParameterStatus* par);

    TGo4Parameter * GetParameter(const char* name, const char* parameter_class = 0);

    Bool_t RemoveParameter(const char* name);

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

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

    TGo4Picture * GetPicture(const char* name);

    Bool_t RemovePicture(const char * name);

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

    TCanvas * GetCanvas(const char* name);

    Bool_t RemoveCanvas(const char * name);

    TGo4AnalysisStatus* CreateStatus();

    TGo4AnalysisWebStatus* CreateWebStatus();

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

    TGo4AnalysisObjectNames * CreateNamesList();

    TFolder * GetObjectFolder();

    void UpdateStatus(TGo4AnalysisStatus* state);

    void SetStatus(TGo4AnalysisStatus * state);

    Bool_t LoadStatus(const char* filename=0);

    Bool_t LoadObjects(const char* filename=0);

    Bool_t SaveStatus(const char* filename=0);

    void SetStepChecking(Bool_t on=kTRUE);

    Bool_t SetFirstStep(const char* name);

    Bool_t SetLastStep(const char* name);

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

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

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

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

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

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

    Bool_t IsAutoSaveFileName() const;

    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();

    Int_t IsErrorStopEnabled();

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

    Bool_t IsNewInputFile() const { return fbNewInputFile; }

    void SetInputFileName(const char* fname) { fxCurrentInputFileName = fname; }

    const char* GetInputFileName() const { return fxCurrentInputFileName.Data(); }

    const char* GetDefaultTestFileName() const { return fxDefaultTestFileName.Data(); }

    void SetDynListInterval(Int_t val);

    Int_t GetDynListInterval();

    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 char * name);

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

    void SendObjectToGUI(TObject* ob);

    void StartObjectServer(const char* basename,  const char* 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 char* expression = 0);

    void PrintConditions(const char* expression = 0);

    void PrintParameters(const char* expression = 0);

    void PrintDynamicList();

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

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

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

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

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

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

    void AutoSave();

    Bool_t AddAnalysisStep(TGo4AnalysisStep* next);

    TGo4AnalysisStep* GetAnalysisStep(const char* name);

    TGo4AnalysisStep* GetAnalysisStepNum(Int_t number);

    void DefineServerPasswords(const char* admin, const char* controller, const char* observer);

    void SetBatchLoopCount(Int_t cnt = -1) { fBatchLoopCount = cnt; }

    void SetMakeWithAutosave(Bool_t on = kTRUE) { fbMakeWithAutosave = on; }

    Bool_t IsObjMade() { return fbObjMade; }

    TH1* MakeTH1(char type, const char* fullname, const char* title,
                 Int_t nbinsx, Double_t xlow, Double_t xup,
                 const char* xtitle = 0, const char* ytitle = 0);

    TH2* MakeTH2(char type, const char* fullname, const char* title,
                 Int_t nbinsx, Double_t xlow, Double_t xup,
                 Int_t nbinsy, Double_t ylow, Double_t yup,
                 const char* xtitle = 0, const char* ytitle = 0, const char* ztitle = 0);

    TGo4WinCond* MakeWinCond(const char* fullname,
                             Double_t xmin, Double_t xmax,
                             const char* HistoName = 0);

    TGo4WinCond* MakeWinCond(const char* fullname,
                             Double_t xmin, Double_t xmax,
                             Double_t ymin, Double_t ymax,
                             const char* HistoName = 0);

    TGo4PolyCond* MakePolyCond(const char* fullname,
                               Int_t npoints,
                               Double_t (*points) [2],
                               const char* HistoName = 0,
                               Bool_t shapedcond=kFALSE);



    TGo4ShapedCond* MakeEllipseCond(const char* fullname,
        Int_t npoints,
        Double_t cx, Double_t cy, Double_t a1, Double_t a2, Double_t theta=0,
        const char* HistoName = 0);

    TGo4ShapedCond* MakeCircleCond(const char* fullname,
            Int_t npoints, Double_t cx, Double_t cy, Double_t r,
            const char* HistoName = 0);

    TGo4ShapedCond* MakeBoxCond(const char* fullname, Double_t cx, Double_t cy, Double_t a1, Double_t a2, Double_t theta,
        const char* HistoName = 0);

    TGo4ShapedCond* MakeFreeShapeCond(const char* fullname,
          Int_t npoints,
          Double_t (*points) [2],
          const char* HistoName = 0);

    TGo4Parameter* MakeParameter(const char* fullname,
                                 const char* classname,
                                 const char* cmd = 0);

    Long_t ExecuteScript(const char* script_name);

     Long_t ExecutePython(const char* script_name, Int_t* errcode=0);


    Long_t ExecuteLine(const char* command, Int_t* errcode=0);


    void ProcessCrtlCSignal();

    void SetSniffer(TGo4AnalysisSniffer* sniff) { fSniffer = sniff; }

    TGo4AnalysisSniffer* GetSniffer() const { return fSniffer; }

    TGo4AnalysisClient* GetAnalysisClient() const { return fxAnalysisSlave; }

    void StopAnalysis();

    void StartAnalysis();

    void ProcessEvents();

  protected:

    Bool_t fbInitIsDone;

    Bool_t fbAutoSaveOn;

    TGo4Analysis(const char* name = 0);

    TGo4Analysis(int argc, char** argv);

    void Constructor();


    Int_t ProcessAnalysisSteps();

  private:

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

    TTree* CreateSingleEventTree(TGo4EventElement* event);

    void UpdateNamesList();

    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(bool for_writing = false);

    void CloseAutoSaveFile();

    void StopWorking() { fxDoWorkingFlag = flagStop; }

    Bool_t IsStopWorking() const { return fxDoWorkingFlag == flagStop; }

    /* for signal handler to shutdown analysis server, if existing*/
    void ShutdownServer();

    static TGo4Analysis* fxInstance;             

    static Bool_t fbExists; 

    static Int_t fiRunningMode; 

    TGo4AnalysisClient* fxAnalysisSlave;            

    TGo4AnalysisStepManager* fxStepManager;      

    TGo4AnalysisObjectManager* fxObjectManager;  

    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;                       

    TString fxCurrentInputFileName;               

    Bool_t fbAutoSaveFileChange;                 

    TGo4EventElement* fxSampleEvent;             

    TGo4AnalysisObjectNames * fxObjectNames;     

    enum { flagInit, flagRunning, flagPause, flagClosed, flagStop  } fxDoWorkingFlag; 

    TGo4InterruptHandler* fxInterruptHandler; 

    TString fAnalysisName;

    Int_t fBatchLoopCount;

    TString fServerAdminPass; 

    TString fServerCtrlPass; 

    TString fServerObserverPass; 

    Bool_t fbMakeWithAutosave; 

    Bool_t fbObjMade; 

    Bool_t fbPythonBound; 

    Int_t fNumCtrlC; 

    TGo4AnalysisSniffer* fSniffer; 

    TGo4Ratemeter* fxRate; 

    TString fxDefaultTestFileName; 

  ClassDef(TGo4Analysis,5)
};

#endif