17#include "TMultiGraph.h"
32#include "TDataMember.h"
33#include "TBaseClass.h"
36#include "TGo4LockGuard.h"
97#define fguSUBFOLDERMAXLEN 1024
100 TNamed(name,
"The Go4 Analysis Object Manager"),
145 gROOT->GetListOfCleanups()->Add(
this);
160 gROOT->GetListOfCleanups()->Add(
this);
166 gROOT->GetListOfCleanups()->Remove(
this);
170 gROOT->GetListOfBrowsables()->Remove(
fxGo4Dir);
173 gROOT->GetRootFolder()->Remove(
fxGo4Dir);
200 if (obj && (obj!=
this)) {
209 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddObject(TNamed *)",__LINE__, __FILE__));
222 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetAsTObject(const char *, const char *)",__LINE__, __FILE__));
224 TObject *ob =
nullptr;
230 if(ob && ob->InheritsFrom(TTree::Class())) ob =
nullptr;
231 if(ob && ob->InheritsFrom(TFolder::Class())) ob =
nullptr;
232 if(ob && ob->InheritsFrom(TGo4EventElement::Class())) ob =
nullptr;
233 if(ob && ob->InheritsFrom(TGo4EventSource::Class())) ob =
nullptr;
234 if(ob && ob->InheritsFrom(TGo4EventStore::Class())) ob =
nullptr;
235 if(ob && ob->InheritsFrom(TGo4EventProcessor::Class())) ob =
nullptr;
239 ob->GetName(), ob->ClassName());
250 return dynamic_cast<TNamed*
> (
GetAsTObject(name, folder));
256 GO4TRACE((11,
"TGo4AnalysisObjectManager::ClearObject(char *)", __LINE__, __FILE__));
259 TObject *ob =
fxGo4Dir->FindObjectAny(name);
261 if (ob->InheritsFrom(TFolder::Class()))
273 TObject *ob =
fxGo4Dir->FindObjectAny(name);
275 if (ob->InheritsFrom(TFolder::Class()))
287 TObject *ob =
fxGo4Dir->FindObjectAny(name);
289 if (ob->InheritsFrom(TFolder::Class()))
298 Int_t startindex, Int_t *skip,
const char *name,
301 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateCompositeBranchFolder(TObjArray *,...)",__LINE__, __FILE__));
302 if (!branchlist)
return nullptr;
309 lastindex = startindex + branchlist->GetLast();
314 TFolder *subnames =
nullptr;
315 TList *nameslist =
new TList;
319 Int_t skippedentries = 0;
321 for(Int_t i=startindex; i<lastindex;i++) {
322 TClass *cl =
nullptr;
323 TObject *entry = branchlist->At(i+offset);
324 if(entry && entry->InheritsFrom(TBranch::Class())) {
326 TBranch *currentbranch =
dynamic_cast<TBranch *
> (entry);
327 TObjArray *currentbranchlist =
nullptr;
329 currentbranchlist = currentbranch->GetListOfBranches();
330 cl = gROOT->GetClass(currentbranch->GetClassName());
332 if(cl && cl->InheritsFrom(TGo4CompositeEvent::Class())) {
335 TString branchname(currentbranch->GetName());
336 Ssiz_t leng = branchname.Length();
337 branchname.Resize(leng-1);
339 subevent =
dynamic_cast<TGo4CompositeEvent *
>(csubevents->FindObject(branchname.Data()));
345 subevent->GetName(), subevent->GetTitle());
346 nameslist->AddLast(subnames);
347 offset+=skippedentries;
351 subnames->GetListOfFolders()->AddAll(temp->GetListOfFolders());
358 if(currentbranchlist)
360 if(currentbranchlist->IsEmpty())
364 nameslist->AddLast(state);
369 CreateBranchFolder(currentbranchlist, currentbranch->GetName(), currentbranch->GetTitle());
370 nameslist->AddLast(subnames);
380 if(currentbranchlist)
382 if(currentbranchlist->IsEmpty())
386 nameslist->AddLast(state);
390 subnames =
CreateBranchFolder(currentbranchlist, currentbranch->GetName(), currentbranch->GetTitle());
391 nameslist->AddLast(subnames);
402 *skip = lastindex+offset-startindex;
403 TFolder *fold =
fxTempFolder->AddFolder(name,title,nameslist);
404 fold->SetOwner(kTRUE);
411 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateTreeStructure(TTree *)",__LINE__, __FILE__));
415 const char *treename=thetree->GetName();
416 const char *treetitle=thetree->GetTitle();
419 TObjArray *branchlist=thetree->GetListOfBranches();
428 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateTreeStructure(const char *)",__LINE__, __FILE__));
429 TTree *thetree =
nullptr;
431 thetree =
dynamic_cast<TTree *
> (
fxTreeDir->FindObjectAny(treename));
438 if(!cl)
return nullptr;
439 auto nameslist =
new TList;
442 TIter biter(cl->GetListOfBases());
443 while(
auto bob = biter()) {
444 auto baseclass =
dynamic_cast<TBaseClass*
>(bob);
445 if(!baseclass)
continue;
448 auto bclass = baseclass->GetClassPointer();
449 if(!bclass)
continue;
451 if(!strcmp(bclass->GetName(),
"TNamed"))
continue;
456 nameslist->AddLast(subfold);
459 TIter miter(cl->GetListOfDataMembers());
461 while(
auto nob = miter()) {
462 auto mem =
dynamic_cast<TDataMember *
>(nob);
463 if(!mem || mem->IsaPointer())
continue;
468 switch(mem->GetArrayDim()) {
470 sbuf.Form(
"%s[%d]", mem->GetName(), mem->GetMaxIndex(0));
474 sbuf.Form(
"%s[%d][%d]", mem->GetName(), mem->GetMaxIndex(0), mem->GetMaxIndex(1));
478 sbuf = mem->GetName();
482 nameslist->AddLast(state);
486 if (obj && obj->InheritsFrom(TGo4CompositeEvent::Class())) {
491 for (Int_t n = 0; n <= arr->GetLast(); n++) {
496 nameslist->AddLast(subfold);
500 auto memberfolder =
fxTempFolder->AddFolder(membrfoldername, TString(
"Object of class ") + cl->GetName(), nameslist);
502 memberfolder->SetOwner(kTRUE);
508 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddHistogram(TH1 *)",__LINE__, __FILE__));
512 if(rev && his) his->SetDirectory(gROOT);
517 const char *foldername,
518 const char *histoname,
524 const char *ytitle) {
526 TString htype(histotype);
528 if (htype.IsNull()) htype =
"I";
529 TClass *cl =
nullptr;
532 case 'C' : cl = TH1C::Class();
break;
533 case 'D' : cl = TH1D::Class();
break;
534 case 'F' : cl = TH1F::Class();
break;
535 case 'I' : cl = TH1I::Class();
break;
536 case 'S' : cl = TH1S::Class();
break;
537 default : cl = TH1I::Class();
542 if (histo)
return histo;
545 case 'C' : histo =
new TH1C(histoname, histoname, nbinsx, xlow, xup);
break;
546 case 'D' : histo =
new TH1D(histoname, histoname, nbinsx, xlow, xup);
break;
547 case 'F' : histo =
new TH1F(histoname, histoname, nbinsx, xlow, xup);
break;
548 case 'I' : histo =
new TH1I(histoname, histoname, nbinsx, xlow, xup);
break;
549 case 'S' : histo =
new TH1S(histoname, histoname, nbinsx, xlow, xup);
break;
550 default : histo =
new TH1I(histoname, histoname, nbinsx, xlow, xup);
553 if (title) histo->SetTitle(title);
554 if (xtitle) histo->SetXTitle(xtitle);
555 if (ytitle) histo->SetYTitle(ytitle);
561 const char *foldername,
562 const char *histoname,
571 const char *ytitle) {
572 TString htype(histotype);
574 if (htype.IsNull()) htype =
"I";
576 TClass *cl =
nullptr;
579 case 'C' : cl = TH2C::Class();
break;
580 case 'D' : cl = TH2D::Class();
break;
581 case 'F' : cl = TH2F::Class();
break;
582 case 'I' : cl = TH2I::Class();
break;
583 case 'S' : cl = TH2S::Class();
break;
584 default : cl = TH2I::Class();
589 if (histo)
return histo;
592 case 'C' : histo =
new TH2C(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
break;
593 case 'D' : histo =
new TH2D(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
break;
594 case 'F' : histo =
new TH2F(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
break;
595 case 'I' : histo =
new TH2I(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
break;
596 case 'S' : histo =
new TH2S(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
break;
597 default : histo =
new TH2I(histoname, histoname, nbinsx, xlow, xup, nbinsy, ylow, yup);
600 if (title) histo->SetTitle(title);
601 if (xtitle) histo->SetXTitle(xtitle);
602 if (ytitle) histo->SetYTitle(ytitle);
612 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateBranchFolder(TObjArray *)",__LINE__, __FILE__));
613 if (!branchlist)
return nullptr;
615 TList *nameslist =
new TList;
618 TIter iter(branchlist);
619 while(
auto entry = iter()) {
620 if(entry->InheritsFrom(TBranch::Class())) {
622 TBranch *subbranch =
dynamic_cast<TBranch*
> (entry);
623 TObjArray *subbranchlist = subbranch->GetListOfBranches();
625 if(subbranchlist->IsEmpty()) {
628 nameslist->AddLast(state);
633 TFolder *subnames =
nullptr;
635 TClass *cl = gROOT->GetClass(subbranch->GetClassName());
636 if(cl && cl->InheritsFrom(TGo4CompositeEvent::Class()) && istopbranch) {
638 TString branchname(subbranch->GetName());
639 Ssiz_t leng = branchname.Length();
640 branchname.Resize(leng-1);
643 Int_t skippedentries = 0;
646 &skippedentries, cevent->GetName(), cevent->GetTitle());
651 subnames->GetListOfFolders()->AddAll(temp->GetListOfFolders());
652 for (Int_t t = 0; t < skippedentries; ++t) {
657 subnames =
CreateBranchFolder(subbranchlist, subbranch->GetName(), subbranch->GetTitle());
660 subnames =
CreateBranchFolder(subbranchlist, subbranch->GetName(), subbranch->GetTitle());
662 nameslist->AddLast(subnames);
668 nameslist->AddLast(state);
674 TFolder *fold =
fxTempFolder->AddFolder(name,title,nameslist);
675 fold->SetOwner(kTRUE);
682 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddTree(TTree *, const char *)",__LINE__, __FILE__));
688 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveTree(TTree *, const char *)",__LINE__, __FILE__));
689 if (!tree)
return kFALSE;
698 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetHistogram(const char *)",__LINE__, __FILE__));
706 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetTree(char *)",__LINE__, __FILE__));
712 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveHistogram(char*)",__LINE__, __FILE__));
718 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddAnalysisCondition(TGo4Condition *)",__LINE__, __FILE__));
723 Bool_t counter, TFolder *parent)
725 GO4TRACE((11,
"TGo4AnalysisObjectManager::SetAnalysisCondition(char*, TGo4Condition *, Bool_t)",__LINE__, __FILE__));
727 if(!con)
return kFALSE;
731 TFolder *topfolder =
nullptr;
737 TObject *searchresult=topfolder->FindObjectAny(name);
739 searchresult=
fxUserDir->FindObjectAny(name);
742 if(searchresult && searchresult->InheritsFrom(TGo4Condition::Class())) {
745 if (searchresult && searchresult->InheritsFrom(TFolder::Class())) {
747 auto subf =
dynamic_cast<TFolder *
>(searchresult);
748 searchresult = subf->FindObjectAny(name);
760 const char *separ = strrchr(name,
'/');
762 TString fname(name, separ-name);
773 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetAnalysisCondition(char*)",__LINE__, __FILE__));
779 if(!cond->InheritsFrom(cond_cl)) cond =
nullptr;
785 const char *conditionname,
788 const char *bindhistogram,
794 if (wcond)
return wcond;
800 if (invert) wcond->
Invert(invert);
806 const char *conditionname,
811 const char *bindhistogram,
817 if (wcond)
return wcond;
823 if (invert) wcond->
Invert(invert);
829 const char *conditionname,
831 Float_t (*points)[2],
832 const char *bindhistogram,
838 if (pcond)
return pcond;
840 TArrayF fullx(size+1), fully(size+1);
841 int numpoints = size;
843 for (
int i = 0; i < numpoints; i++) {
844 fullx[i] = points[i][0];
845 fully[i] = points[i][1];
849 if ((fullx[0]!=fullx[numpoints-1]) || (fully[0]!=fully[numpoints-1])) {
850 fullx[numpoints] = fullx[0];
851 fully[numpoints] = fully[0];
855 TCutG mycat(
"initialcut", numpoints, fullx.GetArray(), fully.GetArray());
860 if (invert) pcond->
Invert(invert);
868 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveAnalysisCondition(char*)",__LINE__, __FILE__));
874 TNamed *
object =
GetObject(name, folder);
880 if(!obj)
return nullptr;
882 if(obj->InheritsFrom(TH1::Class()))
885 if(obj->InheritsFrom(TGo4Parameter::Class()))
893 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateNamesList()",__LINE__, __FILE__));
898 if (!name || (strlen(name) == 0)) name =
"Go4NamesList";
907 GO4TRACE((11,
"TGo4AnalysisObjectManager::CreateNamesFolder(TFolder *)",__LINE__, __FILE__));
908 if (!objectfolder)
return nullptr;
910 auto nameslist =
new TList;
911 TIter listiter(objectfolder->GetListOfFolders());
912 while(
auto entry = listiter()) {
913 if(entry->InheritsFrom(TFolder::Class())) {
915 auto subobj=
dynamic_cast<TFolder *
>(entry);
917 nameslist->AddLast(subnames);
918 }
else if (entry->InheritsFrom(TTree::Class())) {
920 auto subobj =
dynamic_cast<TTree *
> (entry);
922 nameslist->AddLast(treestruct);
923 }
else if(entry->InheritsFrom(TGo4EventElement::Class())) {
926 nameslist->AddLast(evfolder);
930 nameslist->AddLast(state);
934 auto namesfolder =
fxTempFolder->AddFolder(objectfolder->GetName(),objectfolder->GetTitle(),nameslist);
936 namesfolder->SetOwner(kTRUE);
948 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddEventStore(TGo4EventStore *)",__LINE__, __FILE__));
954 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveEventStore(TGo4EventStore *)",__LINE__, __FILE__));
968 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddEventSource(TGo4EventSource *)",__LINE__, __FILE__));
974 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveEventSource(TGo4EventSource *)",__LINE__, __FILE__));
985 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddEventProcessor(TGo4EventProcessor *)",__LINE__, __FILE__));
991 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveEventProcessor(TGo4EventProcessor *)",__LINE__, __FILE__));
1003 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddEventStructure(TGo4EventElement *)",__LINE__, __FILE__));
1009 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveEventStructure(TGo4EventElement *)",__LINE__, __FILE__));
1023 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetEvenStructure(const char *)",__LINE__, __FILE__));
1025 if (!name || (strlen(name) == 0))
return nullptr;
1027 TString path = name;
1030 while (path.Length()>0) {
1031 Int_t pos = path.Index(
"/");
1032 if (pos == 0) { path.Remove(0, 1);
continue; }
1035 if (pos > 0) { sub.Resize(pos); path.Remove(0, pos+1); }
1036 else { path.Clear(); }
1046 if (!chld && curr->InheritsFrom(sub.Data()))
return curr;
1050 if (!curr)
return nullptr;
1058 if (entry) entry->
Reset();
1064 GO4TRACE((11,
"TGo4AnalysisObjectManager::ResetBackStores()",__LINE__, __FILE__));
1067 while(
auto entry = iter()) {
1069 if(bs) bs->
Reset(clearflag);
1076 GO4TRACE((14,
"TGo4AnalysisObjectManager::CloseAnalysis()",__LINE__, __FILE__));
1092 TDirectory *savdir = gDirectory;
1097 file->Write(
nullptr, TObject::kOverwrite);
1107 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddParameter(TGo4Parameter *)",__LINE__, __FILE__));
1113 GO4TRACE((11,
"TGo4AnalysisObjectManager::SetParameter(const char *, TGo4Parameter *)",__LINE__, __FILE__));
1115 if (!par)
return kFALSE;
1117 Bool_t rev = kFALSE;
1123 TGo4Log::Info(
"Updated parameter %s from parameter %s", name, par->GetName());
1129 const char *separ = strrchr(name,
'/');
1131 TString fname(name, separ-name);
1133 TGo4Log::Info(
"Added new parameter %s to folder %s/%s", clonedpar->GetName(), topfolder->GetName(), fname.Data());
1142 GO4TRACE((11,
"TGo4AnalysisObjectManager::SetParameter(char*, TGo4Parameter*)",__LINE__, __FILE__));
1144 if (!status)
return kFALSE;
1146 Bool_t rev = kFALSE;
1158 const char *separ = strrchr(name,
'/');
1160 TString fname(name, separ-name);
1171 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetParameter(char*)",__LINE__, __FILE__));
1174 if (rev && parameter_class && !rev->InheritsFrom(parameter_class))
1181 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveParameter(char*)",__LINE__, __FILE__));
1187 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddPicture(TGo4Picture *)",__LINE__, __FILE__));
1188 if(!pic)
return kFALSE;
1196 GO4TRACE((11,
"TGo4AnalysisObjectManager::SetPicture(char*, TGo4Picture *)",__LINE__, __FILE__));
1198 if (!pic)
return kFALSE;
1213 const char *separ = strrchr(name,
'/');
1215 TString fname(name, separ-name);
1225 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetPicture(char*)",__LINE__, __FILE__));
1233 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemovePicture(char*)",__LINE__, __FILE__));
1239 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddCanvas(TCanvas *)",__LINE__, __FILE__));
1243 if (rev && can) can->SetBit(kMustCleanup);
1253 GO4TRACE((11,
"TGo4AnalysisObjectManager::GetPicture(const char *)",__LINE__, __FILE__));
1261 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemovePicture(const char *)",__LINE__, __FILE__));
1267 GO4TRACE((11,
"TGo4AnalysisObjectManager::LoadObjects(TFile *)",__LINE__, __FILE__));
1271 TFolder *top =
dynamic_cast<TFolder *
>(ob);
1308 const char *hevx,
const char *hmemx,
1309 const char *hevy,
const char *hmemy,
1310 const char *hevz,
const char *hmemz,
1311 const char *condition,
1312 const char *cevx,
const char *cmemx,
1313 const char *cevy,
const char *cmemy)
1315 if(!name || !histo || !hevx || !hmemx)
1319 entry->SetHistogramName(histo);
1321 if (hevx && hmemx) {
1322 entry->SetHisEventName(0, hevx);
1323 entry->SetHisVarName(0, hmemx);
1326 if (hevy && hmemy) {
1327 entry->SetHisEventName(1, hevy);
1328 entry->SetHisVarName(1, hmemy);
1331 if (hevz && hmemz) {
1332 entry->SetHisEventName(2, hevz);
1333 entry->SetHisVarName(2, hmemz);
1336 if(condition && cevx && cmemx) {
1337 entry->SetConditionName(condition);
1338 entry->SetConEventName(0, cevx);
1339 entry->SetConVarName(0, cmemx);
1341 entry->SetConEventName(1, cevy);
1342 entry->SetConVarName(1, cmemy);
1351 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddTreeHistogram(char*,...)",__LINE__, __FILE__));
1353 Bool_t rev = kFALSE;
1374 GO4TRACE((11,
"TGo4AnalysisObjectManager::FindSubFolder(TFolder *, const char *, Bool_t)",__LINE__, __FILE__));
1376 TFolder *result =
nullptr;
1377 if (!parent)
return nullptr;
1378 if (!subfolder)
return parent;
1379 const char *separ = strchr(subfolder,
'/');
1382 TString subname(subfolder, separ - subfolder);
1384 auto nextsubfolder =
FindSubFolder(parent, subname.Data(), create);
1388 TIter listiter(parent->GetListOfFolders());
1389 TObject *bigger_entry =
nullptr;
1390 while (
auto entry = listiter()) {
1391 if (entry->InheritsFrom(TFolder::Class())) {
1392 int cmp = strcmp(subfolder, entry->GetName());
1394 result =
dynamic_cast<TFolder *
>(entry);
1398 bigger_entry = entry;
1404 if(!result && create) {
1405 TList *lst =
nullptr;
1407 lst =
dynamic_cast<TList *
> (parent->GetListOfFolders());
1409 result =
new TFolder(subfolder,
"UserFolder");
1410 lst->AddBefore(bigger_entry, result);
1412 result = parent->AddFolder(subfolder,
"UserFolder");
1422 const char *subfolder,
1427 GO4TRACE((11,
"TGo4AnalysisObjectManager::AddObjectToFolder(TObject *, TFolder *, const char *, Bool_t, Bool_t, Bool_t)",__LINE__, __FILE__));
1430 if(!fold)
return kFALSE;
1433 GO4TRACE((12,
"TGo4AnalysisObjectManager::AddObjectToFolder - zero object",__LINE__, __FILE__));
1443 if (subfolder && (strlen(subfolder) != 0)) {
1444 subname = subfolder;
1445 if (subname[subname.Length()-1] ==
'/')
1446 subname.Resize(subname.Length()-1);
1449 TObject *oldob =
nullptr;
1452 oldob = fold->FindObjectAny(ob->GetName());
1456 if (subname.Length() > 0)
1457 obname = subname +
"/" + ob->GetName();
1459 obname = ob->GetName();
1462 oldob = fold->FindObjectAny(obname.Data());
1468 if(replace && ob!=oldob) {
1470 fold->RecursiveRemove(oldob);
1478 TFolder *addDir =
nullptr;
1481 if(!addDir) addDir = fold;
1491 GO4TRACE((11,
"TGo4AnalysisObjectManager::RemoveObjectFromFolder(const char *, TFolder *, Bool_t)",__LINE__, __FILE__));
1493 if(!fold)
return kFALSE;
1495 TObject *obj =
nullptr;
1499 strncpy(buffer,fullname,buflen-10);
1500 obj = fold->FindObjectAny(buffer);
1504 fold->RecursiveRemove(obj);
1506 if (isDel)
delete obj;
1517 if (!source)
return kFALSE;
1518 GO4TRACE((11,
"TGo4AnalysisObjectManager::LoadFolder(TFolder *, TFolder *, Bool_t)",__LINE__, __FILE__));
1521 TIter folderiter(source->GetListOfFolders());
1522 while (
auto ob = folderiter()) {
1523 if (ob->InheritsFrom(TFolder::Class())) {
1524 TFolder *subfolder =
dynamic_cast<TFolder *
>(ob);
1526 TFolder *subdest =
FindSubFolder(destination, subfolder->GetName(), kTRUE);
1538 GO4TRACE((11,
"TGo4AnalysisObjectManager::LoadFolder(TDirectory *, TFolder *, Bool_t replace)",__LINE__, __FILE__));
1539 if(!source || !destination)
return kFALSE;
1542 TDirectory *savdir = gDirectory;
1545 TIter keyiter(source->GetListOfKeys());
1546 while (
auto keyob = keyiter()) {
1547 auto key =
dynamic_cast<TKey *
>(keyob);
1552 TObject *ob = key->ReadObj();
1555 ob = source->Get(key->GetName());
1562 if (ob->InheritsFrom(TDirectory::Class())) {
1563 TDirectory *subdir =
dynamic_cast<TDirectory *
>(ob);
1565 Bool_t inpicturefolder = kFALSE;
1567 inpicturefolder = kTRUE;
1568 if (inpicturefolder)
1570 TFolder *subdest =
FindSubFolder(destination, subdir->GetName(), kTRUE);
1572 if (inpicturefolder)
1585 if(!ob || !destination)
return kFALSE;
1587 if (ob->InheritsFrom(TGo4DynamicEntry::Class())) {
1591 }
else if(ob->InheritsFrom(TGo4Parameter::Class())) {
1595 }
else if(ob->InheritsFrom(TGo4Picture::Class())) {
1599 }
else if(ob->InheritsFrom(TGo4Condition::Class())) {
1603 }
else if(ob->InheritsFrom(TH1::Class())) {
1606 TH1 *his =
dynamic_cast<TH1 *
>(ob);
1608 his->SetDirectory(gROOT);
1612 }
else if(ob->InheritsFrom(TCanvas::Class())) {
1613 TObject *addob = ob->Clone();
1619 if (gPad==addob) gPad =
nullptr;
1622 TObject *addob = ob->Clone();
1634 if (!source)
return kFALSE;
1637 TIter folderiter(source->GetListOfFolders());
1638 while (
auto ob = folderiter()) {
1639 if (ob->InheritsFrom(TFolder::Class())) {
1640 TFolder *subfolder =
dynamic_cast<TFolder *
>(ob);
1642 TDirectory *currentdir = gDirectory;
1643 const char *subfoldername = subfolder->GetName();
1644 TDirectory *subdir =
dynamic_cast<TDirectory *
>(currentdir->Get(subfoldername));
1646 subdir = currentdir->mkdir(subfoldername,
"subdir");
1666 if(!ob || !dir)
return;
1680 if(!fold || !dir)
return;
1682 TIter iter(fold->GetListOfFolders());
1683 while(
auto ob = iter()) {
1684 if(ob->InheritsFrom(TFolder::Class())) {
1685 TFolder *subfolder =
dynamic_cast<TFolder *
>(ob);
1689 dir->RecursiveRemove(ob);
1697 GO4TRACE((11,
"TGo4AnalysisObjectManager::PrintFolder(TFolder *, Option_t *)",__LINE__, __FILE__));
1699 Int_t totalsize = 0;
1700 TROOT::IndentLevel();
1701 TROOT::IncreaseDirLevel();
1702 std::cout <<
"+Folder " << fold->GetName() <<
" content:" << std::endl;
1703 TIter listiter(fold->GetListOfFolders());
1704 while(
auto ob = listiter()) {
1705 if(ob->InheritsFrom(TFolder::Class()))
1706 totalsize +=
PrintFolder(
dynamic_cast<TFolder *
>(ob),opt,expression);
1707 else if(
IsMatching(ob->GetName(),expression)) {
1708 TROOT::IndentLevel();
1716 TROOT::DecreaseDirLevel();
1717 TROOT::IndentLevel();
1718 std::cout <<
"++++End "<<fold->GetName()<<
"++++++++++" << std::endl;
1724 GO4TRACE((11,
"TGo4AnalysisObjectManager::ClearFolder(TFolder *, Option_t *)",__LINE__, __FILE__));
1725 if(!fold)
return kFALSE;
1727 TIter iter(fold->GetListOfFolders());
1728 while(
auto ob = iter())
1729 if(ob->InheritsFrom(TFolder::Class()))
1738 GO4TRACE((11,
"TGo4AnalysisObjectManager::ClearObject(TObject *)",__LINE__, __FILE__));
1739 Bool_t rev = kFALSE;
1744 if (ob->InheritsFrom(TH1::Class())) {
1745 TH1 *his =
dynamic_cast<TH1 *
>(ob);
1748 }
else if (ob->InheritsFrom(TGo4DynamicEntry::Class())) {
1752 }
else if (ob->InheritsFrom(TGo4Picture::Class())) {
1756 }
else if (ob->InheritsFrom(TGraph::Class())) {
1757 TGraph *gr =
dynamic_cast<TGraph *
>(ob);
1763 }
else if (ob->InheritsFrom(TMultiGraph::Class())) {
1764 TMultiGraph *mg =
dynamic_cast<TMultiGraph *
>(ob);
1766 TIter liter(mg->GetListOfGraphs());
1767 while (
auto gr = liter())
1770 }
else if (ob->InheritsFrom(TGo4EventElement::Class())) {
1774 }
else if (ob->InheritsFrom(TTree::Class())) {
1789 GO4TRACE((11,
"TGo4AnalysisObjectManager::DeleteFolder(TFolder *)", __LINE__, __FILE__));
1794 TIter iter(fold->GetListOfFolders());
1795 while (
auto ob = iter())
1796 if (ob->InheritsFrom(TFolder::Class()))
1805 GO4TRACE((11,
"TGo4AnalysisObjectManager::DeleteObject(TObject *)",__LINE__, __FILE__));
1818 TIter listiter(fold->GetListOfFolders());
1819 while (
auto ob = listiter())
1820 if (ob->InheritsFrom(TFolder::Class()))
1829 if(!ob || !flags)
return kFALSE;
1830 TString opt = flags;
1840 GO4TRACE((11,
"TGo4AnalysisObjectManager::CleanupDynamicLists(TNamed*)", __LINE__, __FILE__));
1845 if (oldobject->InheritsFrom(TH1::Class()) || oldobject->InheritsFrom(TGo4Condition::Class()) ||
1846 oldobject->InheritsFrom(TGo4EventElement::Class()))
1852 GO4TRACE((11,
"TGo4AnalysisObjectManager::PrintConditions(const char *)",__LINE__, __FILE__));
1854 std::cout <<
"___________________________________________________________" << std::endl;
1855 std::cout <<
"Total size of all conditions is: " << totalsize <<
" bytes." << std::endl;
1860 GO4TRACE((11,
"TGo4AnalysisObjectManager::PrintHistograms(const char *)",__LINE__, __FILE__));
1862 std::cout <<
"___________________________________________________________" << std::endl;
1863 std::cout <<
"Total size of all histograms is: " << totalsize <<
" bytes." << std::endl;
1868 GO4TRACE((11,
"TGo4AnalysisObjectManager::PrintParameters(const char *)",__LINE__, __FILE__));
1870 std::cout <<
"___________________________________________________________" << std::endl;
1871 std::cout <<
"Total size of all parameters is: " << totalsize <<
" bytes." << std::endl;
1888 TFolder *searchfold;
1899 auto result =
new TList;
1901 TIter iter(fold->GetListOfFolders());
1902 while(
auto entry = iter()) {
1903 if(entry->InheritsFrom(TFolder::Class())) {
1904 auto subfold=
dynamic_cast<TFolder *
>(entry);
1907 result->AddAll(sublist);
1909 if(entry->InheritsFrom(TTree::Class())) {
1911 if(entry->InheritsFrom(TGo4EventElement::Class())) {
1913 if(entry->InheritsFrom(TGo4EventSource::Class())) {
1915 if(entry->InheritsFrom(TGo4EventStore::Class())) {
1917 if(entry->InheritsFrom(TGo4EventProcessor::Class())) {
1920 result->AddLast(entry);
1929 if(!expression)
return kTRUE;
1930 Bool_t ismatching = kFALSE;
1931 TString entrystring = string;
1932 TRegexp reg(expression,kTRUE);
1933 if(!strcmp(expression,
"*"))
1937 else if (entrystring.Index(reg,0)!=kNPOS)
1940 ismatching = kFALSE;
1947 GO4TRACE((12,
"TGo4AnalysisObjectManager::FindObjectInFolder(TFolder *, const char *)",__LINE__, __FILE__));
1950 return folder ? folder->FindObjectAny(fullname) :
nullptr;
1956 if (pathname && (strlen(pathname) == 0))
1959 fullname = pathname;
1962 fullname += objectname;
1966 if (obj && !obj->InheritsFrom(cl)) {
1977 if (!obj)
return kFALSE;
1981 if (fold->GetListOfFolders()->FindObject(obj) == obj) {
1986 TIter iter(fold->GetListOfFolders());
1987 while (
auto sub = iter()) {
1988 if (!sub->InheritsFrom(TFolder::Class()))
continue;
1990 if (pathname.IsNull())
1991 pathname = sub->GetName();
1993 pathname = TString(sub->GetName()) +
"/" + pathname;
#define fguSUBFOLDERMAXLEN
static const char * GetTMPFOLDER()
TH1 * MakeTH1(const char *histotype, const char *foldername, const char *histoname, Int_t nbinsx, Axis_t xlow, Axis_t xup, const char *title=nullptr, const char *xtitle=nullptr, const char *ytitle=nullptr)
Create 1-dim histogram in histogram folder.
TFolder * fxEventDir
Directory containing references to event structures.
Bool_t IsMatching(const char *string, const char *expression) const
Finds out if string is matching the expression.
Bool_t RemoveTree(TTree *tree, const char *stepname=nullptr)
Remove reference to a tree in the go4 folder structure.
void PrintDynamicList()
Print entries of current dynamic list.
Bool_t ProtectFolder(TFolder *fold, const Option_t *flags)
Change protection properties of all objects in this folder as specified.
Bool_t ClearFolder(TFolder *fold)
Clear (reset) all objects in folder fold, e.g.
static const char * GetTOPDYNAMICLIST()
Int_t fiDynListCount
Event counter for dynamic list processing.
Bool_t AddCanvas(TCanvas *can, const char *subfolder=nullptr)
Puts a new TCanvas in corresponding folder.
Bool_t ProtectObjects(const char *name, const Option_t *flags)
Change protection properties of object name as specified.
void PrintConditions(const char *expression=nullptr)
Print all condition counters to the terminal.
TGo4AnalysisObjectManager()
Bool_t fbCreatedinMake
Boolean flag indicates, if object was created in last calls of one of Make* functions.
static const char * GetTREEFOLDER()
Bool_t AddParameter(TGo4Parameter *par, const char *subfolder=nullptr)
Puts a new parameter object in corresponding folder.
void SaveObjects(TFile *file)
Save folder structure to given file.
Int_t PrintFolder(TFolder *fold, Option_t *opt, const char *expression=nullptr)
Printout all objects in folder fold on the terminal.
static const char * GetHISTFOLDER()
static const char * fgcSRCFOLDER
Event source reference folder name.
Bool_t DeleteObjects(const char *name)
Delete object of name, or all objects in folder name, respectively.
TFolder * fxTempFolder
Temporary folder for nameslist objects.
TGo4Condition * GetAnalysisCondition(const char *name, const char *cond_cl=nullptr)
Retrieves an analysis condition from list by name.
Bool_t ClearObjects(const char *name)
Clear (reset) the specified objects.
Bool_t AddEventStructure(TGo4EventElement *ev)
Add reference to event structure object to Go4 Folder structure.
void AppendToDir(TObject *ob, TDirectory *dir)
Append object ob to directory dir.
void CloseAnalysis()
Cleanups required when analysis is closed.
static const char * GetSTOREFOLDER()
Bool_t RemoveParameter(const char *name)
Removes parameter by name.
Bool_t AddObject(TNamed *anything, const char *subfolder=nullptr, Bool_t replace=kTRUE)
Add any external object to the user object folder.
Bool_t DeleteFolder(TFolder *fold)
Delete all objects in folder fold only if the kGo4CanDelete bit is set.
Bool_t RemoveEventProcessor(TGo4EventProcessor *pro)
Remove reference to event processor from go4 folder structure.
TH1 * GetHistogram(const char *name)
Search histogram in histogram list (directory).
TFolder * CreateCompositeBranchFolder(TObjArray *branchlist, TGo4CompositeEvent *compevent, Int_t startindex, Int_t *skip, const char *name, const char *title)
Create a folder with subfolders from a list of TBranchElements that belongs to a TGo4CompositeEvent.
Bool_t SetParameterStatus(const char *name, TGo4ParameterStatus *par, TFolder *parent=nullptr)
Set existing parameter of name to the values of external parameter object par.
static const char * GetUSRFOLDER()
static const char * GetDYNFOLDER()
Bool_t RemovePicture(const char *name)
Removes picture by name.
void RecursiveRemove(TObject *obj) override
Method used in case when object is cleaned up by the ROOT.
static const char * fgcTREEFOLDER
Tree reference folder name.
Bool_t RemoveEventSource(TGo4EventSource *source)
Remove reference to event source from go4 folder structure.
static const char * fgcUSRFOLDER
User objects folder name.
Bool_t AddTree(TTree *tree, const char *subfolder=nullptr)
Add reference to a tree in the go4 folder structure.
Bool_t fbSuppressLoadHistograms
If this is set to true, any found histogram will not be loaded from the file current TDirectory.
TFolder * fxAnalysisDir
Top Directory for all references to event classes.
TGo4ObjectStatus * CreateObjectStatus(const char *name, const char *folder=nullptr)
Find Object of name in the folder structure and create a complete status object of it.
void ProcessDynamicList()
Loop over the dynamic list and process the actions linked to the entries.
TFolder * GetObjectFolder()
Access to top folder of all objects.
void CleanupDynamicLists(TObject *oldobject)
Remove reference to object from all dynamic lists.Object type is noticed automatically.
Bool_t AddHistogram(TH1 *his, const char *subfolder=nullptr, Bool_t replace=kTRUE)
Add external histogram to go4 histogram directory.
static const char * fgcTOPFOLDER
Top level folder name.
TFolder * fxTreeDir
Directory containing references to trees.
TList * fxMatchList
List of matching objects for name expression.
TObject * TestObject(TFolder *folder, const char *&pathname, const char *objectname, const TClass *cl)
Test, if object exists in provided folder.
static const char * GetTOPFOLDER()
Bool_t RemoveDynamicEntry(const char *entryname)
Remove entry of that name from dynamic list of listname.
Bool_t fbSortedOrder
Is sub-folder created is sorted order.
void PrintParameters(const char *expression=nullptr)
Print all parameters to the terminal.
static const char * GetSRCFOLDER()
Bool_t RemoveEventStructure(TGo4EventElement *ev)
Remove reference to event structure from go4 folder structure.
TObject * FindObjectInFolder(TFolder *folder, const char *fullname) const
Search in folder for object with specified name Uses fxDirMutex until search is working.
Bool_t ResetBackStores(Bool_t clearflag=kFALSE)
Reset all registered backstore instances.Called by dynamic list processing.
TGo4WinCond * MakeWindowCond(const char *foldername, const char *conditionname, Double_t xlow, Double_t xup, const char *bindhistogram=nullptr, Bool_t invert=kFALSE)
Create 1-dim window condition in conditions folder.
Bool_t RemoveEventStore(TGo4EventStore *store)
Remove reference to event store from go4 folder structure.
TFolder * fxCanvasDir
Directory containing TCanvases.
Bool_t AddObjectToFolder(TObject *ob, TFolder *fold, const char *subfolder=nullptr, Bool_t replace=kTRUE, Bool_t uniquename=kFALSE, Bool_t resetbits=kTRUE)
Add any named object to a folder.
TCanvas * GetCanvas(const char *name)
Retrieves a TCanvas by name from the Canvases folder.
TFolder * fxProcessorDir
Directory containing references to event processors.
TMutex * fxDirMutex
Mutex protecting the object directories.
Bool_t SetPicture(const char *name, TGo4Picture *pic, TFolder *parent=nullptr)
Set existing picture of name to the values of external picture object pic.
Bool_t AddEventProcessor(TGo4EventProcessor *pro)
Add reference to event processor object to Go4 Folder structure.
Bool_t AddDynamicHistogram(const char *name, const char *histo, const char *hevx, const char *hmemx, const char *hevy=nullptr, const char *hmemy=nullptr, const char *hevz=nullptr, const char *hmemz=nullptr, const char *condition=nullptr, const char *cevx=nullptr, const char *cmemx=nullptr, const char *cevy=nullptr, const char *cmemy=nullptr)
Add (create) new dynamic histogram entry which connects an existing histogram with existing condition...
static const char * GetPICTFOLDER()
TGo4AnalysisObjectNames * CreateNamesList()
Creates a list of names (keys) of all objects in analysis directories.
TFolder * fxSourceDir
Directory containing references to event sources.
TObject * NextMatchingObject(const char *expr, const char *folder, Bool_t reset)
Delivers pointer to next object of the Go4 folder structure with a name matching the expression expr.
static const char * fgcPARAFOLDER
Analysis user parameters folder name.
TH2 * MakeTH2(const char *histotype, const char *foldername, const char *histoname, Int_t nbinsx, Axis_t xlow, Axis_t xup, Int_t nbinsy, Axis_t ylow, Axis_t yup, const char *title=nullptr, const char *xtitle=nullptr, const char *ytitle=nullptr)
Create 2-dim histogram in histogram folder.
TGo4Parameter * GetParameter(const char *name, const char *parameter_class=nullptr)
Retrieves a parameter object by name from the object folder.
Bool_t AddDynamicEntry(TGo4DynamicEntry *entry)
Adds entry to object manager.
TObject * GetAsTObject(const char *name, const char *folder=nullptr)
Searches for object by name in all go4 folders.
TFolder * fxParameterDir
Directory containing user parameter objects.
static const char * fgcCONDFOLDER
Analysis conditions folder name.
Bool_t RemoveHistogram(const char *name, Bool_t del=kTRUE)
Removes histogram from histogram dir by name.
TList * CreateObjectList(const char *expr, const char *folder=nullptr)
Create a list of objects which names are matching expression expr.
Bool_t SaveFolder(TFolder *source)
Save this folder as a new subdirectory (TDirectory) of the current directory i.e.
static const char * fgcSTOREFOLDER
Event store reference folder name.
Bool_t IsSortedOrder() const
Returns true if sub-folders will be created in sorted order.
TGo4EventElement * GetEventStructure(const char *name) const
Search reference to event structure in folder.
static const char * GetANALYSISFOLDER()
static const char * fgcHISTFOLDER
Histograms folder name.
TFolder * fxStoreDir
Directory containing references to event stores.
TFolder * fxPictureDir
Directory containing the pictures.
Bool_t AddAnalysisCondition(TGo4Condition *con, const char *subfolder=nullptr)
Puts a new analysis condition object in corresponding list.
TFolder * fxDynListDir
Directory containing all action objects to be used by dynamic list and by user analysis.
TFolder * fxConditionDir
Directory containing all condition objects to be used by dynamic list and by user analysis.
Bool_t AddEventSource(TGo4EventSource *source)
Add reference to event source object to Go4 Folder structure.
static const char * GetPARAFOLDER()
TFolder * FindSubFolder(TFolder *parent, const char *subfolder, Bool_t create=kTRUE)
Get pointer to subfolder of parent specified by name.
Bool_t LoadFolder(TFolder *source, TFolder *destination, Bool_t replace=kFALSE)
Update folder destination with the content of the folder source.
TNamed * GetObject(const char *name, const char *folder=nullptr)
Searches for object by name in all go4 folders.
static const char * fgcPICTFOLDER
Picture objects folder name.
static const char * fgcTOPDYNAMICLIST
Default name of the default (toplevel) dynamic list.
TFolder * CreateMembersFolder(TObject *obj, const char *membrfoldername, TClass *cl)
Create a folder with members of this class.
Bool_t DeleteObject(TObject *ob)
Delete the specified object if the kGo4CanDelete bit is set.
TGo4Picture * GetPicture(const char *name)
Retrieves a picture object by name from the object folder.
static const char * fgcANALYSISFOLDER
top analysis objects reference folder name
static const char * fgcTMPFOLDER
Temporary dummy folder name.
static const char * GetCANVFOLDER()
TFolder * CreateBranchFolder(TObjArray *branchlist, const char *name, const char *title, Bool_t istopbranch=kFALSE)
Create a folder with subfolders from a list of TBranchElements.
void ResetCurrentDynList()
Reset the current dynamic list.
void RemoveFromDir(TFolder *fold, TDirectory *dir)
Remove all objects in folder fold from directory dir, recursively.
static const char * fgcEVENTFOLDER
Event references folder name.
TIterator * fxMatchIterator
Iterator for list of matching objects.
Bool_t AddPicture(TGo4Picture *pic, const char *subfolder=nullptr)
Puts a new picture object in corresponding folder.
TGo4PolyCond * MakePolyCond(const char *foldername, const char *conditionname, Int_t size, Float_t(*points)[2], const char *bindhistogram=nullptr, Bool_t invert=kFALSE)
Create polygon 2-dim condition in conditions folder.
static const char * GetPROCFOLDER()
TFolder * fxGo4Dir
Top level Go4 Directory (root folder)
Bool_t PutToFolder(TObject *ob, TFolder *destination, Bool_t replace=kFALSE)
Method used by both LoadFolder variants to assign object ob into destination folder by object type.
Bool_t SetAnalysisCondition(const char *name, TGo4Condition *con, Bool_t counter=kTRUE, TFolder *parent=nullptr)
Set existing analysis condition of name to the values of external condition object con.
TTree * GetTree(const char *name)
Search tree in tree folder.
static const char * GetEVENTFOLDER()
TGo4TreeStructure * CreateTreeStructure(TTree *thetree)
Create a tree structure object that maps the TBranchelements into a TFolder hierarchy.
Bool_t ClearObject(TObject *ob)
Clear (reset) the specified object.
Int_t GetDynListInterval() const
TFolder * fxUserDir
Directory containing all user objects.
Bool_t LoadObjects(TFile *statusfile)
Load objects from file.
TFolder * fxHistogramDir
Directory containing all histogram objects to be used by dynamic list and user analysis.
Bool_t RemoveObject(const char *name, Bool_t del=kTRUE)
Removes object from user object folder by name.
Bool_t AddTreeHistogram(const char *hisname, const char *treename, const char *varexp, const char *cutexp)
Add Histogram into the dynamic list which is linked to a tree.
Bool_t ProtectObject(TObject *ob, const Option_t *flags)
Change protection properties of object name as specified.
Int_t fiDynListInterval
Interval for dynamic list processing.
static const char * fgcCANVFOLDER
TCanvas folder name.
Bool_t RemoveObjectFromFolder(const char *fullname, TFolder *fold, Bool_t isDel)
Remove object specified by full name ("subfolder/subssubfolder/name") from folder fold.
void PrintHistograms(const char *expression=nullptr)
Printout of all histogram statistic counters on the terminal.
static const char * fgcPROCFOLDER
Event processor reference folder name.
Bool_t RemoveAnalysisCondition(const char *name)
Removes analysis condition from list by name.
TFolder * CreateNamesFolder(TFolder *objectfolder)
Conversion of the TFolder of objects into a TFolder containing the object names as TObjectStrings.
Bool_t AddEventStore(TGo4EventStore *store)
Add reference to event store object to Go4 Folder structure.
Bool_t FindObjectPathName(TObject *obj, TString &pathname, TFolder *fold=nullptr)
Return full path name to object, relative to specified folder.
static const char * GetCONDFOLDER()
static const char * fgcDYNFOLDER
Dynamic lists folder name.
Bool_t SetParameter(const char *name, TGo4Parameter *par, TFolder *parent=nullptr)
Set existing parameter of name to the values of external parameter object par.
virtual ~TGo4AnalysisObjectManager()
Bool_t RemoveCanvas(const char *name)
Removes TCanvas by name.
Contains the name (key) list of all objects in the analysis scope.
TFolder * fxTopFolder
Top Level Go4 Folder with all subfolders and the analysis folder contents as TObjString instances.
static TGo4Analysis * Instance()
return analysis instance
void Message(Int_t prio, const char *text,...)
Display a user message.
const char * GetName() const override
Return analysis name.
Event store to keep the last n events in a TTree which is not saved to a file.
void Reset(Bool_t onlyclearflag=kFALSE)
Dynamic list might reset backstore after processing.
Base type for object composition.
TObjArray * getListOfComposites(Bool_t toplevel=kTRUE)
Short_t getNElements() const
virtual Bool_t UpdateFrom(TGo4Condition *cond, Bool_t counts)
Copy values from cond to this.
void SetHistogram(const char *name)
Define the name of the associated histogram.
virtual void Invert(Bool_t on)
Inverts return values, when on is true, i.e.
ABC for all entries that can be kept in a dynamic list.
virtual void Reset()
Resets this entry to an initial status.
static void ProcessEntries(TFolder *folder, Bool_t processtrees, Int_t interval)
Iterates all entries of the list and processes the objects, depending on coordinate values and analys...
static void PrintEntries(TFolder *folder)
static void ResetEntries(TFolder *folder)
static void CleanupPointerInEntries(TFolder *folder, TObject *obj)
The abstract base class for the data elements of which the unpacked events (or detector structure dat...
virtual TGo4EventElement * GetChild(const char *name)
Abstract event processor.
The abstract interface class for the raw event store.
Entry for the dynamic list, specialized for histogram like objects.
Runtime status of a histogram object.
static void Info(const char *text,...) GO4_PRINTF_ARGS
User shortcut for message with prio 1.
One entry of the object names folder.
Int_t GetObjectSize() const
Size of described object in byte.
Status object for an analysis parameter.
TGo4Parameter * CreateParameter()
Bool_t UpdateParameterValues(TGo4Parameter *par)
Base class for all parameter aggregations, e.g.
virtual Bool_t UpdateFrom(TGo4Parameter *rhs)
Update contents of parameter class with external object.
Picture cconfiguration in Go4.
void UpdateFrom(TGo4Picture *source, TClass *selectedobjclass=nullptr)
static void CleanupSpecials()
Remove all references to any TCutGs from ROOT list of specials.
void SetValues(Double_t *x, Double_t *y, Int_t len) override
Delete old cut and create a new cut with X,Y values.
Dynamic list entry which links a histogram to a certain tree.
Contains the branchelement structure of a certain TTree on the analysis side.
TFolder * fxTopFolder
Folder containing the tree structure.
void SetValues(Double_t low1, Double_t up1) override
Set limits and internal dimension to 1.