TGo4AnalysisObjectManager.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 TGO4ANALYSISOBJECTMANAGER_H
#define TGO4ANALYSISOBJECTMANAGER_H

#include "TNamed.h"

class TCanvas;
class TTree;
class TMutex;
class TFolder;
class TH1;
class TH2;
class TFile;
class TDirectory;
class TIterator;

class TGo4EventElement;
class TGo4EventProcessor;
class TGo4EventSource;
class TGo4EventStore;
class TGo4ObjectStatus;
class TGo4TreeStructure;
class TGo4CompositeEvent;
class TObjArray;
class TGo4Condition;
class TGo4WinCond;
class TGo4PolyCond;
class TGo4AnalysisObjectNames;
class TGo4DynamicEntry;
class TGo4MbsHist;
class TGo4Picture;
class TGo4Parameter;
class TGo4ParameterStatus;

class TGo4AnalysisObjectManager : public TNamed {

   public:

      TGo4AnalysisObjectManager();

      TGo4AnalysisObjectManager(const char *name);

      virtual ~TGo4AnalysisObjectManager();

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

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

      TObject *GetAsTObject(const char *name, const char *folder = nullptr);


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

      Bool_t DeleteObjects(const char *name);

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

      TFolder *CreateBranchFolder(TObjArray *branchlist,
                                  const char *name,
                                  const char *title,
                                  Bool_t istopbranch = kFALSE);

      TFolder *CreateCompositeBranchFolder(TObjArray *branchlist,
                                           TGo4CompositeEvent *compevent,
                                           Int_t startindex, Int_t *skip,
                                           const char *name, const char *title);

      TGo4TreeStructure *CreateTreeStructure(TTree *thetree);

      TGo4TreeStructure *CreateTreeStructure(const char *treename);

      TFolder *CreateMembersFolder(TObject *obj, const char *membrfoldername, TClass *cl);

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

      TH1 *GetHistogram(const char *name);

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

      TH1 *MakeTH1(const char *histotype,
                   const char *foldername,
                   const char *histoname,
                   Int_t       nbinsx,
                   Axis_t      xlow,
                   Axis_t      xup,
                   const char *title = nullptr,
                   const char *xtitle = nullptr,
                   const char *ytitle = nullptr);

      TH2 *MakeTH2(const char *histotype,
                   const char *foldername,
                   const char *histoname,
                   Int_t       nbinsx,
                   Axis_t      xlow,
                   Axis_t      xup,
                   Int_t       nbinsy,
                   Axis_t      ylow,
                   Axis_t      yup,
                   const char *title = nullptr,
                   const char *xtitle = nullptr,
                   const char *ytitle = nullptr);

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

      TTree *GetTree(const char *name);

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

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

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

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

      Bool_t RemoveAnalysisCondition(const char *name);

      TGo4WinCond *MakeWindowCond(const char *foldername,
                                  const char *conditionname,
                                  Double_t    xlow,
                                  Double_t    xup,
                                  const char *bindhistogram = nullptr,
                                  Bool_t      invert = kFALSE);

      TGo4WinCond *MakeWindowCond(const char *foldername,
                                  const char *conditionname,
                                  Double_t    xlow,
                                  Double_t    xup,
                                  Double_t    ylow,
                                  Double_t    yup,
                                  const char *bindhistogram = nullptr,
                                  Bool_t      invert = kFALSE);

      TGo4PolyCond *MakePolyCond(const char *foldername,
                                 const char *conditionname,
                                 Int_t       size,
                                 Float_t     (*points)[2],
                                 const char *bindhistogram = nullptr,
                                 Bool_t      invert = kFALSE);
      Bool_t AddParameter(TGo4Parameter *par, const char *subfolder = nullptr);

      Bool_t SetParameter(const char *name, TGo4Parameter *par, TFolder *parent = nullptr);

