TGo4AnalysisImp.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer 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 "TObject.h"
#include "TGo4CommandReceiver.h"
#include "TString.h"

class TH1;
class TH2;
class TTree;
class TGraph;
class TF1;
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 TGo4ListCond;
class TGo4RollingGraph;
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 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();

   const char *GetName() const override { 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 = nullptr, const char *hmemy = nullptr,
                              const char *hevz = nullptr, const char *hmemz = nullptr,
                              const char *condition = nullptr,
                              const char *cevx = nullptr, const char *cmemx = nullptr,
                              const char *cevy = nullptr, const char *cmemy = nullptr);

   Bool_t AddDynamicEntry(TGo4DynamicEntry *entry);

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

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

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

   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 = nullptr,
                               const char *folder = nullptr,
                               Bool_t reset = kFALSE);

   TGo4TreeStructure *CreateTreeStructure(const char *treename);

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

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

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

   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 = nullptr);

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

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

   Bool_t RemoveAnalysisCondition(const char *name);

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

   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 = nullptr);

   Bool_t RemoveParameter(const char *name);

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

   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 = nullptr);

   TCanvas *GetCanvas(const char *name);

   Bool_t RemoveCanvas(const char *name);

   TGo4AnalysisStatus *CreateStatus();

   TGo4AnalysisWebStatus *CreateWebStatus();

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

   TGo4AnalysisObjectNames *CreateNamesList();

   TFolder *GetObjectFolder();

   void UpdateStatus(TGo4AnalysisStatus *state);

   void SetStatus(TGo4AnalysisStatus *state);

   Bool_t LoadStatus(const char *filename = nullptr);

   Bool_t LoadObjects(const char *filename = nullptr);

   Bool_t SaveStatus(const char *filename = nullptr);

   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 = nullptr,
                        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() const;

   void SetRunning(Bool_t on = kTRUE);

   Int_t WaitForStart();

   Int_t IsErrorStopEnabled() const;

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

   TGo4EventElement *GetInputEvent(const char *stepname) const;

   TGo4EventElement *GetInputEvent(Int_t stepindex) const;

   TGo4EventElement *GetOutputEvent(const char *stepname) const;

   TGo4EventElement *GetOutputEvent(Int_t stepindex) const;

   TGo4EventElement *GetOutputEvent() const;

   TGo4EventElement *GetEventStructure(const char *name) const;

   void Message(Int_t prio, const char *text, ...)
   #if defined(__GNUC__) && !defined(__CINT__)
   __attribute__((format(printf, 3, 4)))
   #endif
   ;

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

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

   void PrintHistograms(const char *expression = nullptr);

   void PrintConditions(const char *expression = nullptr);

   void PrintParameters(const char *expression = nullptr);

   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() const { return fbObjMade; }

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

   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 = nullptr, const char *ytitle = nullptr, const char *ztitle = nullptr);

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

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

   TGo4PolyCond *MakePolyCond(const char *fullname,
                              Int_t npoints,
                              Double_t (*points) [2],
                              const char *HistoName = nullptr,
                              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 = nullptr);

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

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

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

   TGo4ListCond *MakeListCond(const char *fullname, const Int_t num,
                              const Int_t *values, const char *HistoName = nullptr);

   TGo4ListCond *MakeListCond(const char *fullname, const Int_t start,
                              const Int_t stop, const Int_t step = 1, const char *HistoName = nullptr);

   TGo4ListCond *MakeListCond(const char *fullname, const char *title,
                              const char *HistoName = nullptr);

   TGraph *MakeGraph(const char *fullname, const char *title, Int_t points = 0,
                     Double_t *xvalues = nullptr, Double_t *yvalues = nullptr);

   TGraph *MakeGraph(const char *fullname, const char *title, TF1 *function);

   TGo4RollingGraph *MakeRollingGraph(const char *fullname, const char *title, Int_t points = 0, Int_t average = 1);

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

   void SetSortedOrder(Bool_t on = kTRUE);

   Bool_t IsSortedOrder() const;

   Long64_t ExecuteScript(const char *script_name);

   Long64_t ExecutePython(const char *script_name, Int_t *errcode = nullptr);

   Long64_t ExecuteLine(const char *command, Int_t *errcode = nullptr);

   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{kFALSE};

   Bool_t fbAutoSaveOn{kFALSE};

   TGo4Analysis(const char *name = nullptr);

   TGo4Analysis(int argc, char **argv);

   void Constructor();

   Int_t ProcessAnalysisSteps();

private:

   Bool_t EvaluateFolderpath(const char *fullname, TString &object, TString &folder);

   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{nullptr};            

   TGo4AnalysisStepManager *fxStepManager{nullptr};      

   TGo4AnalysisObjectManager *fxObjectManager{nullptr};  

   Int_t fiAutoSaveCount{0};                       

   TStopwatch *fxAutoSaveClock{nullptr};                

   Int_t fiAutoSaveInterval{0};                    

   Int_t fiAutoSaveCompression{0};                 

   TMutex *fxAutoSaveMutex{nullptr};                     

   TFile *fxAutoFile{nullptr};                           

   TString fxAutoFileName;                      

   Bool_t fbAutoSaveOverwrite{kFALSE};                  

   TString fxConfigFilename;                    

   Bool_t fbNewInputFile{kFALSE};                       

   TString fxCurrentInputFileName;               

   Bool_t fbAutoSaveFileChange{kFALSE};                 

   TGo4EventElement *fxSampleEvent{nullptr};             

   TGo4AnalysisObjectNames *fxObjectNames{nullptr};     

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

   TGo4InterruptHandler *fxInterruptHandler{nullptr}; 

   TString fAnalysisName;

   Int_t fBatchLoopCount{0};

   TString fServerAdminPass; 

   TString fServerCtrlPass; 

   TString fServerObserverPass; 

   Bool_t fbMakeWithAutosave{kFALSE}; 

   Bool_t fbObjMade{kFALSE}; 

   Bool_t fbPythonBound{kFALSE}; 

   Int_t fNumCtrlC{0}; 

   TGo4AnalysisSniffer *fSniffer{nullptr}; 

   TGo4Ratemeter *fxRate{nullptr}; 

   TString fxDefaultTestFileName; 

   ClassDefOverride(TGo4Analysis,5)
};

#endif