---

/Go4Analysis/TGo4AnalysisObjectManager.cxx

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.
//----------------------------------------------------------------
#include "TGo4AnalysisObjectManager.h"

#include <iostream.h>

#include "TCanvas.h"
#include "TRegexp.h"
#include "TMultiGraph.h"
#include "TKey.h"
#include "TObjArray.h"
#include "TFolder.h"
#include "TList.h"
#include "TThread.h"
#include "TH2.h"
#include "TCanvas.h"
#include "TTree.h"

#include "Go4ThreadManager/TGo4LockGuard.h"
#include "Go4StatusBase/TGo4ObjectStatus.h"
#include "Go4StatusBase/TGo4BranchStatus.h"
#include "Go4StatusBase/TGo4Parameter.h"
#include "Go4ConditionsBase/TGo4Condition.h"
#include "Go4ConditionsBase/TGo4WinCond.h"
#include "Go4ConditionsBase/TGo4PolyCond.h"
#include "Go4DynamicList/TGo4TreeHistogramEntry.h"
#include "Go4DynamicList/TGo4DynamicList.h"
#include "Go4EventServer/TGo4MainTree.h"
#include "Go4StatusAnalysis/TGo4AnalysisObjectNames.h"
#include "Go4StatusAnalysis/TGo4HistogramStatus.h"
#include "Go4StatusAnalysis/TGo4TreeStructure.h"


#include "Go4StatusBase/TGo4Parameter.h"
#include "Go4StatusBase/TGo4Picture.h"
#include "Go4Event/TGo4CompositeEvent.h"
#include "Go4EventServer/Go4EventServer.h"
#include "Go4StatusAnalysis/TGo4ConditionStatus.h"
#include "Go4StatusAnalysis/TGo4ParameterStatus.h"
#include "Go4StatusAnalysis/TGo4PictureStatus.h"
#include "Go4StatusAnalysis/TGo4CanvasStatus.h"
#include "Go4StatusAnalysis/TGo4EventStatus.h"
#include "Go4StatusAnalysis/TGo4EventSourceStatus.h"
#include "Go4StatusAnalysis/TGo4EventStoreStatus.h"
#include "Go4StatusAnalysis/TGo4EventProcStatus.h"
#include "Go4ConditionsBase/TGo4PolyCond.h"
#include "Go4DynamicList/TGo4DynamicList.h"
#include "Go4DynamicList/TGo4DynamicListException.h"
#include "Go4DynamicList/TGo4DynamicListStatus.h"
#include "Go4DynamicList/TGo4HistogramEntryStatus.h"
#include "Go4DynamicList/TGo4TreeHistogramEntryStatus.h"
#include "Go4Analysis/TGo4AnalysisImp.h"

//#include "Go4HistogramServer/TGo4MbsHist.h"

const Text_t TGo4AnalysisObjectManager::fgcTOPDYNAMICLIST[]="Go4DynamicList";
const Text_t TGo4AnalysisObjectManager::fgcTOPFOLDER[]="Go4";
const Text_t TGo4AnalysisObjectManager::fgcHISTFOLDER[]="Histograms";
const Text_t TGo4AnalysisObjectManager::fgcDYNFOLDER[]="DynamicLists";
const Text_t TGo4AnalysisObjectManager::fgcCONDFOLDER[]="Conditions";
const Text_t TGo4AnalysisObjectManager::fgcPARAFOLDER[]="Parameters";
const Text_t TGo4AnalysisObjectManager::fgcTREEFOLDER[]="Trees";
const Text_t TGo4AnalysisObjectManager::fgcPICTFOLDER[]="Pictures";
const Text_t TGo4AnalysisObjectManager::fgcCANVFOLDER[]="Canvases";
const Text_t TGo4AnalysisObjectManager::fgcANALYSISFOLDER[]="EventObjects";
const Text_t TGo4AnalysisObjectManager::fgcEVENTFOLDER[]="Events";
const Text_t TGo4AnalysisObjectManager::fgcSRCFOLDER[]="EventSources";
const Text_t TGo4AnalysisObjectManager::fgcSTOREFOLDER[]="EventStores";
const Text_t TGo4AnalysisObjectManager::fgcPROCFOLDER[]="EventProcessors";
const Text_t TGo4AnalysisObjectManager::fgcUSRFOLDER[]="UserObjects";
const Text_t TGo4AnalysisObjectManager::fgcTMPFOLDER[]="Go4-tmp";

const UInt_t TGo4AnalysisObjectManager::fguSUBFOLDERMAXLEN=1024;

TGo4AnalysisObjectManager::TGo4AnalysisObjectManager(const Text_t* name)
:TNamed(name,"The Go4 Analysis Object Manager"),
      fxGo4Dir(0),fxHistogramDir(0),fxConditionDir(0), fxParameterDir(0),
      fxDynListDir(0),fxUserDir(0), fxAnalysisDir(0), fxTempFolder(0),
      fxMatchList(0), fxMatchIterator(0),
      fxDynamicList(0), fiDynListCount(0), fiDynListInterval(0),
      fbCreatedinMake(kFALSE), fbSuppressLoadHistograms(kFALSE)
{
         fxDirMutex=new TMutex(kTRUE);
         fxGo4Dir=gROOT->GetRootFolder()->AddFolder(fgcTOPFOLDER,"The Go4 Object folder");
         fxGo4Dir->SetOwner(kTRUE); // top go4 dir owns subfolders
         gROOT->GetListOfBrowsables()->Add(fxGo4Dir, fxGo4Dir->GetName());
         fxHistogramDir=fxGo4Dir->AddFolder(fgcHISTFOLDER,"All Histogram objects");
         fxHistogramDir->SetOwner(kTRUE);
         fxConditionDir=fxGo4Dir->AddFolder(fgcCONDFOLDER,"All Condition objects");
         fxConditionDir->SetOwner(kTRUE);
         fxParameterDir=fxGo4Dir->AddFolder(fgcPARAFOLDER,"All Parameter objects");
         fxParameterDir->SetOwner(kTRUE);
         fxDynListDir=fxGo4Dir->AddFolder(fgcDYNFOLDER,"Dynamic List Instances");
         fxDynListDir->SetOwner(kTRUE);
         fxTreeDir=fxGo4Dir->AddFolder(fgcTREEFOLDER,"References to trees");
         fxTreeDir->SetOwner(kFALSE); // tree dir does not own objects,
         fxPictureDir=fxGo4Dir->AddFolder(fgcPICTFOLDER,"Picture objects");
         fxPictureDir->SetOwner(kTRUE);
         fxCanvasDir=fxGo4Dir->AddFolder(fgcCANVFOLDER,"All TCanvases");
         fxCanvasDir->SetOwner(kTRUE);
         fxAnalysisDir=fxGo4Dir->AddFolder(fgcANALYSISFOLDER,"Event objects of current analysis");
         fxAnalysisDir->SetOwner(kTRUE); // owns folders, but not objects in folders
         fxStoreDir=fxAnalysisDir->AddFolder(fgcSTOREFOLDER,"References to event stores");
         fxStoreDir->SetOwner(kFALSE); // event  classes dir does not own objects,
         fxSourceDir=fxAnalysisDir->AddFolder(fgcSRCFOLDER,"References to event sources");
         fxSourceDir->SetOwner(kFALSE); // event  classes dir does not own objects,
         fxProcessorDir=fxAnalysisDir->AddFolder(fgcPROCFOLDER,"References to event processors");
         fxProcessorDir->SetOwner(kFALSE); // event  classes dir does not own objects,
         fxEventDir=fxAnalysisDir->AddFolder(fgcEVENTFOLDER,"References to event structures");
         fxEventDir->SetOwner(kFALSE); // event  classes dir does not own objects,
         fxUserDir=fxGo4Dir->AddFolder(fgcUSRFOLDER,"For User Objects");
         fxGo4Dir->SetOwner(kFALSE);
         fxTempFolder=gROOT->GetRootFolder()->AddFolder(fgcTMPFOLDER,"The Go4 temporary object folder");
         fxTempFolder->SetOwner(kFALSE);
}

TGo4AnalysisObjectManager::TGo4AnalysisObjectManager()
:fxGo4Dir(0),fxHistogramDir(0),fxConditionDir(0),
fxDynListDir(0),fxUserDir(0), fxAnalysisDir(0), fxTempFolder(0),
fxDynamicList(0), fiDynListCount(0), fiDynListInterval(0),
fbCreatedinMake(kFALSE), fbSuppressLoadHistograms(kFALSE)
{
// ctor for streamer only!
}


TGo4AnalysisObjectManager::~TGo4AnalysisObjectManager()
{

delete fxMatchIterator;
delete fxMatchList;
//delete fxDirMutex;
gROOT->GetListOfBrowsables()->Remove(fxGo4Dir);
//cout <<"Removed all folders from list of browsables" << endl;

gROOT->GetRootFolder()->Remove(fxTempFolder);
gROOT->GetRootFolder()->Remove(fxGo4Dir);

fxHistogramDir->Clear();
fxConditionDir->Clear();
fxParameterDir->Clear();
fxDynListDir->Clear();
fxUserDir->Clear();
fxTreeDir->Clear();
fxPictureDir->Clear();
fxCanvasDir->Clear();
fxEventDir->Clear();
fxProcessorDir->Clear();
fxStoreDir->Clear();
fxSourceDir->Clear();
fxGo4Dir->Clear();
fxTempFolder->Clear();
//cout <<"Cleared all folders" << endl;
delete fxTempFolder;
//cout <<"deleted temporary folder" << endl;
delete fxGo4Dir;
//cout <<"deleted top folder" << endl;
}


Bool_t TGo4AnalysisObjectManager::AddObject(TNamed * anything, const Text_t* subfolder, Bool_t replace)
{
TRACE((11,"TGo4AnalysisObjectManager::AddObject(TNamed *)",__LINE__, __FILE__));
   // unspecified objects are only allowed to put into userdir
 return (AddObjectToFolder(anything,fxUserDir,subfolder,replace));
}

Bool_t TGo4AnalysisObjectManager::RemoveObject(const Text_t * name, Bool_t del)
{
   return RemoveObjectFromFolder(name, fxUserDir, del);
}



TNamed * TGo4AnalysisObjectManager::GetObject(const Text_t * name, const Text_t* folder)
{
TRACE((11,"TGo4AnalysisObjectManager::GetObject(Text_t *)",__LINE__, __FILE__));
   //
   TNamed* ob=0;
   TFolder* searchfold;
   if(folder==0 || !strcmp(folder,fgcTOPFOLDER))
      searchfold=fxGo4Dir; // default: search topfolder
   else
      searchfold=FindSubFolder(fxGo4Dir, folder, kFALSE);
   if(searchfold)
      {
      ob= dynamic_cast<TNamed*> (FindObjectInFolder(searchfold, name));
      //cout << "found object in top folder :" << ob  <<endl;
      if(ob && ob->InheritsFrom("TTree")) ob=0; // disable sending tree to gui!
      if(ob && ob->InheritsFrom("TFolder")) ob=0; // disable sending complete folder
      if(ob && ob->InheritsFrom("TGo4EventElement")) ob=0; // disable events
      if(ob && ob->InheritsFrom("TGo4EventSource")) ob=0; // disable events
      if(ob && ob->InheritsFrom("TGo4EventStore")) ob=0; // disable events
      if(ob && ob->InheritsFrom("TGo4EventProcessor")) ob=0; // disable events
      }
   else
      {
         ob=0;
      }
   if(ob)
      {
         TGo4Analysis::Instance()->Message(0,"AnalysisObjectManager - found object %s of class %s",
               ob->GetName(), ob->ClassName());
      }
   else
      {
         TGo4Analysis::Instance()->Message(0,"!!! AnalysisObjectManager - no such object %s !!!",
               name);
      }
   return ob;
}



Bool_t TGo4AnalysisObjectManager::ClearObjects(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::ClearObject(Text_t *)",__LINE__, __FILE__));
Bool_t rev=kTRUE;
TGo4LockGuard  dirguard(fxDirMutex);
TObject* ob= fxGo4Dir->FindObjectAny(name);
if(ob==0)
   {
      //if not found in folder, try to find dynamic entry in list:
      TGo4DynamicEntry* ent=fxDynamicList->GetEntry(name);
      if(ent) 
         {
            ent->Reset();
            rev=kTRUE;
         }
      else
         {
            rev=kFALSE;
         }
   }
else
   {
      if(ob->InheritsFrom("TFolder"))
         {
             TFolder* fold=dynamic_cast<TFolder*>(ob);
             rev=ClearFolder(fold);
         }
      else
         {
             rev=ClearObject(ob);
          }//if(ob->InheritsFrom("TFolder"))
   } // if(ob==0)
return rev;
}