      Bool_t SetParameterStatus(const char *name, TGo4ParameterStatus *par, TFolder *parent = nullptr);

      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, TFolder *parent = nullptr);

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

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

      TGo4ObjectStatus *CreateObjectStatus(TObject *ob, Bool_t fullinfo = kTRUE);

      TGo4AnalysisObjectNames *CreateNamesList();

      TFolder *CreateNamesFolder(TFolder *objectfolder);

      TFolder *GetObjectFolder();

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

      TGo4EventElement *GetEventStructure(const char *name) const;

      Bool_t ResetBackStores(Bool_t clearflag=kFALSE);

      void CloseAnalysis();

      void SaveObjects(TFile *file);

      Bool_t LoadObjects(TFile *statusfile);

      Bool_t AddDynamicEntry(TGo4DynamicEntry *entry);

      void ResetCurrentDynList();

      void ProcessDynamicList();

      void SetDynListInterval(Int_t val) { fiDynListInterval = val; }

      Int_t GetDynListInterval() const { return fiDynListInterval; }

      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 AddTreeHistogram(const char *hisname, const char *treename, const char *varexp, const char *cutexp);

      void PrintHistograms(const char *expression = nullptr);

      void PrintConditions(const char *expression = nullptr);

      void PrintParameters(const char *expression = nullptr);

      void PrintDynamicList();

      Bool_t ClearObjects(const char *name);

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

      Bool_t RemoveDynamicEntry(const char *entryname);

      TFolder *FindSubFolder(TFolder *parent, const char *subfolder, Bool_t create = kTRUE);

      Bool_t FindObjectPathName(TObject *obj, TString &pathname, TFolder *fold = nullptr);

      Bool_t CreatedInMake() const { return fbCreatedinMake; }

      void SetSortedOrder(Bool_t on = kTRUE) { fbSortedOrder = on; }

      Bool_t IsSortedOrder() const { return fbSortedOrder; }

      void RecursiveRemove(TObject *obj) override;

      static const char *fgcTOPDYNAMICLIST;

      static const char *fgcTOPFOLDER;

      static const char *fgcHISTFOLDER;

      static const char *fgcDYNFOLDER;

      static const char *fgcCONDFOLDER;

      static const char *fgcPARAFOLDER;

      static const char *fgcTREEFOLDER;

      static const char *fgcPICTFOLDER;

      static const char *fgcCANVFOLDER;

      static const char *fgcANALYSISFOLDER;

      static const char *fgcEVENTFOLDER;

      static const char *fgcSRCFOLDER;

      static const char *fgcSTOREFOLDER;

      static const char *fgcPROCFOLDER;

      static const char *fgcUSRFOLDER;

      static const char *fgcTMPFOLDER;

      static const char *GetTOPDYNAMICLIST();
      static const char *GetTOPFOLDER();
      static const char *GetHISTFOLDER();
      static const char *GetDYNFOLDER();
      static const char *GetCONDFOLDER();
      static const char *GetPARAFOLDER();
      static const char *GetTREEFOLDER();
      static const char *GetPICTFOLDER();
      static const char *GetCANVFOLDER();
      static const char *GetANALYSISFOLDER();
      static const char *GetEVENTFOLDER();
      static const char *GetSRCFOLDER();
      static const char *GetSTOREFOLDER();
      static const char *GetPROCFOLDER();
      static const char *GetUSRFOLDER();
      static const char *GetTMPFOLDER();

   private:

      TFolder *fxGo4Dir{nullptr};


      TFolder *fxHistogramDir{nullptr};

      TFolder *fxConditionDir{nullptr};

      TFolder *fxParameterDir{nullptr};

      TFolder *fxDynListDir{nullptr};

      TFolder *fxUserDir{nullptr};

      TFolder *fxTreeDir{nullptr};

      TFolder *fxPictureDir{nullptr};

      TFolder *fxCanvasDir{nullptr};

      TFolder *fxStoreDir{nullptr};

      TFolder *fxSourceDir{nullptr};

      TFolder *fxProcessorDir{nullptr};

      TFolder *fxEventDir{nullptr};

      TFolder *fxAnalysisDir{nullptr};

      TFolder *fxTempFolder{nullptr};

      TMutex *fxDirMutex{nullptr};

      TList *fxMatchList{nullptr};

      TIterator *fxMatchIterator{nullptr}; 

      Int_t fiDynListCount{0};

      Int_t fiDynListInterval{0};

      Bool_t fbCreatedinMake{kFALSE};    

      Bool_t fbSuppressLoadHistograms{kFALSE};    

      Bool_t fbSortedOrder{kFALSE};    

      Bool_t AddObjectToFolder(TObject *ob,
                               TFolder *fold,
                               const char *subfolder = nullptr,
                               Bool_t replace = kTRUE,
                               Bool_t uniquename = kFALSE,
                               Bool_t resetbits = kTRUE);

      Bool_t RemoveObjectFromFolder(const char *fullname, TFolder *fold, Bool_t isDel);

      Bool_t LoadFolder(TFolder *source, TFolder *destination, Bool_t replace = kFALSE);

      Bool_t LoadFolder(TDirectory *source, TFolder *destination, Bool_t replace = kFALSE);

      Bool_t PutToFolder(TObject *ob, TFolder *destination, Bool_t replace = kFALSE);

      Bool_t SaveFolder(TFolder *source);

      void RemoveFromDir(TFolder *fold, TDirectory *dir);

      void AppendToDir(TObject *ob, TDirectory *dir);

      Int_t PrintFolder(TFolder *fold, Option_t *opt, const char *expression = nullptr);

      Bool_t ClearFolder(TFolder *fold);

      Bool_t ClearObject(TObject *ob);

      Bool_t DeleteFolder(TFolder *fold);

      Bool_t DeleteObject(TObject *ob);

      Bool_t ProtectFolder(TFolder *fold, const Option_t *flags);

      Bool_t ProtectObject(TObject *ob, const Option_t *flags);

      void CleanupDynamicLists(TObject *oldobject);

      TList *CreateObjectList(const char *expr, const char *folder = nullptr);

      TList *CreateObjectList(const char *expr, TFolder *fold);

      Bool_t IsMatching(const char *string, const char *expression) const;

      TObject *FindObjectInFolder(TFolder *folder, const char *fullname) const;

      TObject *TestObject(TFolder *folder,
                          const char *&pathname,
                          const char *objectname,
                          const TClass *cl);

};

#endif //TGO4ANALYSISOBJECTMANAGER_H