TGo4AnalysisObjectManager.h

Go to the documentation of this file.

// $Id: TGo4AnalysisObjectManager.h 1566 2015-06-16 06:42:45Z linev $
//-----------------------------------------------------------------------
//       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 TGO4ANALYSISOBJECTMANAGER_H
#define TGO4ANALYSISOBJECTMANAGER_H

#include "TNamed.h"
#include "Htypes.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;

#ifdef __CINT__
class TGo4AnalysisObjectManager : public TNamed {
#else
#ifdef GO4_EXPORT
class __declspec(dllimport) TGo4AnalysisObjectManager : public TNamed {
#else
class TGo4AnalysisObjectManager : public TNamed {
#endif
#endif

   public:

      TGo4AnalysisObjectManager();

      TGo4AnalysisObjectManager(const char* name);

      ~TGo4AnalysisObjectManager();

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

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

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


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

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

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

      TTree * GetTree(const char * name);

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

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

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

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

      Bool_t RemoveAnalysisCondition(const char * name);

      TGo4WinCond* MakeWindowCond(const char* foldername,
            const char* conditionname,
            Double_t      xlow,
            Double_t      xup,
            const char* bindhistogram = 0,
            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 = 0,
            Bool_t        invert = kFALSE);

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

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

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

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

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

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

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

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

      void PrintHistograms(const char* expression=0);

      void PrintConditions(const char* expression=0);

      void PrintParameters(const char* expression=0);

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

      Bool_t CreatedInMake() const { return fbCreatedinMake; }

      virtual void RecursiveRemove(TObject* obj);

      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;

   private:

      TFolder * fxGo4Dir;


      TFolder * fxHistogramDir;

      TFolder * fxConditionDir;

      TFolder * fxParameterDir;

      TFolder * fxDynListDir;

      TFolder * fxUserDir;

      TFolder * fxTreeDir;

      TFolder * fxPictureDir;

      TFolder * fxCanvasDir;

      TFolder * fxStoreDir;

      TFolder * fxSourceDir;

      TFolder * fxProcessorDir;

      TFolder * fxEventDir;

      TFolder * fxAnalysisDir;

      TFolder * fxTempFolder;

      TMutex * fxDirMutex;


      TList * fxMatchList;

      TIterator * fxMatchIterator; 


      Int_t fiDynListCount;

      Int_t fiDynListInterval;

      Bool_t fbCreatedinMake;    

      Bool_t fbSuppressLoadHistograms;    

      Bool_t AddObjectToFolder(TObject * ob,
            TFolder* fold,
            const char* subfolder=0,
            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=0);

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

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

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

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

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

};

#endif //TGO4ANALYSISOBJECTMANAGER_H