Bool_t TGo4AnalysisObjectManager::DeleteObjects(const Text_t * name)
{
Bool_t rev=kTRUE;
TGo4LockGuard  dirguard(fxDirMutex);
TObject* ob= fxGo4Dir->FindObjectAny(name);
if(ob==0)
   {
      rev=kFALSE;
   }
else
   {
      if(ob->InheritsFrom("TFolder"))
         {
             TFolder* fold=dynamic_cast<TFolder*>(ob);
             rev=DeleteFolder(fold);
         }
      else
         {
             rev=DeleteObject(ob);
          }//if(ob->InheritsFrom("TFolder"))
   } // if(ob==0)
return rev;



}


Bool_t TGo4AnalysisObjectManager::ProtectObjects(const Text_t* name, const Option_t* flags)
{
Bool_t rev=kTRUE;
TGo4LockGuard  dirguard(fxDirMutex);
TObject* ob= fxGo4Dir->FindObjectAny(name);
if(ob==0)
   {
      rev=kFALSE;
   }
else
   {
      if(ob->InheritsFrom("TFolder"))
         {
             TFolder* fold=dynamic_cast<TFolder*>(ob);
             rev=ProtectFolder(fold, flags);
         }
      else
         {
             rev=ProtectObject(ob, flags);
          }//if(ob->InheritsFrom("TFolder"))
   } // if(ob==0)
return rev;      
}



TFolder * TGo4AnalysisObjectManager::CreateBranchFolder(TObjArray* branchlist, const Text_t* name, const Text_t* title, Bool_t istopbranch)
{
   TRACE((11,"TGo4AnalysisObjectManager::CreateBranchFolder(TObjArray*)",__LINE__, __FILE__));
   TFolder* fold=0;
   if(branchlist)
      {
         TFolder* subnames=0;
         TList* nameslist= new TList;
         TIterator* listiter=branchlist->MakeIterator();
         TObject* entry;
         TGo4ObjectStatus* state;
         Int_t cursor=0;
         while((entry=listiter->Next()) !=0)
            {
               if(entry->InheritsFrom("TBranch"))
                  {
                      // found subfolder, process it recursively
                      TBranch* subbranch= dynamic_cast<TBranch*> (entry);
                      TObjArray* subbranchlist=subbranch->GetListOfBranches();
                      if(subbranchlist)
                         {
                            if(subbranchlist->IsEmpty())
                               {
                                 // subbranchlist is empty, add status object to folder
                                    state=new TGo4BranchStatus(subbranch);
                                    nameslist->AddLast(state);
                               }
                            else
                               {
                                  // found subbranchlist
                                  // test for composite event:
                                   TClass* cl=gROOT->GetClass(subbranch->GetClassName());
                                   if(cl  && cl->InheritsFrom("TGo4CompositeEvent") && istopbranch)
                                    {
                                       // search for composite event of that name in Go4 (only if top level call)
                                       TGo4CompositeEvent* cevent=0;
                                       TString branchname(subbranch->GetName());
                                       Ssiz_t leng = branchname.Length();
                                       branchname.Resize(leng-1); // strip dot from branchname
                                       //cout <<"searching for composite event "<< branchname.Data() << endl;
                                       cevent = dynamic_cast<TGo4CompositeEvent*> (GetEventStructure(branchname.Data()));

                                       if(cevent)
                                        {
                                           //cout <<"found top comp event" << endl;
                                           Int_t skippedentries=0;
                                           // we pass complete top branchlist to method
                                           subnames=CreateCompositeBranchFolder(
                                                branchlist,cevent,cursor+1,
                                                     &skippedentries,
                                                    cevent->GetName(),
                                                    cevent->GetTitle());
                                           // skip comp subelements in iterator:
                                            //cout <<"top skipped:"<<skippedentries<< endl;
                                           // now process subbranchlist  of top compevent,
                                           // add members of this folder to existing folder subnames!
                                           TFolder* temp=CreateBranchFolder(subbranchlist,
                                                    "dummy",
                                                    "dummy");
                                           subnames->GetListOfFolders()->AddAll(temp->GetListOfFolders());

                                           for(Int_t t=0;t<skippedentries;++t)
                                              {
                                                 listiter->Next();
                                                 cursor++;
                                              }

                                        }
                                       else
                                        {
                                           //cout <<"not found top comp event" << endl;
                                           subnames=CreateBranchFolder(subbranchlist,
                                                    subbranch->GetName(),
                                                    subbranch->GetTitle());
                                        }
                                    } // if (cl  && cl->InheritsFrom("TGo4CompositeEvent"))
                                  else
                                     {
                                        //cout <<"no class or not top branch" << endl;
                                        subnames=CreateBranchFolder(subbranchlist,
                                                    subbranch->GetName(),
                                                    subbranch->GetTitle());
                                     }
                                  nameslist->AddLast(subnames);
                               } // if(subbranchlist->IsEmpty())
                         }
                     else
                        {
                           // no subbranchlist, should not happen...
                           // add status object to folder
                           state=new TGo4BranchStatus(subbranch);
                           nameslist->AddLast(state);
                        } // if(subbranchlist)
                  }
               else
                  {

                  } //if(entry->InheritsFrom("TBranch"))
                cursor++;
            } // while((entry=listiter->Next()) !=0)
         fold=fxTempFolder->AddFolder(name,title,nameslist);
         fold->SetOwner(kTRUE);
         fxTempFolder->Remove(fold);
         delete listiter;
        }
      else
         {   } // if(branchlist)

   return fold;
}
TFolder * TGo4AnalysisObjectManager::CreateCompositeBranchFolder(TObjArray* branchlist,
                                           TGo4CompositeEvent* compevent,
                                           Int_t startindex, Int_t* skip,
                                           const Text_t* name, const Text_t* title)
{
   TRACE((11,"TGo4AnalysisObjectManager::CreateCompositeBranchFolder(TObjArray*,...)",__LINE__, __FILE__));
   TFolder* fold=0;
   TFolder* subnames=0;
   if(branchlist)
      {
         TList* nameslist= new TList;
         TGo4ObjectStatus* state;
         TObjArray* csubevents=0;
         Int_t lastindex=0;
         if(compevent)
            {
               csubevents=compevent->getListOfComposites();
               if(startindex==1)
                  {
                     lastindex=startindex+branchlist->GetLast(); // top event: scan everything

                  }
               else
                  {
                     lastindex=startindex+compevent->getNElements(); // subevent: scan only own members
                  }
                //cout <<"startindex:"<<startindex <<" lastindex:"<<lastindex << endl;
            }
         else
            {
               //cout <<"CreateCompsositeBranchFolder Error: no composite event" << endl;
               return (CreateBranchFolder(branchlist,name,title));
            }
         Int_t skippedentries=0;
         Int_t offset=0;
         for(Int_t i=startindex; i<lastindex;i++)
            {
            //cout <<"i+offset="<<i+offset << endl;
            TClass* cl=0;
            TObject* entry=branchlist->At(i+offset);
            if(entry && entry->InheritsFrom("TBranch"))
               {
                         // found subfolder, process it recursively
               TBranch* currentbranch= dynamic_cast<TBranch*> (entry);
               TObjArray* currentbranchlist=0;
               if (currentbranch)
                  {
                     currentbranchlist=currentbranch->GetListOfBranches();
                     cl=gROOT->GetClass(currentbranch->GetClassName());
                  }
               else {}
               if(cl  && cl->InheritsFrom("TGo4CompositeEvent"))
                  {
                  // subevent is also composite event, treat next n branches as subbranches:
                  TGo4CompositeEvent* subevent=0;
                  TString branchname(currentbranch->GetName());
                  Ssiz_t leng = branchname.Length();
                  branchname.Resize(leng-1); // strip dot from branchname
                  //cout <<"searching for composite sub event "<< branchname.Data() << endl;
                  if(csubevents)
                     {
                        subevent = dynamic_cast<TGo4CompositeEvent *>(csubevents->FindObject(branchname.Data()));
                     }
                  else
                     {   }
                  if(subevent && subevent->getNElements()>0)
                     {
                         //cout <<"found composite subevent "<< subevent->GetName() << endl;
                         // found subbranch, add it to folder struct

                         subnames=CreateCompositeBranchFolder(branchlist,
                                                          subevent,
                                                          i+offset+1, &skippedentries,
                                                          subevent->GetName(),
                                                          subevent->GetTitle());
                         nameslist->AddLast(subnames);
                         offset+=skippedentries;
                         //cout <<"skipped:"<<skippedentries<<", i:"<<i << endl;
                         //cout <<"offset:"<<offset<< endl;
                         // now process subbranchlist currentbranchlist of compevent,
                         // add members of this folder to existing folder subnames!
                         TFolder* temp=CreateBranchFolder(currentbranchlist,
                                                    "dummy",
                                                    "dummy");
                         subnames->GetListOfFolders()->AddAll(temp->GetListOfFolders());


                     }
                  else
                     {
                         //cout <<"composite subevent is basic member..." << endl;
                         // subevent not in list, normal operation:
                        //state=new TGo4ObjectStatus(dynamic_cast<TNamed*> (entry) );
                        //nameslist->AddLast(state);
                        if(currentbranchlist)
                         {
                            if(currentbranchlist->IsEmpty())
                               {
                                 // subbranchlist is empty, add status object to folder
                                    state=new TGo4BranchStatus(currentbranch);
                                    nameslist->AddLast(state);
                               }
                            else
                               {
                                 subnames=CreateBranchFolder(currentbranchlist,
                                                    currentbranch->GetName(),
                                                    currentbranch->GetTitle());
                                 nameslist->AddLast(subnames);
                               }
                         } // if(currentbranchlist)
                     } //if(subevent && subevent->getNElements()>0)

               }   //  if(cl  && cl->InheritsFrom("TGo4CompositeEvent"))
            else
               {
                  // subevent is not a composite event, normal operation:
//                  state=new TGo4ObjectStatus(dynamic_cast<TNamed*> (entry) );
//                  nameslist->AddLast(state);
                  if(currentbranchlist)
                         {
                            if(currentbranchlist->IsEmpty())
                               {
                                 // subbranchlist is empty, add status object to folder
                                    state=new TGo4BranchStatus(currentbranch);
                                    nameslist->AddLast(state);
                               }
                            else
                               {
                                 subnames=CreateBranchFolder(currentbranchlist,
                                                    currentbranch->GetName(),
                                                    currentbranch->GetTitle());
                                 nameslist->AddLast(subnames);
                               }
                     }
                  //cout <<"added entry"<< entry->GetName() << endl;
               }
            }
            else
               {
                  break;
//                  if(entry)
//                     cout <<"ERROR: no branch in branchlist, class:"<< entry->ClassName() << endl;
//                  else
//                     cout << "ZERO entry in branchlist"<< endl;

               } //if(entry->InheritsFrom("TBranch"))
         } // for()
         *skip=lastindex+offset-startindex;
         fold=fxTempFolder->AddFolder(name,title,nameslist);
         fold->SetOwner(kTRUE);
         fxTempFolder->Remove(fold);
        }
      else
         {   } // if(branchlist)

   return fold;

}
TGo4TreeStructure * TGo4AnalysisObjectManager::CreateTreeStructure(TTree* thetree)
{
TRACE((11,"TGo4AnalysisObjectManager::CreateTreeStructure(TTree*)",__LINE__, __FILE__));
   //
   TGo4TreeStructure* tstructure=0;
   if(thetree)
      {
         const Text_t* treename=thetree->GetName();
         const Text_t* treetitle=thetree->GetTitle();
         TGo4Analysis::Instance()->Message(0,"AnalysisObjectManager - creating structure of tree %s",
                treename);
         TObjArray* branchlist=thetree->GetListOfBranches();
         tstructure= new TGo4TreeStructure(treename);
         tstructure->fxTopFolder=CreateBranchFolder(branchlist,treename,treetitle, kTRUE);
      }
   else {}
   return tstructure;
}

