TGo4AnalysisObjectManager.h

Go to the documentation of this file.

//-------------------------------------------------------------
//        Go4 Release Package v3.04-01 (build 30401)
//                      28-November-2008
//---------------------------------------------------------------
//   The GSI Online Offline Object Oriented (Go4) Project
//   Experiment Data Processing at EE 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 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;

class TGo4AnalysisObjectManager : public TNamed
   {
   public:

      TGo4AnalysisObjectManager();

      TGo4AnalysisObjectManager(const char* name);

      ~TGo4AnalysisObjectManager();

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

    TObject* NextMatchingObject(const Text_t* expr,
                                const Text_t* 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 Text_t* treename);

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


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

      TH1* GetHistogram(const Text_t * name);

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

      TH1* MakeH1(const Text_t* histotype,
                  const Text_t* foldername,
                  const Text_t* histoname,
                  Int_t         nbinsx,
                  Axis_t        xlow,
                  Axis_t        xup,
                  const Text_t* title = 0,
                  const Text_t* xtitle = 0,
                  const Text_t* ytitle = 0);

      TH2* MakeH2(const Text_t* histotype,
                  const Text_t* foldername,
                  const Text_t* histoname,
                  Int_t         nbinsx,
                  Axis_t        xlow,
                  Axis_t        xup,
                  Int_t         nbinsy,
                  Axis_t        ylow,
                  Axis_t        yup,
                  const Text_t* title = 0,
                  const Text_t* xtitle = 0,
                  const Text_t* ytitle = 0);

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

      TTree * GetTree(const Text_t * name);

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

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

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

      TGo4Condition * GetAnalysisCondition(const Text_t * name);

      Bool_t RemoveAnalysisCondition(const Text_t * name);

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

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

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

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

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

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

      TGo4Picture * GetPicture(const Text_t * name);

      Bool_t RemovePicture(const Text_t * name);


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

      TCanvas * GetCanvas(const Text_t * name);

      Bool_t RemoveCanvas(const Text_t * name);

      TGo4ObjectStatus * CreateObjectStatus(const Text_t * name, const Text_t* 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 Text_t * 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 Text_t* expression=0);
   void PrintConditions(const Text_t* expression=0);
   void PrintDynamicList();


   Bool_t ClearObjects(const Text_t* name);


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

       Bool_t RemoveDynamicEntry(const char* entryname);


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


      Bool_t CreatedInMake() const { return fbCreatedinMake; }

      static const Text_t fgcTOPDYNAMICLIST[];

      static const Text_t fgcTOPFOLDER[];

      static const Text_t fgcHISTFOLDER[];

      static const Text_t fgcDYNFOLDER[];

      static const Text_t fgcCONDFOLDER[];

      static const Text_t fgcPARAFOLDER[];

      static const Text_t fgcTREEFOLDER[];

      static const Text_t fgcPICTFOLDER[];

      static const Text_t fgcCANVFOLDER[];

      static const Text_t fgcANALYSISFOLDER[];

      static const Text_t fgcEVENTFOLDER[];

      static const Text_t fgcSRCFOLDER[];

      static const Text_t fgcSTOREFOLDER[];

      static const Text_t fgcPROCFOLDER[];

      static const Text_t fgcUSRFOLDER[];

      static const Text_t 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 Text_t* 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 Text_t* 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 Text_t* expr, const Text_t* folder=0);

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

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

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

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

};

#endif //TGO4ANALYSISOBJECTMANAGER_H

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

---