---

/Go4Analysis/TGo4AnalysisObjectManager.h

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE 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 "TH1.h"

class TCut;
class TCanvas;
class TTree;
class TMutex;
class TFolder;
class TH2;

class TGo4EventElement;
class TGo4EventProcessor;
class TGo4EventSource;
class TGo4EventStore;
class TGo4ObjectStatus;
class TGo4TreeStructure;
class TGo4CompositeEvent;
class TObjArray;
class TGo4EventDataIndex;
class TGo4Condition;
class TGo4WinCond;
class TGo4PolyCond;
class TGo4AnalysisObjectNames;
class TGo4DynamicList;
class TGo4DynamicEntry;
class TGo4MbsHist;
class TGo4Picture;
class TGo4Parameter;
class TGo4CanvasStatus;
class TGo4HistogramEntryStatus;
class TGo4DynamicEntryStatus;

class TGo4AnalysisObjectManager : public TNamed
   {
   public:

      TGo4AnalysisObjectManager();

      TGo4AnalysisObjectManager(const Text_t* 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 Text_t* name, const Text_t* Title,
                                      Bool_t istopbranch=kFALSE);

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

      TGo4TreeStructure * CreateTreeStructure(TTree * thetree);

      TGo4TreeStructure * CreateTreeStructure(const Text_t* treename);

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

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

      Bool_t SetCanvas(const Text_t * name, TGo4CanvasStatus * stat, TFolder* parent=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();
  
      void CloseAnalysis();

    void SaveObjects(TFile* file);

      Bool_t LoadObjects(TFile* statusfile);

      Bool_t AddDynamicList(TGo4DynamicList * list);

      TGo4DynamicList * GetDynamicList(const Text_t * name);

      Bool_t RemoveDynamicList(const Text_t * name);

    void RemoveDynamicList(TGo4DynamicList* list);

      void SetCurrentDynList(TGo4DynamicList* list)
          {
              fxDynamicList=list;
          }
      TGo4DynamicList* GetCurrentDynList()
          {
              return fxDynamicList;
          }

      void ResetCurrentDynList();

      Int_t ProcessDynamicList();

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

      Int_t GetDynListInterval()
          {
             return fiDynListInterval;
          }

//     /* Direct access to folder with registered histograms. For histogram server! */
//      TFolder* GetHistogramFolder()
//          {
//             return fxHistogramDir;
//          }


/* True if number of events reaches dynlistinterval modulo */
  Bool_t CheckDynListInterval()
      {
         return ((fiDynListCount%fiDynListInterval)==0);
      }



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


      /* Add new dynamic list entry according to settings */
      Bool_t AddDynamicHistogram(TGo4HistogramEntryStatus* settings);


   Bool_t AddTreeHistogram(const Text_t * hisname, const Text_t * treename, const Text_t* varexp, TCut selection);


   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 SetDynamicEntryStatus(const Text_t* name, TGo4DynamicEntryStatus* state, const Text_t* listname=0);


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


      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[];

      static const UInt_t fguSUBFOLDERMAXLEN;

   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; 

      TGo4DynamicList * fxDynamicList; 


      Int_t fiDynListCount;

      Int_t fiDynListInterval;

      Bool_t fbCreatedinMake;    

      Bool_t fbSuppressLoadHistograms;    


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

     void InitPictures(TFolder* fold=0);


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

---