TGo4TreeStructure * TGo4AnalysisObjectManager::CreateTreeStructure(const Text_t* treename)
{
TRACE((11,"TGo4AnalysisObjectManager::CreateTreeStructure(const Text_t *)",__LINE__, __FILE__));
   TTree* thetree=0;
   if(fxTreeDir)
      {
         thetree=dynamic_cast<TTree*> (fxTreeDir->FindObjectAny(treename));
      }
   else
      {
         thetree=0;
      }
   return (CreateTreeStructure(thetree));

}


Bool_t TGo4AnalysisObjectManager::AddHistogram(TH1 * his, const Text_t* subfolder, Bool_t replace)
{
TRACE((11,"TGo4AnalysisObjectManager::AddHistogram(TH1*)",__LINE__, __FILE__));
   Bool_t rev=AddObjectToFolder(his,fxHistogramDir,subfolder,replace,kTRUE);
   // for histograms: add with unique object names within histogramdir
   // to avoid errors in TTree::Draw()
   if(rev && his) his->SetDirectory(gROOT); // assign histo to the top dir, no file!
   return rev;
}

TH1* TGo4AnalysisObjectManager::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,
                                       const Text_t* xtitle,
                                       const Text_t* ytitle) {

   TString htype(histotype);
   htype.ToUpper();
   if (htype.Length()==0) htype = "I";
   TClass* cl = 0;

   switch (htype[0]) {
     case 'C' : cl = TH1C::Class(); break;
     case 'D' : cl = TH1D::Class(); break;
     case 'F' : cl = TH1F::Class(); break;
     case 'I' : cl = TH1I::Class(); break;
     case 'S' : cl = TH1S::Class(); break;
     default : cl = TH1I::Class();
   }

   TH1* histo = (TH1*) TestObject(fxHistogramDir, foldername, histoname, cl);

   if (histo) return histo;

   switch(htype[0]) {
      case 'C' : histo = new TH1C(histoname, histoname, nbinsx, xlow, xup); break;
      case 'D' : histo = new TH1D(histoname, histoname, nbinsx, xlow, xup); break;
      case 'F' : histo = new TH1F(histoname, histoname, nbinsx, xlow, xup); break;
      case 'I' : histo = new TH1I(histoname, histoname, nbinsx, xlow, xup); break;
      case 'S' : histo = new TH1S(histoname, histoname, nbinsx, xlow, xup); break;
      default :  histo = new TH1I(histoname, histoname, nbinsx, xlow, xup);
   }

   if (title) histo->SetTitle(title);
   if (xtitle) histo->SetXTitle(xtitle);
   if (ytitle) histo->SetYTitle(ytitle);
   AddHistogram(histo, foldername);
   return histo;
}

TH2* TGo4AnalysisObjectManager::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,
                                       const Text_t* xtitle,
                                       const Text_t* ytitle) {
   TString htype(histotype);
   htype.ToUpper();
   if (htype.Length()==0) htype = "I";

   TClass* cl = 0;

   switch (htype[0]) {
     case 'C' : cl = TH2C::Class(); break;
     case 'D' : cl = TH2D::Class(); break;
     case 'F' : cl = TH2F::Class(); break;
     case 'I' : cl = TH2I::Class(); break;
     case 'S' : cl = TH2S::Class(); break;
     default : cl = TH2I::Class();
   }

   TH2* histo = (TH2*) TestObject(fxHistogramDir, foldername, histoname, cl);

   if (histo) return histo;

   switch(htype[0]) {
      case 'C' : histo = new TH2C(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup); break;
      case 'D' : histo = new TH2D(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup); break;
      case 'F' : histo = new TH2F(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup); break;
      case 'I' : histo = new TH2I(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup); break;
      case 'S' : histo = new TH2S(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup); break;
      default :  histo = new TH2I(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
   }

   if (title) histo->SetTitle(title);
   if (xtitle) histo->SetXTitle(xtitle);
   if (ytitle) histo->SetYTitle(ytitle);
   AddHistogram(histo, foldername);
   return histo;
}

Bool_t TGo4AnalysisObjectManager::AddTree(TTree* tree, const Text_t* subfolder)
{
TRACE((11,"TGo4AnalysisObjectManager::AddTree(TTree*, Text_t*)",__LINE__, __FILE__));
  return (AddObjectToFolder(tree,fxTreeDir,subfolder,kFALSE));
}

Bool_t TGo4AnalysisObjectManager::RemoveTree(TTree * tree, const Text_t* stepname)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveTree(TTree*, Text_t*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(tree)
      {
               TGo4LockGuard listguard(fxDirMutex);
                  fxTreeDir->Remove(tree);
                  // later: we use directory with name stepname to put tree in
      }
   else
      {
         rev=kFALSE;
      }
   return rev;
}
TH1* TGo4AnalysisObjectManager::GetHistogram(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetHistogram(Text_t *)",__LINE__, __FILE__));
   TH1* rev= dynamic_cast<TH1*> (FindObjectInFolder(fxHistogramDir, name));
   if(rev==0) rev= dynamic_cast<TH1*> (FindObjectInFolder(fxUserDir, name)); // also check user objects dir
   return rev;
}

TTree * TGo4AnalysisObjectManager::GetTree(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetTree(Text_t *)",__LINE__, __FILE__));
  return dynamic_cast<TTree*> (FindObjectInFolder(fxTreeDir, name));
}

Bool_t TGo4AnalysisObjectManager::RemoveHistogram(const Text_t * name, Bool_t del)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveHistogram(Text_t*)",__LINE__, __FILE__));
   //
   return RemoveObjectFromFolder(name, fxHistogramDir, del);
}


Bool_t TGo4AnalysisObjectManager::AddAnalysisCondition(TGo4Condition * con, const Text_t* subfolder)
{
TRACE((11,"TGo4AnalysisObjectManager::AddAnalysisCondition(TGo4Condition *)",__LINE__, __FILE__));
return(AddObjectToFolder(con,fxConditionDir,subfolder,kTRUE));
}

Bool_t TGo4AnalysisObjectManager::SetAnalysisCondition(const Text_t * name, TGo4Condition* con,
                                   Bool_t counter, TFolder* parent)
{
TRACE((11,"TGo4AnalysisObjectManager::SetAnalysisCondition(Text_t*, TGo4Condition*, Bool_t)",__LINE__, __FILE__));
TGo4LockGuard   listguard(fxDirMutex);
Bool_t rev=kFALSE;
TFolder* topfolder=0;
if(parent)
   topfolder=parent;
else
   topfolder=fxConditionDir;
if(con)
   {
      TObject* searchresult=topfolder->FindObjectAny(name);
      if(searchresult==0)
         searchresult=fxUserDir->FindObjectAny(name);
         // condition may be under user objects folder if not found in topfolder
      TGo4Condition* oldcon;
      if(searchresult && searchresult->InheritsFrom("TGo4Condition"))
         {
            oldcon= dynamic_cast<TGo4Condition *> (searchresult);
         }
      else if (searchresult && searchresult->InheritsFrom("TFolder"))
         {
            // this is for the case that condition has same name as its folder!
            TFolder* subf=dynamic_cast<TFolder*>(searchresult);
            searchresult=subf->FindObjectAny(name);
            oldcon= dynamic_cast<TGo4Condition *> (searchresult);
         }
      else
         {
             oldcon=0;
         }
      if(oldcon!=0)
         {
            // update existing condition of given name
            rev=oldcon->UpdateFrom(con,counter);
            //cout << "++++ Updated condition "<< name<<" from condition "<< con->GetName() << endl;
            //oldcon->PrintCondition(true);
         }
      else
         {
            // condition not yet exisiting, add external condition
             TGo4Condition* clonedcon= dynamic_cast<TGo4Condition*>(con->Clone());
             TGo4PolyCond::CleanupSpecials(); // remove reference to cloned cut
             // find out destination folder for new condition from name:
            Text_t subfolder[fguSUBFOLDERMAXLEN];
            size_t fnamelen=0;
            const char* endname = name;
            const char* foldername = name;
            while (endname!=0)
               {
                  endname=strstr(foldername,"/");
                  if(endname==0) break;
                  clonedcon->SetName(endname+1);
                  fnamelen= endname-name; // length of path string
                  //cout <<"SetAnalysiscondition: namelen="<< (Int_t) fnamelen << endl;
                  foldername=endname+1;
               }

             if(fnamelen>0)
                {
                   // we have a subfolder for condition
                   if(fnamelen>fguSUBFOLDERMAXLEN) fnamelen=fguSUBFOLDERMAXLEN;
                   snprintf(subfolder,fnamelen+1,"%s",name);
                   rev=AddObjectToFolder(clonedcon,topfolder,subfolder,kTRUE,kFALSE,kFALSE);
                   //cout << "++++ Added new condition "<< clonedcon->GetName()<<" to folder "<<topfolder->GetName()<<"/"<< subfolder << endl;
                }
             else
                {
                   // no subfolder, condition is directly under topfolder
                   rev=AddObjectToFolder(clonedcon,topfolder,0,kTRUE,kFALSE,kFALSE);
                   //cout << "++++ Added new condition "<< clonedcon->GetName()<<" to folder "<<topfolder->GetName()<<", no subfolder!!!"<< endl;
                }
         }
   }
else
   {
      rev=kFALSE;
   }
return rev;
}

TGo4Condition * TGo4AnalysisObjectManager::GetAnalysisCondition(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetAnalysisCondition(Text_t*)",__LINE__, __FILE__));
   TGo4Condition* cond = dynamic_cast<TGo4Condition *> (FindObjectInFolder(fxConditionDir, name));
   if(cond==0) cond=dynamic_cast<TGo4Condition *> (FindObjectInFolder(fxUserDir, name));
      // some users have their conditions rather in user folder...
   return cond;
}

TGo4WinCond* TGo4AnalysisObjectManager::MakeWindowCond(const Text_t* foldername,
                                                       const Text_t* conditionname,
                                                       Double_t      xlow,
                                                       Double_t      xup,
                                                       const Text_t* bindhistogram,
                                                       Bool_t        invert) {
   TGo4WinCond* wcond = (TGo4WinCond*)
     TestObject(fxConditionDir, foldername, conditionname, TGo4WinCond::Class());

   if (wcond) return wcond;

   wcond = new TGo4WinCond(conditionname);
   wcond->SetValues(xlow, xup);
   if (bindhistogram!=0)
     wcond->SetHistogram(bindhistogram);
   if (invert) wcond->Invert(invert);
   AddAnalysisCondition(wcond, foldername);
   return wcond;
}

TGo4WinCond* TGo4AnalysisObjectManager::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,
                                                       Bool_t      invert) {
   TGo4WinCond* wcond = (TGo4WinCond*)
     TestObject(fxConditionDir, foldername, conditionname, TGo4WinCond::Class());

   if (wcond) return wcond;

   wcond = new TGo4WinCond(conditionname);
   wcond->SetValues(xlow, xup, ylow, yup);
   if (bindhistogram!=0)
     wcond->SetHistogram(bindhistogram);
   if (invert) wcond->Invert(invert);
   AddAnalysisCondition(wcond, foldername);
   return wcond;
}

TGo4PolyCond* TGo4AnalysisObjectManager::MakePolyCond(const Text_t* foldername,
                                                      const Text_t* conditionname,
                                                      Int_t         size,
                                                      Float_t      (*points)[2],
                                                      const Text_t* bindhistogram,
                                                      Bool_t        invert)
{
   TGo4PolyCond* pcond = (TGo4PolyCond*)
      TestObject(fxConditionDir, foldername, conditionname, TGo4PolyCond::Class());

   if (pcond) return pcond;

   Float_t fullx[size+1], fully[size+1];
   int numpoints = size;

   for (int i=0;i<numpoints;i++) {
     fullx[i] = points[i][0];
     fully[i] = points[i][1];
   }

   // connect first and last points
   if ((fullx[0]!=fullx[numpoints-1]) || (fully[0]!=fully[numpoints-1])) {
      fullx[numpoints] = fullx[0];
      fully[numpoints] = fully[0];
      numpoints++;
   }

   TCutG mycat("initialcut", numpoints, fullx, fully);
   pcond = new TGo4PolyCond(conditionname);
   pcond->SetValues(&mycat);
   if (bindhistogram!=0)
     pcond->SetHistogram(bindhistogram);
   if (invert) pcond->Invert(invert);
   AddAnalysisCondition(pcond, foldername);
   return pcond;
}


Bool_t TGo4AnalysisObjectManager::RemoveAnalysisCondition(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveAnalysisCondition(Text_t*)",__LINE__, __FILE__));
   return RemoveObjectFromFolder(name, fxConditionDir, kTRUE);
}

TGo4ObjectStatus * TGo4AnalysisObjectManager::CreateObjectStatus(const Text_t * name, const Text_t* folder)
{
   TNamed* object=GetObject(name, folder);
   return CreateObjectStatus(object);
}

TGo4ObjectStatus * TGo4AnalysisObjectManager::CreateObjectStatus(TObject* ob, Bool_t fullinfo)
{
if(ob==0) return 0;
TGo4ObjectStatus* state=0;
if(ob->InheritsFrom("TH1"))
   {
       // found histogram
       TH1* his= dynamic_cast<TH1*> (ob);
       state=new TGo4HistogramStatus(his,fullinfo);
  }
 else if(ob->InheritsFrom("TGo4Condition"))
   {
       TGo4Condition* cond= dynamic_cast<TGo4Condition*> (ob);
       state=new TGo4ConditionStatus(cond);
   }
else if(ob->InheritsFrom("TGo4Parameter"))
   {
       TGo4Parameter* par= dynamic_cast<TGo4Parameter*> (ob);
       state=new TGo4ParameterStatus(par);
   }
else if(ob->InheritsFrom("TGo4Picture"))
   {
       TGo4Picture* par= dynamic_cast<TGo4Picture*> (ob);
       state=new TGo4PictureStatus(par);
   }
 else if(ob->InheritsFrom("TCanvas"))
   {
       TCanvas* can= dynamic_cast<TCanvas*> (ob);
       state=new TGo4CanvasStatus(can,kTRUE);
   }
 else if(ob->InheritsFrom("TGo4EventElement"))
   {
       TGo4EventElement* ev= dynamic_cast<TGo4EventElement*> (ob);
       state=new TGo4EventStatus(ev);
   }
else if(ob->InheritsFrom("TGo4EventSource"))
   {
       TGo4EventSource* ev= dynamic_cast<TGo4EventSource*> (ob);
       state=new TGo4EventSourceStatus(ev);
   }
else if(ob->InheritsFrom("TGo4EventStore"))
   {
       TGo4EventStore* ev= dynamic_cast<TGo4EventStore*> (ob);
       state=new TGo4EventStoreStatus(ev);
   }
else if(ob->InheritsFrom("TGo4EventProcessor"))
   {
       TGo4EventProcessor* ev= dynamic_cast<TGo4EventProcessor*> (ob);
       state=new TGo4EventProcStatus(ev);
   }
else
   {
      state=new TGo4ObjectStatus(dynamic_cast<TNamed*> (ob) );
   }
return state;
}

TGo4AnalysisObjectNames * TGo4AnalysisObjectManager::CreateNamesList()
{
TRACE((11,"TGo4AnalysisObjectManager::CreateNamesList()",__LINE__, __FILE__));
   TGo4LockGuard   listguard(fxDirMutex);
   TGo4AnalysisObjectNames* namesobject=0;
   //fxTempFolder->Clear();
   namesobject= new TGo4AnalysisObjectNames("Go4NamesList");
   namesobject->fxTopFolder=CreateNamesFolder(fxGo4Dir);
   TGo4PolyCond::CleanupSpecials(); // remove references to cloned TCutG in status
   return namesobject;
}
TFolder * TGo4AnalysisObjectManager::CreateNamesFolder(TFolder * objectfolder)
{
   TRACE((11,"TGo4AnalysisObjectManager::CreateNamesFolder(TFolder*)",__LINE__, __FILE__));
   TFolder* namesfolder=0;
   if(objectfolder)
      {
         TList* nameslist= new TList;
         TList* objectlist=dynamic_cast<TList*> (objectfolder->GetListOfFolders());
         TIterator* listiter=objectlist->MakeIterator();
         TObject* entry;
         TGo4ObjectStatus* state;
         while((entry=listiter->Next()) !=0)
            {
               if(entry->InheritsFrom("TFolder"))
                  {
                      // found subfolder, process it recursively
                      //cout <<"##### parsing folder "<< entry->GetName() << endl;
                      TFolder* subobj= dynamic_cast<TFolder*> (entry);
                      TFolder* subnames=CreateNamesFolder(subobj);
                      nameslist->AddLast(subnames);
                  }
                else if (entry->InheritsFrom("TTree"))
                   {
                      // treestructure should be ObjectStatus?
                      TTree* subobj= dynamic_cast<TTree*> (entry);
                      TGo4TreeStructure* treestruct=CreateTreeStructure(subobj);
                      nameslist->AddLast(treestruct);
                   }
                 else if (entry->InheritsFrom("TGo4DynamicList"))
                   {
                      TGo4DynamicList* subobj= dynamic_cast<TGo4DynamicList*> (entry);
                      TGo4DynamicListStatus* dynstat=
                            dynamic_cast<TGo4DynamicListStatus*> ( subobj->CreateStatus() );
                      nameslist->AddLast(dynstat->GetTopFolder(kTRUE));
                      delete dynstat;
                      // after the top folder is adopted by the nameslist,
                      // we do not need the dynmic list status object itself, avoid leak!
                   }
                else
                   {
                     state=CreateObjectStatus(entry,kFALSE); // do not use full status info for nameslist
                     if(state==0) continue;
                     if(state->InheritsFrom("TGo4EventStatus"))
                        {
                           TGo4EventStatus* evstate=dynamic_cast<TGo4EventStatus*>(state);
                           nameslist->AddLast(evstate->GetTopFolder(kTRUE));
                           delete evstate;
                        }
                     else
                        {
                           nameslist->AddLast(state);
                        }
                  }
            } // while
         namesfolder=fxTempFolder->AddFolder(objectfolder->GetName(),objectfolder->GetTitle(),nameslist);
         fxTempFolder->Remove(namesfolder);
         namesfolder->SetOwner(kTRUE);
         delete listiter;
      }
   else
      {
         namesfolder=0;
      }

   return namesfolder;
}

TFolder * TGo4AnalysisObjectManager::GetObjectFolder()
{
   return fxGo4Dir;
}




Bool_t TGo4AnalysisObjectManager::AddEventStore(TGo4EventStore * store)
{
TRACE((11,"TGo4AnalysisObjectManager::AddEventStore(TGo4EventStore*)",__LINE__, __FILE__));
 return (AddObjectToFolder(store,fxStoreDir,0,kFALSE));
}
Bool_t TGo4AnalysisObjectManager::RemoveEventStore(TGo4EventStore * store)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveEventStore(TGo4EventStore*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(store)
      {
         TGo4LockGuard listguard(fxDirMutex);
            fxStoreDir->Remove(store);
            rev=kTRUE;
      }
   else
      {
         rev=kFALSE;
      }
   return rev;
}

Bool_t TGo4AnalysisObjectManager::AddEventSource(TGo4EventSource * source)
{
TRACE((11,"TGo4AnalysisObjectManager::AddEventSource(TGo4EventSource*)",__LINE__, __FILE__));
 return (AddObjectToFolder(source,fxSourceDir,0,kFALSE));
}

Bool_t TGo4AnalysisObjectManager::RemoveEventSource(TGo4EventSource* source)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveEventSource(TGo4EventSource*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(source)
      {
         TGo4LockGuard listguard(fxDirMutex);
            fxSourceDir->Remove(source);
            rev=kTRUE;
      }
   else
      {
         rev=kFALSE;
      }
   return rev;
}
Bool_t TGo4AnalysisObjectManager::AddEventProcessor(TGo4EventProcessor * pro)
{
TRACE((11,"TGo4AnalysisObjectManager::AddEventProcessor(TGo4EventProcessor*)",__LINE__, __FILE__));
  return (AddObjectToFolder(pro,fxProcessorDir,0,kFALSE));
}

Bool_t TGo4AnalysisObjectManager::RemoveEventProcessor(TGo4EventProcessor * pro)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveEventProcessor(TGo4EventProcessr*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(pro)
      {
         TGo4LockGuard listguard(fxDirMutex);
            fxProcessorDir->Remove(pro);
            rev=kTRUE;
      }
   else
      {
         rev=kFALSE;
      }
   return rev;
}
Bool_t TGo4AnalysisObjectManager::AddEventStructure(TGo4EventElement * ev)
{
TRACE((11,"TGo4AnalysisObjectManager::AddEventStructure(TGo4EventElement*)",__LINE__, __FILE__));
  return (AddObjectToFolder(ev,fxEventDir,0,kFALSE));
}

Bool_t TGo4AnalysisObjectManager::RemoveEventStructure(TGo4EventElement * ev)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveEventStructure(TGo4EventElement*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(ev) {
      TGo4LockGuard listguard(fxDirMutex);
      fxEventDir->Remove(ev);
      // remove pointers to event data from all dynamic lists:
      TObject* dl=0;
      TIter iter(fxDynListDir->GetListOfFolders());
      while((dl=iter())!=0) {
         TGo4DynamicList* dynlist= dynamic_cast<TGo4DynamicList*>(dl);
         if(dynlist)
            dynlist->CleanupEvent(ev);
      }
      rev=kTRUE;
   } else {
      rev=kFALSE;
   }
   return rev;
}
TGo4EventElement * TGo4AnalysisObjectManager::GetEventStructure(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetEvenStructure(Text_t *)",__LINE__, __FILE__));
   return dynamic_cast<TGo4EventElement*> (FindObjectInFolder(fxEventDir, name));
}

Bool_t TGo4AnalysisObjectManager::AddDynamicList(TGo4DynamicList * list)
{
TRACE((11,"TGo4AnalysisObjectManager::AddDynamicList(TGo4DynamicList *)",__LINE__, __FILE__));
  return (AddObjectToFolder(list,fxDynListDir,0,kTRUE));

}

void TGo4AnalysisObjectManager::RemoveDynamicList(TGo4DynamicList* list)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveDynamicList(TGo4DynamicList*)",__LINE__, __FILE__));
   fxDynListDir->Remove(list);
}

Bool_t TGo4AnalysisObjectManager::RemoveDynamicList(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveDynamicList(Text_t*)",__LINE__, __FILE__));
   return RemoveObjectFromFolder(name, fxDynListDir, kTRUE);
}

TGo4DynamicList * TGo4AnalysisObjectManager::GetDynamicList(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetDynamicList(Text_t*)",__LINE__, __FILE__));
   return dynamic_cast<TGo4DynamicList *> (FindObjectInFolder(fxDynListDir, name));
}

Bool_t TGo4AnalysisObjectManager::ResetBackStores()
{
TRACE((11,"TGo4AnalysisObjectManager::ResetBackStores()",__LINE__, __FILE__));
   Bool_t rev=kTRUE;
// now reset all backstore instances:
   TList* objectlist=dynamic_cast<TList*> (fxStoreDir->GetListOfFolders());
   TIterator* listiter=objectlist->MakeIterator();
   TObject* entry;
   while((entry=listiter->Next()) !=0)
      {
         if(entry->InheritsFrom("TGo4BackStore"))
            {
               TGo4BackStore* bs= dynamic_cast<TGo4BackStore*>(entry);
               if(bs)
                  {
                     bs->Reset();
                     //
                     //TGo4Log::Debug(" Analysis Object Manager has reset backstore %s",bs->GetName());
                  }
               else   {}
            }
         else {}
      } // while
   delete listiter;
   return rev;
}

void TGo4AnalysisObjectManager::CloseAnalysis()
{
TRACE((14,"TGo4AnalysisObjectManager::CloseAnalysis()",__LINE__, __FILE__));
   fxDynamicList->Reset();
   fiDynListCount=0;
   TGo4Analysis::Instance()->Message(0,"Analysis Object Manager  --  Dynamic List was reset.");
}

void TGo4AnalysisObjectManager::SaveObjects(TFile* file)
{
   if(!file) return;
   TGo4Analysis::Instance()->Message(0,"Analysis Object Manager  --  Saving objects to file %s",file->GetName());
   fxGo4Dir->RecursiveRemove(fxTreeDir); // do not save the trees twice!
   fxGo4Dir->RecursiveRemove(fxAnalysisDir); // do not save eventclass refs
   //fxGo4Dir->Write(0, TObject::kOverwrite);
   TDirectory* savdir=gDirectory;
   file->cd();
   // file->Delete("T*;*"); // remove old contents (get rid of deleted dynamic objects)
   // note: we always use RECREATE option on saving now. No need to cleanup old file!
   SaveFolder(fxGo4Dir);
   file->Write(0,TObject::kOverwrite); // write all appended objects and subdirs
   savdir->cd();
   RemoveFromDir(fxGo4Dir,file); // prevent object deletion on closing the file
   fxGo4Dir->Add(fxTreeDir);
   fxGo4Dir->Add(fxAnalysisDir);
}
Bool_t TGo4AnalysisObjectManager::AddParameter(TGo4Parameter * par, const Text_t* subfolder)
{
TRACE((11,"TGo4AnalysisObjectManager::AddParameter(TGo4Parameter *)",__LINE__, __FILE__));
   return (AddObjectToFolder(par,fxParameterDir,subfolder,kTRUE));
}

Bool_t TGo4AnalysisObjectManager::SetParameter(const Text_t * name, TGo4Parameter * par, TFolder* parent)
{
TRACE((11,"TGo4AnalysisObjectManager::SetParameter(Text_t*, TGo4Parameter*)",__LINE__, __FILE__));
Bool_t rev=kFALSE;
TFolder* topfolder=0;
if(parent)
   topfolder=parent;
else
   topfolder=fxParameterDir;
if(par)
   {
      TGo4Parameter* oldpar= dynamic_cast<TGo4Parameter *> (topfolder->FindObjectAny(name));
      if(oldpar!=0)
         {
            // update existing parameter of given name
            rev=oldpar->UpdateFrom(par);
            //cout << "++++ Updated parameter "<< name<<" from parameter "<< par->GetName() << endl;
            //oldpar->PrintParameter();
         }
      else
         {
            // parameter not yet exisiting, add external paramter as a copy:
             TGo4Parameter* clonedpar=dynamic_cast<TGo4Parameter*>(par->Clone());
              // find out destination folder for new parameter from name:
            Text_t subfolder[fguSUBFOLDERMAXLEN];
            size_t fnamelen=0;
            const char* endname = name;
            const char* foldername = name;
            while (endname!=0)
               {
                  endname=strstr(foldername,"/");
                  if(endname==0) break;
                  fnamelen= endname-name; // length of path string
                  foldername=endname+1;
               }
            if(fnamelen>0)
                {
                   // we have a subfolder for condition
                   if(fnamelen>fguSUBFOLDERMAXLEN) fnamelen=fguSUBFOLDERMAXLEN;
                   snprintf(subfolder,fnamelen,"%s",name);
                   rev=AddObjectToFolder(clonedpar,topfolder,subfolder,kTRUE);
                   //cout << "++++ Added new parameter "<< clonedpar->GetName()<<" to folder "<<topfolder->GetName()<<"/"<< subfolder << endl;
                }
             else
                {
                   // no subfolder, condition is directly under topfolder
                   rev=AddObjectToFolder(clonedpar,topfolder,0,kTRUE);
                   //cout << "++++ Added new parameter "<< clonedpar->GetName()<<" to folder "<<topfolder->GetName()<<", no subfolder!!!"<< endl;
                }
         }
   }
else
   {
      rev=kFALSE;
   }
return rev;
}

TGo4Parameter * TGo4AnalysisObjectManager::GetParameter(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetParameter(Text_t*)",__LINE__, __FILE__));
   TGo4Parameter* rev=dynamic_cast<TGo4Parameter *> (FindObjectInFolder(fxParameterDir,name));
   if(rev==0) rev= dynamic_cast<TGo4Parameter *> (FindObjectInFolder(fxUserDir,name));
   return rev;
}

Bool_t TGo4AnalysisObjectManager::RemoveParameter(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveParameter(Text_t*)",__LINE__, __FILE__));
   return RemoveObjectFromFolder(name, fxParameterDir, kTRUE);
}

Bool_t TGo4AnalysisObjectManager::AddPicture(TGo4Picture * pic, const Text_t* subfolder)
{
TRACE((11,"TGo4AnalysisObjectManager::AddPicture(TGo4Picture *)",__LINE__, __FILE__));
if(pic)
{
   pic->LocateObjectsFrom(fxGo4Dir);
   return (AddObjectToFolder(pic,fxPictureDir,subfolder,kTRUE));
}
else
   return kFALSE;
}

Bool_t TGo4AnalysisObjectManager::SetPicture(const Text_t * name, TGo4Picture * pic, TFolder* parent)
{
TRACE((11,"TGo4AnalysisObjectManager::SetPicture(Text_t*, TGo4Picture*)",__LINE__, __FILE__));
Bool_t rev=kFALSE;
TFolder* topfolder=0;
if(parent)
   topfolder=parent;
else
   topfolder=fxPictureDir;
if(pic)
   {
      TGo4Picture* oldpic= dynamic_cast<TGo4Picture *> (topfolder->FindObjectAny(name));
      if(oldpic!=0)
         {
            // update existing picture of given name
            oldpic->UpdateFrom(pic);
//            cout << "++++ Updated picture "<< name<<" from picture "<< pic->GetName() << endl;
         }
      else
         {
            // picture not yet exisiting, add external as a copy:
             TGo4Picture* clonedpic=dynamic_cast<TGo4Picture*>(pic->Clone());
              // find out destination folder for new pic from name:
            Text_t subfolder[fguSUBFOLDERMAXLEN];
            size_t fnamelen=0;
            const char* endname = name;
            const char* foldername = name;
            while (endname!=0)
               {
                  endname=strstr(foldername,"/");
                  if(endname==0) break;
                  fnamelen= endname-name; // length of path string
                  foldername=endname+1;
               }
            if(fnamelen>0)
                {
                   // we have a subfolder for condition
                   if(fnamelen>fguSUBFOLDERMAXLEN) fnamelen=fguSUBFOLDERMAXLEN;
                   snprintf(subfolder,fnamelen,"%s",name);
                   rev=AddObjectToFolder(clonedpic,topfolder,subfolder,kTRUE);
                }
             else
                {
                   // no subfolder, condition is directly under topfolder
                   rev=AddObjectToFolder(clonedpic,topfolder,0,kTRUE);
                }
         }
   }
else
   {
      rev=kFALSE;
   }
return rev;
}

TGo4Picture * TGo4AnalysisObjectManager::GetPicture(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetPicture(Text_t*)",__LINE__, __FILE__));
   TGo4Picture* rev=dynamic_cast<TGo4Picture *> (FindObjectInFolder(fxPictureDir, name));
   if(rev==0) rev=dynamic_cast<TGo4Picture *> (FindObjectInFolder(fxUserDir, name));
   return rev;
}

Bool_t TGo4AnalysisObjectManager::RemovePicture(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::RemovePicture(Text_t*)",__LINE__, __FILE__));
   return RemoveObjectFromFolder(name, fxPictureDir, kTRUE);
}


void TGo4AnalysisObjectManager::InitPictures(TFolder* fold) {
TFolder* workfolder;
if(fold)
   workfolder=fold;
else
   workfolder=fxPictureDir;

TGo4LockGuard  dirguard(fxDirMutex);

TIter iter(workfolder->GetListOfFolders());
TObject* ob=0;
while(( ob=iter() ) !=0)
   {
      if(ob->InheritsFrom(TFolder::Class()))
         {
            TFolder* subfolder =dynamic_cast<TFolder*> (ob);
            if(subfolder)
               {
                  InitPictures(subfolder); // recursively scan all subfolders
               }
         }
      else if(ob->InheritsFrom(TGo4Picture::Class()))
         {
            TGo4Picture* pic=dynamic_cast<TGo4Picture*> (ob);
            pic->LocateObjectsFrom(fxGo4Dir);
            //cout<< "PPPPPPP init of picture "<<pic->GetName() <<endl;
         }
   } // while
}



Bool_t TGo4AnalysisObjectManager::AddCanvas(TCanvas * can, const Text_t* subfolder)
{
TRACE((11,"TGo4AnalysisObjectManager::AddCanvas(TCanvas *)",__LINE__, __FILE__));
Bool_t rev=AddObjectToFolder(can,fxCanvasDir,subfolder,kFALSE);
if(rev && can) gROOT->GetListOfCanvases()->Remove(can);
   // make sure that root has no other reference to our canvas
return rev;
}

Bool_t TGo4AnalysisObjectManager::SetCanvas(const Text_t * name, TGo4CanvasStatus * stat, TFolder* parent)
{
TRACE((11,"TGo4AnalysisObjectManager::SetCanvas(Text_t*, TGo4CanvasStat*)",__LINE__, __FILE__));
Bool_t rev=kFALSE;
TFolder* topfolder=0;
if(parent)
   topfolder=parent;
else
   topfolder=fxCanvasDir;
if(stat)
   {
       TCanvas* can=stat->CreateCanvas();
       if(can)  gROOT->GetListOfCanvases()->Remove(can);
       //can->SetName(name); // override original canvas name
        // find out destination folder for canvas from name:
      Text_t subfolder[fguSUBFOLDERMAXLEN];
      size_t fnamelen=0;
      const char* endname = name;
      const char* foldername = name;
      while (endname!=0)
         {
            endname=strstr(foldername,"/");
            if(endname==0) break;
            fnamelen= endname-name; // length of path string
            foldername=endname+1;
         }
      if(fnamelen>0)
          {
             // we have a subfolder for condition
             if(fnamelen>fguSUBFOLDERMAXLEN) fnamelen=fguSUBFOLDERMAXLEN;
             snprintf(subfolder,fnamelen,"%s",name);
             rev=AddObjectToFolder(can,topfolder,subfolder,kTRUE);
             //cout << "++++ Added new parameter "<< clonedpar->GetName()<<" to folder "<<topfolder->GetName()<<"/"<< subfolder << endl;
          }
       else
          {
             // no subfolder, condition is directly under topfolder
             rev=AddObjectToFolder(can,topfolder,0,kTRUE);
             //cout << "++++ Added new parameter "<< clonedpar->GetName()<<" to folder "<<topfolder->GetName()<<", no subfolder!!!"<< endl;
          }

   }
else
   {
      rev=kFALSE;
   }
return rev;
}

TCanvas * TGo4AnalysisObjectManager::GetCanvas(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::GetPicture(Text_t*)",__LINE__, __FILE__));
   TCanvas* rev=dynamic_cast<TCanvas*> (FindObjectInFolder(fxCanvasDir, name));
   if(rev==0) rev=dynamic_cast<TCanvas*> (FindObjectInFolder(fxCanvasDir, name));
   return rev;
}

Bool_t TGo4AnalysisObjectManager::RemoveCanvas(const Text_t * name)
{
TRACE((11,"TGo4AnalysisObjectManager::RemovePicture(Text_t*)",__LINE__, __FILE__));
   return RemoveObjectFromFolder(name, fxCanvasDir, kTRUE);
}





Bool_t TGo4AnalysisObjectManager::LoadObjects(TFile* obfile)
{
   TRACE((11,"TGo4AnalysisObjectManager::LoadObjects(TFile*)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(obfile)
      {
         TObject* ob=obfile->Get(TGo4AnalysisObjectManager::fgcTOPFOLDER);
         TFolder* top= dynamic_cast<TFolder*>(ob);
         if(top)
            {
               // kept for backward compatibility: read folder struct directly
               //cout << "found top go4 folder "<< endl;
               rev=LoadFolder(top,fxGo4Dir,kFALSE);
            }
         else
            {
               // new: convert directory structure of file into folders
               //cout <<"LoadObjects with Dirscan..." << endl;
               rev=LoadFolder(obfile,fxGo4Dir,kFALSE);
            }
         TGo4PolyCond::CleanupSpecials(); // remove references to file cuts
         InitPictures(); // initialize pointers to histos
         if(fxDynamicList) fxDynamicList->Reset(); // reset loaded entries
      
      }
   return rev;
}

void TGo4AnalysisObjectManager::ResetCurrentDynList()
{
   if(fxDynamicList)
      fxDynamicList->Reset();
}

Int_t TGo4AnalysisObjectManager::ProcessDynamicList()
{
TRACE((11,"TGo4AnalysisObjectManager::ProcessDynamicList()",__LINE__, __FILE__));
//
   Int_t rev=-1;
   if(fxDynamicList)
      {
         if(fxDynamicList->IsEmpty()) return 0;
         fiDynListCount++;
         rev=fxDynamicList->Process(); // normally, all entries are processed eventwise
                                       // except for treehistogramentries; these
                                       // check the dynlistinterval internally now!
         if(CheckDynListInterval()) ResetBackStores();
            // after dynlistinterval treehistogram entries are processed, reset trees for them
      }
   else
      {
         throw TGo4DynamicListException(0,
               "AnalysisObjectManager::ProcessDynamicList: No current dynamic list set  !!!");
      }
   return rev;
}

Bool_t TGo4AnalysisObjectManager::SetDynamicEntryStatus(const Text_t* name, TGo4DynamicEntryStatus* state, const Text_t* listname)
{
TRACE((11,"TGo4AnalysisObjectManager::SetDynamicEntryStatus(Text_t*, TGo4DynamicEntryStatus*)",__LINE__, __FILE__));
   if(state==0) return kFALSE;
   TGo4DynamicList* thelist=0;
   if(listname==0)
      {
         thelist=GetCurrentDynList(); // default behaviour: work on current dynlist
      }
   else
      {
         thelist= GetDynamicList(listname); // later: more than one dynamic list?
      } //   if(listname==0)
   if(thelist)
      return (thelist->SetEntryStatus(name,state));
   else
      return kFALSE;
   return kFALSE;
}

Bool_t TGo4AnalysisObjectManager::AddDynamicHistogram(const Text_t* name,
                                                      const Text_t* histo,
                                                      const Text_t* hevx, const Text_t* hmemx,
                                                      const Text_t* hevy, const Text_t* hmemy,
                                                      const Text_t* hevz, const Text_t* hmemz,
                                                      const Text_t* condition,
                                                      const Text_t* cevx, const Text_t* cmemx,
                                                      const Text_t* cevy, const Text_t* cmemy)
{
TRACE((11,"TGo4AnalysisObjectManager::AddDynamicHistogram(Text_t*,...)",__LINE__, __FILE__));
   if(name==0 || histo==0 || hevx==0 || hmemx==0) return kFALSE;
   TGo4HistogramEntryStatus* settings= new TGo4HistogramEntryStatus;
   settings->ResetNames();
   settings->SetName(name);
   settings->SetHistogramName(histo);
   TString hevents[__MAXHISDIM__];
   TString hmembers[__MAXHISDIM__];
   for (UInt_t t=0; t<TGo4HistogramEntry::fguMAXHISDIMENSION;++t)
      {
          // set names to defaults.
          hevents[t]=TGo4DynamicEntry::fgcNOEVENT;
          hmembers[t]=TGo4DynamicEntry::fgcNODATA;
      }
   hevents[0]=hevx;
   hmembers[0]=hmemx;
   if(hevy!=0 && hmemy!=0 && TGo4HistogramEntry::fguMAXHISDIMENSION>1)
      {
         hevents[1]=hevy;
         hmembers[1]=hmemy;
         if(hevz!=0 && hmemz!=0 && TGo4HistogramEntry::fguMAXHISDIMENSION>2)
            {
                hevents[2]=hevz;
                hmembers[2]=hmemz;
            }
         else {}
      }
   else {}
   settings->SetHisEventNames(hevents);
   settings->SetHisVarNames(hmembers);
   if(condition!=0 && cevx!=0 && cmemx!=0 )
      {
          settings->SetConditionName(condition);
          TString cevents[__MAXCONDIM__];
          TString cmembers[__MAXCONDIM__];
          for (UInt_t t=0; t<TGo4DynamicEntry::fguMAXCONDIMENSION;++t)
            {
                // set names to defaults.
                cevents[t]=TGo4DynamicEntry::fgcNOEVENT;
                cmembers[t]=TGo4DynamicEntry::fgcNODATA;
            }
          cevents[0]=cevx;
          cmembers[0]=cmemx;
          if(cevy!=0 && cmemy!=0 && TGo4DynamicEntry::fguMAXCONDIMENSION>1)
            {
               cevents[1]=cevy;
               cmembers[1]=cmemy;
            }
          settings->SetConEventNames(cevents);
          settings->SetConVarNames(cmembers);
       } // if (condition...)
    else {}

   Bool_t rev=AddDynamicHistogram(settings);
   delete settings;
   return rev;
}

Bool_t TGo4AnalysisObjectManager::AddDynamicHistogram(TGo4HistogramEntryStatus* settings)
{
TRACE((11,"TGo4AnalysisObjectManager::AddDynamicHistogram(TGo4HistogramEntryStatus**,...)",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   if(settings==0) return kFALSE;
   const Text_t* name=settings->GetName();
   TGo4DynamicList* thelist=GetCurrentDynList();
   if(thelist)
      {
         TGo4HistogramEntry* hisentry= new TGo4HistogramEntry(name);
         hisentry->SetStatus(settings);
         if(thelist->AddEntry(hisentry))
            {
               rev=kTRUE;
            }
         else
            {
               // adding failed, name already exists
               delete hisentry;
               rev=kFALSE;
            }
      }
   else
      {
         rev=kFALSE;
      }  //  if(thelist)
   return rev;
}

Bool_t TGo4AnalysisObjectManager::AddTreeHistogram(const Text_t * hisname, const Text_t * treename, const Text_t* varexp, TCut selection)
{
TRACE((11,"TGo4AnalysisObjectManager::AddTreeHistogram(Text_t*,...)",__LINE__, __FILE__));
  //
   Bool_t rev=kFALSE;
   TGo4TreeHistogramEntry* hisentry= new TGo4TreeHistogramEntry(hisname,
                                                             treename,
                                                             varexp,
                                                             selection);
   TGo4DynamicList* curlist=GetCurrentDynList();
   if(curlist)
      {

         if(curlist->AddEntry(hisentry))
            {
               TGo4Analysis::Instance()->Message(0,"Analysis added tree histogram %s to dynamic list",
               hisentry->GetName() );
               //UpdateNamesList();
               rev=kTRUE;
            }
         else
            {
               TGo4Analysis::Instance()->Message(0,"!!! Analysis AddTreeHistogram- ERROR: entry %s already exists !!!",
                     hisentry->GetName());
               rev=kFALSE;
            }
      }
  else
      {
          TGo4Analysis::Instance()->Message(3,"!!! Analysis AddTreeHistogram- ERROR: no dynamic list !!!");
          delete hisentry;
          rev=kFALSE;
      } // if(fxDynamicList)
   return rev;
}




Bool_t TGo4AnalysisObjectManager::RemoveDynamicEntry(const Text_t * entryname, const Text_t* listname)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveDynamicEntry(const Text_t *, const Text_t* )",__LINE__, __FILE__));
   Bool_t rev=kFALSE;
   TGo4DynamicList* thelist=0;
   if(listname==0)
      {
         thelist=GetCurrentDynList();
      }
   else
      {
         thelist= GetDynamicList(listname);
      } //   if(listname==0)
   if(thelist)
      {
         thelist->DeleteEntry(entryname);
         rev=kTRUE;
      }
   else
      {
         // no such dynamic list
         rev=kFALSE;
      }  //  if(thelist)
   return rev;
}


TFolder* TGo4AnalysisObjectManager::FindSubFolder(TFolder* parent, const Text_t* subfolder, Bool_t create)
{
TRACE((11,"TGo4AnalysisObjectManager::FindSubFolder(TFolder*, const Text_t*, Bool_t)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
   TFolder* result=0;
   if(parent==0) return 0;
   if(subfolder==0) return parent;
   Text_t subname[fguSUBFOLDERMAXLEN];
   size_t fnamelen=0;
   const char* endname = subfolder;
   const char* searchname = subfolder;
   endname=strstr(searchname,"/"); // find end of first subfolder string
   if(endname!=0)
      {
         // we have subfolder of subfolder, process recursively
         endname+=1;
         fnamelen= endname-searchname; // length of first subfolder name
         if(fnamelen>fguSUBFOLDERMAXLEN) fnamelen=fguSUBFOLDERMAXLEN;
         snprintf(subname,fnamelen,"%s",searchname);
         //cout <<" fffffff Searching for subfolder "<< subname << endl;
         TFolder* nextsubfolder=FindSubFolder(parent,subname,create); // get folder directly under parent
         result=FindSubFolder(nextsubfolder,endname,create); // search rest of path in this folder
      }
   else
      {
         // only one level of subfolder, find it directly
         TList* folderlist=dynamic_cast<TList*> (parent->GetListOfFolders());
         TIterator* listiter=folderlist->MakeIterator();
         TObject* entry;
         while((entry=listiter->Next()) !=0)
            {
               if(entry->InheritsFrom("TFolder"))
                  {
                     if(!strcmp(subfolder,entry->GetName()))
                        {
                            result= dynamic_cast<TFolder*>(entry);
                            //cout <<" fffffff Found subfolder "<<subfolder << endl;
                            break;
                        }
                  }
            }
         if(result==0 && create)
            {
               result=parent->AddFolder(subfolder,"UserFolder"); // create new subfolder if not found
            }
         delete listiter;
      } // if (endname!=0)
   return result;
}


Bool_t TGo4AnalysisObjectManager::AddObjectToFolder(TObject * ob, TFolder* fold, const Text_t* subfolder, Bool_t replace, Bool_t uniquename, Bool_t resetbits)
{
TRACE((11,"TGo4AnalysisObjectManager::AddObjectToFolder(TObject *, TFolder*, const Text_t*, Bool_t)",__LINE__, __FILE__));

Bool_t rev=kTRUE;
TGo4LockGuard  dirguard(fxDirMutex);
if(fold==0) return kFALSE;
if(ob)
   {
      if(resetbits)
         {
            ob->ResetBit(TGo4Status::kGo4NoReset);
            ob->ResetBit(TGo4Status::kGo4CanDelete); // default behaviour: allow reset, disable delete   
         }
      Text_t obname[fguSUBFOLDERMAXLEN];
      Text_t subname[fguSUBFOLDERMAXLEN];
      if(subfolder)
         {
            // prepare given name of subfolder:
            snprintf(subname,fguSUBFOLDERMAXLEN,"%s",subfolder);
            Text_t* lastchar=subname + strlen(subname)-1;
            if (*lastchar=='/')
               *lastchar = 0;
/*            if(!strcmp("/",lastchar))
               {
                  // last character of foldername is slash, ignore it!
                  snprintf(lastchar,1,"\0");
               }
*/
            snprintf(obname,fguSUBFOLDERMAXLEN,"%s/%s",subname,ob->GetName());
         }
      else
         {
            snprintf(obname,fguSUBFOLDERMAXLEN,"%s",ob->GetName());
         }

      TObject* oldob=0;
      if(uniquename)
         {
            // look for object of identical name anywhere in top folder
            oldob=fold->FindObjectAny( ob->GetName() );
         }
      else
         {
            // only check for objects that are in given subfolder
            oldob= fold->FindObjectAny(obname);
         }
      if(oldob)
         // is object already in folder?
         {
               //yes, shall we replace? check if pointers are identical first!
            if(replace && ob!=oldob)
               {
                  // remove old reference before adding new one:
                  fold->RecursiveRemove(oldob);
                  CleanupDynamicLists(oldob);
                  delete oldob;
               }
            else
               {
                  return kFALSE; // do not overwrite old one
               }
         }
      else   {}
    TFolder* addDir=0;
    if(subfolder)
       {
         addDir=FindSubFolder(fold,subname,kTRUE);
         if(addDir==0)
            {
            // should not happen: all specified subfolders should be created!
            addDir=fold;
            }
       }
    else
       {
          addDir=fold;
       } // if(subfolder)
    addDir->Add(ob);
    rev=kTRUE;
   }
else
   {
      TRACE((12,"TGo4AnalysisObjectManager::AddObjectToFolder - zero object",__LINE__, __FILE__));
      rev=kFALSE;
   } // if(his)



return rev;
}


Bool_t TGo4AnalysisObjectManager::RemoveObjectFromFolder(const Text_t* fullname, TFolder* fold, Bool_t isDel)
{
TRACE((11,"TGo4AnalysisObjectManager::RemoveObjectFromFolder(const Text_t*, TFolder*, Bool_t)",__LINE__, __FILE__));
//
   if(fold==0) return kFALSE;
   TGo4LockGuard  dirguard(fxDirMutex);
   TNamed* obj = 0;
   Int_t buflen=fguSUBFOLDERMAXLEN;
   Text_t buffer[buflen];
   if(fullname) {
      strncpy(buffer,fullname,buflen-10);
      obj = dynamic_cast<TNamed*> (fold->FindObjectAny(buffer));
   }

   if(obj!=0) {
      fold->RecursiveRemove(obj);
      CleanupDynamicLists(obj);
      if (isDel) delete obj;
      TGo4Analysis::Instance()->Message(0,"Analysis: removed object %s",buffer);
      return kTRUE;
   }

   TGo4Analysis::Instance()->Message(0,"!!! Analysis: removing object %s FAILED !!!",buffer);
   return kFALSE;
}

Bool_t TGo4AnalysisObjectManager::LoadFolder(TFolder* source, TFolder* destination, Bool_t replace)
{
TRACE((11,"TGo4AnalysisObjectManager::LoadFolder(TFolder*, TFolder*, Bool_t replace)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
Bool_t rev=kTRUE;
TCollection* folderlist=source->GetListOfFolders();
TIterator* folderiter=folderlist->MakeIterator();
TObject* ob=0;
while(( ob=folderiter->Next() ) !=0)
   {
      if(ob->InheritsFrom("TFolder"))
         {
            TFolder* subfolder =dynamic_cast<TFolder*> (ob);
            if(subfolder)
               {
                  //cout <<"LLLLLL Load folder scanning subfolder "<< subfolder->GetName() << endl;
                  TFolder* subdest=FindSubFolder(destination,subfolder->GetName(), kTRUE);
                  LoadFolder(subfolder,subdest,replace); // recursively scan all subfolders
               }
         }
      else
         {
            rev=PutToFolder(ob,destination,replace);
         }
} // while(..)
delete folderiter;
return rev;
}

Bool_t TGo4AnalysisObjectManager::LoadFolder(TDirectory* source, TFolder* destination, Bool_t replace)
{
TRACE((11,"TGo4AnalysisObjectManager::LoadFolder(TDirectory*, TFolder*, Bool_t replace)",__LINE__, __FILE__));
if(!source || !destination) return kFALSE;
TGo4LockGuard  dirguard(fxDirMutex);
Bool_t rev=kTRUE;
TDirectory* savdir=gDirectory;
source->cd(); // this is necessary to let the TKey::ReadObj work!
source->ReadKeys();
TCollection* keylist=source->GetListOfKeys();
TIterator* keyiter=keylist->MakeIterator();
TObject* keyob=0;
TKey* key=0;
while(( keyob=keyiter->Next() ) !=0)
   {
      key=dynamic_cast<TKey*>(keyob);
      if(key==0)
        {
           TGo4Analysis::Instance()->Message(3,"Analysis LoadFolder: ZERO key in directory %s",
                          source->GetName());
           delete keyiter;               
           return kFALSE;
        }
      //cout <<"Reading key "<<key->GetName() << endl;
      TObject* ob=key->ReadObj();
      if(ob==0)
         {
             TGo4Analysis::Instance()->Message(2,"Analysis LoadFolder: Retrying to read key %s ...",
                          key->GetName());
            ob=source->Get(key->GetName());
            if(ob==0)
               {
                  TGo4Analysis::Instance()->Message(3,"Analysis LoadFolder: Failed to read key %s !",
                          key->GetName());
                  return kFALSE;
               }
         }

      if(ob->InheritsFrom("TDirectory"))
         {
            TDirectory* subdir =dynamic_cast<TDirectory*> (ob);
            if(subdir)
               {
                  //cout <<"LLLLLL Load folder dir scanning for subdir "<< subdir->GetName() << endl;
                  Bool_t inpicturefolder=kFALSE;
                  if(!strcmp(subdir->GetName(),fgcPICTFOLDER)) inpicturefolder=kTRUE;
                  if(inpicturefolder) fbSuppressLoadHistograms=kTRUE;   
                  TFolder* subdest=FindSubFolder(destination,subdir->GetName(), kTRUE);
                  rev=LoadFolder(subdir,subdest,replace); // recursively scan all subfolders
                  if(inpicturefolder) fbSuppressLoadHistograms=kFALSE;
               }
         }
      else
         {
            rev=PutToFolder(ob,destination,replace);
         }
} // while(..)
delete keyiter;
savdir->cd();
return rev;
}

Bool_t TGo4AnalysisObjectManager::PutToFolder(TObject* ob, TFolder* destination, Bool_t replace)
{
if(!ob || !destination) return kFALSE;
Bool_t rev=kTRUE;
//cout <<"put to folder for "<<ob->GetName() << endl;
if(ob->InheritsFrom("TGo4DynamicList"))
   {
      // this case only happens for old autosave file structure
      // take care for global dynamic list pointer
     RemoveDynamicList(fxDynamicList);
     TGo4DynamicList* list =dynamic_cast<TGo4DynamicList*> ( ob->Clone() ); // deep copy of source object!
      if(AddObjectToFolder(list,destination,0,replace))
         {
           //cout <<"put to folder added dynamic list "<<list->GetName()<<" "<< list << endl;
           //cout <<"put to folder deleted old list "<<fxDynamicList << endl;
           delete fxDynamicList; // discard previous list
           fxDynamicList=list;
           TGo4Analysis::Instance()->Message(0,"Analysis LoadFolder: Dynamiclist %s was loaded and set.",
                          list->GetName());
         }
      else
         {
            //cout <<"put to folder 2. try: added dynamic list "<<list->GetName()<<" "<< ob << endl;
            // object already there and noreplace set: delete clone
            delete list;
            AddDynamicList(fxDynamicList); // we continue with old list
         } // if(AddObjectToFolder(addob,destination,0,replace))
                     fxDynamicList->Reset();
   }
else if (ob->InheritsFrom("TGo4DynamicEntry"))
{
   // new autosave file structure will save dynamic entries independently:
   if(fxDynamicList==0)
      {
         fxDynamicList= new TGo4DynamicList( TGo4Analysis::fgcTOPDYNAMICLIST );
         AddDynamicList(fxDynamicList);
      }
   TGo4DynamicEntry* dentry =dynamic_cast<TGo4DynamicEntry*> ( ob->Clone() ); // deep copy of source object!
   fxDynamicList->DeleteEntry(dentry->GetName());
   fxDynamicList->AddEntry(dentry);
   //cout <<"Added dynamic entry from file: "<<dentry->GetName() << endl;
}

else if(ob->InheritsFrom("TGo4Parameter"))
   {
      // parameters never replaced, but updated
      TGo4Parameter* par =dynamic_cast<TGo4Parameter*>(ob);
      SetParameter(ob->GetName(),par,destination);
   }
else if(ob->InheritsFrom("TGo4Picture"))
   {
      // pictures never replaced, but updated
      TGo4Picture* pic =dynamic_cast<TGo4Picture*>(ob);
      //cout <<"LLLLLoad Folder SetsPicture!!!!!" << endl;
      SetPicture(ob->GetName(),pic,destination);
   }
else if(ob->InheritsFrom("TGo4Condition"))
   {
      // conditions not replaced, but updated
      TGo4Condition* con =dynamic_cast<TGo4Condition*>(ob);
      SetAnalysisCondition(ob->GetName(),con,kTRUE, destination);
   }
else if(ob->InheritsFrom("TH1")) 
   {
      if(fbSuppressLoadHistograms) return kFALSE;
      // test: do not clone histos, but change dir from asf file to memory
      TH1* his =dynamic_cast<TH1*>(ob);
       if(AddObjectToFolder(his,destination,0,replace,kFALSE,kFALSE))
         {
            his->SetDirectory(gROOT); // set directory for histos, needed for TTree::Draw
            TGo4Analysis::Instance()->Message(0,"Analysis LoadFolder: Histogram %s was loaded.",
                          his->GetName());
            //cout <<"Changed directory of histo "<<his->GetName() << endl;
         }
       else
        {
            // object already there and noreplace set: do not change dir
        }
   }
else
   {
      TObject* addob =ob->Clone(); // deep copy of source object!
      if(AddObjectToFolder(addob,destination,0,replace))
         {

            TGo4Analysis::Instance()->Message(-1,"Analysis LoadFolder: Object %s was loaded.",
                          addob->GetName());
         }
      else
         {
            // object already there and noreplace set: delete clone
            delete addob;
         } // if(AddObjectToFolder(addob,destination,0,replace))
   }
return rev;
}



Bool_t TGo4AnalysisObjectManager::SaveFolder(TFolder* source)
{
TGo4LockGuard  dirguard(fxDirMutex);
Bool_t rev=kTRUE;
TCollection* folderlist=source->GetListOfFolders();
TIterator* folderiter=folderlist->MakeIterator();
TObject* ob=0;
while(( ob=folderiter->Next() ) !=0)
   {
      if(ob->InheritsFrom("TFolder"))
         {
            TFolder* subfolder =dynamic_cast<TFolder*> (ob);
            if(subfolder)
               {
                  TDirectory* currentdir=gDirectory;
                  const Text_t* subfoldername=subfolder->GetName();
                  TDirectory* subdir=subdir=dynamic_cast<TDirectory*>(currentdir->Get(subfoldername));
                  if(subdir==0)
                     {
                        subdir=currentdir->mkdir(subfoldername,"subdir");
                        //cout <<"SSSS Save folder created subdir "<<subfoldername << endl;
                     }
                  else
                     {
                         //cout <<"SSSS Save folder found existing subdir "<<subfoldername << endl;
                     }

                  if(subdir)
                     {
                        subdir->cd();
                        //cout <<"SSSS Save folder scanning subfolder "<< subfolder->GetName() << endl;
                        SaveFolder(subfolder); // recursively scan all subfolders
                     }
                  else
                     {
                          TGo4Analysis::Instance()->Message(2,"Analysis SaveFolder: Could not assign subdirectory %s to folder.",
                                subfoldername);
                     }
                  currentdir->cd();
               }
         }
      else
         {


            if(ob->InheritsFrom("TGo4DynamicList"))
               {
                   TGo4DynamicList* dlist=dynamic_cast<TGo4DynamicList*>(ob);
                   dlist->ResetIterator();
                   TGo4DynamicEntry* dentry=0;
                   while((dentry= dlist->NextEntry()) !=0)
                     {
                        AppendToDir(dentry,gDirectory);
                        //cout <<"Appending dynamic list entry "<<dentry->GetName()<<" "<< ob << endl;
                     }
               }
            else
               {
                    AppendToDir(ob,gDirectory);
                    //cout <<"Appended "<<ob->GetName()<<" to subdir "<< gDirectory->GetName() <<endl;
               }
         }
} // while(..)
delete folderiter;
return rev;
}

void TGo4AnalysisObjectManager::AppendToDir(TObject* ob, TDirectory* dir)
{
if(!ob || !dir) return;
// note: we do not check for old objects anymore, because
// file is generally cleaned up before writing now JA
//TObject* oldob=dir->Get(ob->GetName());
//if(oldob)
//   {
//   }
dir->Append(ob);
}

void TGo4AnalysisObjectManager::RemoveFromDir(TFolder* fold, TDirectory* dir)
{
if(!fold || !dir) return;
TCollection* folderlist=fold->GetListOfFolders();
TIterator* folderiter=folderlist->MakeIterator();
TObject* ob=0;
while(( ob=folderiter->Next() ) !=0)
   {
      if(ob->InheritsFrom("TFolder"))
         {
            TFolder* subfolder =dynamic_cast<TFolder*> (ob);
            if(subfolder)
               {
                  RemoveFromDir(subfolder,dir); // recursively scan all subfolders
               }
         }
      else if (ob->InheritsFrom("TGo4DynamicList"))
         {
            TGo4DynamicList* dlist=dynamic_cast<TGo4DynamicList*>(ob);
            dlist->ResetIterator();
            TGo4DynamicEntry* dentry=0;
            while((dentry=dlist->NextEntry() ) !=0)
               {
                  dir->RecursiveRemove(dentry);
                  //cout <<"Removing dynamic list entry "<<dentry->GetName()<<" "<< dentry << endl;
               }
         }
      else
         {
            dir->RecursiveRemove(ob);
         }
   }
delete folderiter;
}

Int_t TGo4AnalysisObjectManager::PrintFolder(TFolder* fold, Option_t* opt, const Text_t* expression)
{
TRACE((11,"TGo4AnalysisObjectManager::PrintFolder(TFolder*, Option_t*)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
Int_t totalsize=0;
if(fold)
   {
      TROOT::IndentLevel();
      TROOT::IncreaseDirLevel();
      cout <<"+Folder "<<fold->GetName()<<" content:" << endl;
      TCollection* list=fold->GetListOfFolders();
      TIterator* listiter=list->MakeIterator();
      TObject* ob=0;
      while((ob=listiter->Next())!=0)
         {
            if(ob->InheritsFrom("TFolder"))
               {
                   totalsize+=PrintFolder(dynamic_cast<TFolder*>(ob),opt,expression);
               }
            else
               {
                   if(IsMatching(ob->GetName(),expression))
                      {
                         TROOT::IndentLevel();
                         ob->Print(opt);
                         TGo4ObjectStatus* temp=CreateObjectStatus(ob);
                         if(temp) totalsize+=temp->GetObjectSize();
                         delete temp;
                      }
               }
      }// while
   TROOT::DecreaseDirLevel();
   TROOT::IndentLevel();
   cout <<"++++End "<<fold->GetName()<<"++++++++++" << endl;
   delete listiter;
   } else {}
return totalsize;
}

Bool_t TGo4AnalysisObjectManager::ClearFolder(TFolder* fold)
{
TRACE((11,"TGo4AnalysisObjectManager::ClearFolder(TFolder*, Option_t*)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
Bool_t rev=kFALSE;
if(fold)
   {
      rev=kTRUE;
      TCollection* list=fold->GetListOfFolders();
      TIterator* listiter=list->MakeIterator();
      TObject* ob=0;
      while((ob=listiter->Next())!=0)
         {
            if(ob->InheritsFrom("TFolder"))
               {
                   ClearFolder(dynamic_cast<TFolder*>(ob));
               }
            else
               {
                   ClearObject(ob);
               }
      }// while
   delete listiter;
   }
return rev;
}

Bool_t TGo4AnalysisObjectManager::ClearObject(TObject* ob)
{
TRACE((11,"TGo4AnalysisObjectManager::ClearObject(TObject*)",__LINE__, __FILE__));
Bool_t rev=kFALSE;
if(ob)
   {
      if(ob->TestBit(TGo4Status::kGo4NoReset)) return kFALSE;
      rev=kTRUE;
      if(ob->InheritsFrom("TH1"))
         {
             TH1* his= dynamic_cast<TH1*>(ob);
             his->Reset(); // histogram has no Clear implementation!
         }
      else if(ob->InheritsFrom("TGo4Picture"))
         {
             TGo4Picture* pic= dynamic_cast<TGo4Picture*>(ob);
             pic->Reset(); // picture has no Clear implementation!
         }
      else if(ob->InheritsFrom("TGraph"))
         {
            TGraph* gr= dynamic_cast<TGraph*>(ob);
            Int_t pn=gr->GetN();
            gr->Set(0); // clear array of points
            gr->Set(pn); // this should set all to 0
         }
     else if(ob->InheritsFrom("TMultiGraph"))
         {
            TMultiGraph* mg= dynamic_cast<TMultiGraph*>(ob);
            TList* glist=mg->GetListOfGraphs();
            TIterator* liter=glist->MakeIterator();
            TObject* ob=0;
            while((ob=liter->Next())!=0)
               {
                  ClearObject(ob);
               }
            delete liter;
         }
      else if(ob->InheritsFrom("TGo4EventElement"))
         {
            // nop, we do not allow a user clear from gui
            // on any event
            rev=kFALSE;
         }
      else if(ob->InheritsFrom("TTree"))
         {
            // nop, we do not allow a user clear from gui
            // on any tree
            rev=kFALSE;
         }
      else
         {
             ob->Clear();
             // use virtual Clear of all objects
             // make sure that TNamed::Clear is overwritten in subclasses
         }
   }
return rev;
}


Bool_t TGo4AnalysisObjectManager::DeleteFolder(TFolder* fold)
{
TRACE((11,"TGo4AnalysisObjectManager::DeleteFolder(TFolder*, Option_t*)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
Bool_t rev=kFALSE;
if(fold)
   {
      rev=kTRUE;
      TCollection* list=fold->GetListOfFolders();
      TIterator* listiter=list->MakeIterator();
      TObject* ob=0;
      while((ob=listiter->Next())!=0)
         {
            if(ob->InheritsFrom("TFolder"))
               {
                   DeleteFolder(dynamic_cast<TFolder*>(ob));
               }
            else
               {
                   DeleteObject(ob);
               }
      }// while
   delete listiter;
   }
return rev;
}

Bool_t TGo4AnalysisObjectManager::DeleteObject(TObject* ob)
{
TRACE((11,"TGo4AnalysisObjectManager::DeleteObject(TObject*)",__LINE__, __FILE__));
if(ob==0 || !ob->TestBit(TGo4Status::kGo4CanDelete) ) return kFALSE;
fxGo4Dir->RecursiveRemove(ob);
CleanupDynamicLists(ob);
delete ob;
return kTRUE;;
}



Bool_t TGo4AnalysisObjectManager::ProtectFolder(TFolder* fold, const Option_t* flags)
{
if(fold==0) return kFALSE;
TGo4LockGuard  dirguard(fxDirMutex);
TCollection* list=fold->GetListOfFolders();
TIter listiter(list);
TObject* ob=0;
while((ob=listiter.Next())!=0)
   {
      if(ob->InheritsFrom("TFolder"))
         {
             ProtectFolder(dynamic_cast<TFolder*>(ob), flags);
         }
      else
         {
             ProtectObject(ob, flags);
         }
   }// while
return kTRUE;
}

Bool_t TGo4AnalysisObjectManager::ProtectObject(TObject* ob, const Option_t* flags)
{
if(ob==0 || flags==0) return kFALSE;
TString opt=flags;
if(opt.Contains("+D")) ob->ResetBit(TGo4Status::kGo4CanDelete);
if(opt.Contains("-D")) ob->SetBit(TGo4Status::kGo4CanDelete);
if(opt.Contains("+C")) ob->SetBit(TGo4Status::kGo4NoReset);
if(opt.Contains("-C")) ob->ResetBit(TGo4Status::kGo4NoReset);
return kTRUE;
}




void TGo4AnalysisObjectManager::CleanupDynamicLists(TObject* oldobject)
{
TRACE((11,"TGo4AnalysisObjectManager::CleanupDynamicLists(TNamed*)",__LINE__, __FILE__));
TGo4LockGuard  dirguard(fxDirMutex);
// scan all dynamic lists for this object:
TCollection* dynlistlist=fxDynListDir->GetListOfFolders();
TIterator* dyniter=dynlistlist->MakeIterator();
TObject* dl=0;
while((dl=dyniter->Next())!=0)
   {
     TGo4DynamicList* dynlist= dynamic_cast<TGo4DynamicList*>(dl);
     if(dynlist)
      {
          if(oldobject->InheritsFrom("TH1"))
             {
                TH1* his=dynamic_cast<TH1*>(oldobject);
                dynlist->CleanupHistogram(his);
             }
          else if (oldobject->InheritsFrom("TGo4Condition"))
             {
                TGo4Condition* con=dynamic_cast<TGo4Condition*>(oldobject);
                dynlist->CleanupCondition(con);
             }
          else if (oldobject->InheritsFrom("TGo4EventElement"))
             {
                TGo4EventElement* eve=dynamic_cast<TGo4EventElement*>(oldobject);
                dynlist->CleanupEvent(eve);
             }
          else { }
      }
   }// while()
delete dyniter;
}


void TGo4AnalysisObjectManager::PrintConditions(const Text_t* expression)
{
TRACE((11,"TGo4AnalysisObjectManager::PrintConditions()",__LINE__, __FILE__));
Int_t totalsize=PrintFolder(fxConditionDir,"*",expression);
cout<<"___________________________________________________________"<<endl;
cout << "Total size of all conditions is: "<<totalsize<<" bytes."<<endl;
}

void TGo4AnalysisObjectManager::PrintHistograms(const Text_t* expression)
{
TRACE((11,"TGo4AnalysisObjectManager::PrintHistograms()",__LINE__, __FILE__));
Int_t totalsize=PrintFolder(fxHistogramDir,"*",expression);
cout<<"___________________________________________________________"<<endl;
cout << "Total size of all histograms is: "<<totalsize<<" bytes."<<endl;

}

void TGo4AnalysisObjectManager::PrintDynamicList()
{
if(fxDynamicList)
   {
   TGo4DynamicListStatus* dynstat=
                 dynamic_cast<TGo4DynamicListStatus*> ( fxDynamicList->CreateStatus() );
   dynstat->Print("*");
   delete dynstat;
   }
else
   {
      cout <<"No current dynamic list object." << endl;
   }
}

TObject* TGo4AnalysisObjectManager::NextMatchingObject(const Text_t* expr,
                        const Text_t* folder,
                        Bool_t reset)
{
if(reset)
   {
       delete fxMatchIterator;
       delete fxMatchList;
       fxMatchList=CreateObjectList(expr,folder);
       fxMatchIterator=fxMatchList->MakeIterator();
   }
else {}
return (fxMatchIterator->Next());
}

TList* TGo4AnalysisObjectManager::CreateObjectList(const Text_t* expr, const Text_t* folder)
{
TGo4LockGuard  dirguard(fxDirMutex);
TFolder* searchfold;
if(folder==0 || !strcmp(folder,fgcTOPFOLDER))
   searchfold=fxGo4Dir; // default: search topfolder
else
   searchfold=FindSubFolder(fxGo4Dir, folder, kFALSE);
return (CreateObjectList(expr, searchfold));
}


TList* TGo4AnalysisObjectManager::CreateObjectList(const Text_t* expr, TFolder* fold)
{
 TList* result=new TList;
 if(fold) {
   TIter iter(fold->GetListOfFolders());
   TObject* entry=0;
   while((entry = iter())!=0) {
       if(entry->InheritsFrom("TFolder")) {
           TFolder* subfold=dynamic_cast<TFolder*>(entry);
           TList* sublist=CreateObjectList(expr,subfold);
           // add sublist contents to our result list:
           result->AddAll(sublist);
       } else
       if(entry->InheritsFrom("TTree")) {
       } else  // disable sending tree to gui!
       if(entry->InheritsFrom("TGo4EventElement")) {
       } else // disable events
       if(entry->InheritsFrom("TGo4EventSource")) {
       } else  // disable events
       if(entry->InheritsFrom("TGo4EventStore")) {
       } else // disable events
       if(entry->InheritsFrom("TGo4EventProcessor")) {
       } else { // disable events
         if(IsMatching(entry->GetName(),expr))
            result->AddLast(entry);
       } // if(entry->InheritsFrom("TFolder"))
   } // while
 } // if(fold)
 return result;
}

Bool_t TGo4AnalysisObjectManager::IsMatching(const Text_t* string, const Text_t* expression)
{
if(expression==0) return kTRUE;
Bool_t ismatching=kFALSE;
TString entrystring=string;
TRegexp reg(expression,kTRUE);
if(!strcmp(expression,"*"))
   ismatching=kTRUE; // take all in this folder
//               else if (strstr(expression,string))
//                  ismatching=kTRUE; // expression just contained in name
else if (entrystring.Index(reg,0)!=kNPOS)
   ismatching=kTRUE; // root regular expression class
else
   ismatching=kFALSE;
return ismatching;
}


TObject* TGo4AnalysisObjectManager::FindObjectInFolder(TFolder*      folder,
                                                       const Text_t* fullname)
{
   TRACE((12,"TGo4AnalysisObjectManager::FindObjectInFolder(TFolder*, const Text_t*)",__LINE__, __FILE__));
   TGo4LockGuard  listguard(fxDirMutex);
   return folder ? folder->FindObjectAny(fullname) : 0;
}


TObject* TGo4AnalysisObjectManager::TestObject(TFolder*     folder,
                                               const Text_t* &pathname,
                                               const Text_t* objectname,
                                               const TClass* cl)
{
   TString fullname;
   if ((pathname!=0) && (strlen(pathname)==0)) pathname = 0;
   if (pathname) {
     fullname = pathname;
     fullname += "/";
   }
   fullname += objectname;

   TObject* obj = FindObjectInFolder(folder, fullname);

   if ((obj!=0) && (!obj->InheritsFrom(cl))) {
      RemoveObjectFromFolder(fullname, folder, kTRUE);
      obj = 0;
   }

   fbCreatedinMake = (obj==0);
   return obj;
}




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

---