a macro with TPC,ITS, ITSSPD vertex, global vertex and v0's
[u/mrichter/AliRoot.git] / ANALYSIS / AliTagAnalysis.cxx
1 /**************************************************************************
2  * Author: Panos Christakoglou.                                           *
3  * Contributors are mentioned in the code where appropriate.              *
4  *                                                                        *
5  * Permission to use, copy, modify and distribute this software and its   *
6  * documentation strictly for non-commercial purposes is hereby granted   *
7  * without fee, provided that the above copyright notice appears in all   *
8  * copies and that both the copyright notice and this permission notice   *
9  * appear in the supporting documentation. The authors make no claims     *
10  * about the suitability of this software for any purpose. It is          *
11  * provided "as is" without express or implied warranty.                  *
12  **************************************************************************/
13
14 /* $Id$ */
15
16 //-----------------------------------------------------------------
17 //           AliTagAnalysis class
18 //   This is the class to deal with the tag analysis
19 //   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
20 //-----------------------------------------------------------------
21
22 //ROOT
23 #include <Riostream.h>
24 #include <TSystem.h>
25 #include <TChain.h>
26 #include <TFile.h>
27 #include <TEventList.h>
28 #include <TEntryList.h>
29 #include <TTreeFormula.h>
30 #include <TMap.h>
31
32 //ROOT-AliEn
33 #include <TGridResult.h>
34
35 #include "AliLog.h"
36
37 #include "AliRunTag.h"
38 #include "AliEventTag.h"
39 #include "AliTagAnalysis.h"
40 #include "AliEventTagCuts.h"
41 #include "AliDetectorTagCuts.h"
42 #include "AliLHCTagCuts.h"
43 #include "AliRunTagCuts.h"
44 #include "AliXMLCollection.h"
45
46 class TTree;
47
48 ClassImp(AliTagAnalysis)
49
50 //___________________________________________________________________________
51 AliTagAnalysis::AliTagAnalysis(): 
52   TObject(),
53   ftagresult(0x0),
54   fTagDirName(),
55   fChain(0x0),
56   fAnalysisType(),
57   fGlobalList(0) {
58   //Default constructor for a AliTagAnalysis
59 }
60
61 //___________________________________________________________________________
62 AliTagAnalysis::AliTagAnalysis(const char* type): 
63   TObject(),
64   ftagresult(0x0),
65   fTagDirName(),
66   fChain(0x0),
67   fAnalysisType(type),
68   fGlobalList(0) {
69   //constructor for a AliTagAnalysis
70 }
71
72 //___________________________________________________________________________
73 AliTagAnalysis::~AliTagAnalysis() {
74   //Default destructor for a AliTagAnalysis
75   if(ftagresult) delete ftagresult;
76   if(fChain) delete fChain;
77   if(fGlobalList) delete fGlobalList;
78 }
79
80 //___________________________________________________________________________
81 Bool_t  AliTagAnalysis::AddTagsFile(const char *alienUrl) {
82   // Add a single tags file to the chain
83
84   Bool_t rv = kTRUE ;
85
86   if (! fChain) fChain = new TChain("T");
87
88   TFile *f = TFile::Open(alienUrl,"READ");
89   fChain->Add(alienUrl);
90   AliInfo(Form("Chained tag files: %d ",fChain->GetEntries()));
91   delete f;
92
93   if (fChain->GetEntries() == 0 )
94     rv = kFALSE ;
95
96   return rv ;
97 }
98
99 //___________________________________________________________________________
100 void AliTagAnalysis::ChainLocalTags(const char *dirname) {
101   //Searches the entries of the provided direcory
102   //Chains the tags that are stored locally
103   fTagDirName = dirname;
104   TString fTagFilename;
105   
106   if (! fChain)  fChain = new TChain("T");
107   const char * tagPattern = 0x0;
108   if(fAnalysisType == "ESD") tagPattern = "ESD.tag.root";
109   else if(fAnalysisType == "AOD") tagPattern = "AOD.tag.root";
110   else AliFatal("Only ESD and AOD type is implemented!!!");
111
112   // Open the working directory
113   void * dirp = gSystem->OpenDirectory(fTagDirName);
114   const char * name = 0x0;
115   // Add all files matching *pattern* to the chain
116   while((name = gSystem->GetDirEntry(dirp))) {
117     if (strstr(name,tagPattern)) { 
118       fTagFilename = fTagDirName;
119       fTagFilename += "/";
120       fTagFilename += name;
121                 
122       fChain->Add(fTagFilename);  
123       printf("Tag file %s\n", fTagFilename.Data());
124       
125     }//pattern check
126   }//directory loop
127   AliInfo(Form("Chained tag files: %d ",fChain->GetEntries()));
128   fChain->ls();
129   
130 }
131
132
133 //___________________________________________________________________________
134 TChain * AliTagAnalysis::ChainGridTags(TGridResult *res) {
135   //Loops overs the entries of the TGridResult
136   //Chains the tags that are stored in the GRID
137   ftagresult = res;
138   Int_t nEntries = ftagresult->GetEntries();
139  
140   if (! fChain)  fChain = new TChain("T");
141
142   TString gridname = "alien://";
143   TString alienUrl;
144  
145   for(Int_t i = 0; i < nEntries; i++) {
146     alienUrl = ftagresult->GetKey(i,"turl");
147     fChain->Add(alienUrl);
148   }//grid result loop
149   return fChain;
150 }
151
152
153 //___________________________________________________________________________
154 TChain *AliTagAnalysis::QueryTags(AliRunTagCuts *runTagCuts, 
155                                   AliLHCTagCuts *lhcTagCuts, 
156                                   AliDetectorTagCuts *detTagCuts, 
157                                   AliEventTagCuts *evTagCuts) {
158   //Queries the tag chain using the defined 
159   //event tag cuts from the AliEventTagCuts object
160   //and returns a TChain along with the associated TEventList
161   AliInfo(Form("Querying the tags........"));
162
163   Bool_t aod = kFALSE;
164   TString aliceFile;
165   if(fAnalysisType == "ESD") aliceFile = "esdTree";
166   else if(fAnalysisType == "AOD") {
167       aliceFile = "aodTree";
168       aod = kTRUE;
169   }
170   else AliFatal("Only ESD and AOD type is implemented!!!");
171
172   //ESD file chain
173   TChain *esdChain = new TChain(aliceFile.Data());
174   //global entry list
175   fGlobalList = new TEntryList();
176   
177   //Defining tag objects
178   AliRunTag   *tag     = new AliRunTag;
179   AliEventTag *evTag   = new AliEventTag;
180   fChain->SetBranchAddress("AliTAG",&tag);
181
182   TString guid;
183   TString turl;
184   TString path;
185
186   TTree*      cTree     = 0; 
187   TEntryList* localList = new TEntryList();
188
189   Int_t iAccepted = 0;
190   Int_t iev       = 0;
191   Int_t ientry    = 0;
192   Int_t cEntries  = 0;
193   
194   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
195     fChain->GetEntry(iTagFiles);
196     TTree* tree = fChain->GetTree();
197     if (cTree != tree) {
198         // Fix for aod tags: for each tree in the chain, merge the entries
199         cTree    = tree;
200         cEntries = tree->GetEntries();
201         iev      = 0;
202         ientry   = 0;
203     }
204
205     if(runTagCuts->IsAccepted(tag)) {
206       if(lhcTagCuts->IsAccepted(tag->GetLHCTag())) {
207         if(detTagCuts->IsAccepted(tag->GetDetectorTags())) {
208           if ((iev == 0) || !aod) localList->Reset();
209           Int_t iEvents = tag->GetNEvents();
210           const TClonesArray *tagList = tag->GetEventTags();
211           for(Int_t i = 0; i < iEvents; i++) {
212             evTag = (AliEventTag *) tagList->At(i);
213             guid = evTag->GetGUID(); 
214             turl = evTag->GetTURL(); 
215             path = evTag->GetPath();
216             localList->SetTreeName(aliceFile.Data());
217             if(turl!="") localList->SetFileName(turl.Data());
218             else localList->SetFileName(path.Data());
219
220             if(evTagCuts->IsAccepted(evTag)) {
221                 if(aod) localList->Enter(iev);
222                 else localList->Enter(i);
223             }
224             iev++;
225           }//event loop
226           if ((ientry == cEntries-1) || !aod) {
227               iAccepted += localList->GetN();
228               if(path != "") esdChain->AddFile(path);
229               else if(turl != "") esdChain->AddFile(turl);
230               fGlobalList->Add(localList);
231           }
232         }//detector tag cuts
233       }//lhc tag cuts
234     }//run tags cut
235     tag->Clear();
236     ientry++;
237   }//tag file loop
238   AliInfo(Form("Accepted events: %d",iAccepted));
239   esdChain->ls();
240   esdChain->SetEntryList(fGlobalList,"ne");
241   delete tag;
242   
243   return esdChain;
244 }
245
246 //___________________________________________________________________________
247 TChain *AliTagAnalysis::QueryTags(const char *fRunCut, 
248                                   const char *fLHCCut, 
249                                   const char *fDetectorCut, 
250                                   const char *fEventCut) {       
251   //Queries the tag chain using the defined      
252   //event tag cuts from the AliEventTagCuts object       
253   //and returns a TChain along with the associated TEventList    
254   AliInfo(Form("Querying the tags........"));    
255   
256   Bool_t aod = kFALSE;
257   TString aliceFile;
258   if(fAnalysisType == "ESD") aliceFile = "esdTree";
259   else if(fAnalysisType == "AOD") {
260       aliceFile = "aodTree";
261       aod = kTRUE;
262   }
263   else AliFatal("Only ESD and AOD type is implemented!!!");
264
265   //ESD file chain
266   TChain *esdChain = new TChain(aliceFile.Data());
267   //global entry list
268   fGlobalList = new TEntryList();
269   
270   //Defining tag objects         
271   AliRunTag   *tag   = new AliRunTag;    
272   AliEventTag *evTag = new AliEventTag;          
273   fChain->SetBranchAddress("AliTAG",&tag);       
274   
275   TString guid;          
276   TString turl;          
277   TString path;          
278   
279   TTreeFormula *fRunFormula = new TTreeFormula("fRun",fRunCut,fChain);   
280   TTreeFormula *fLHCFormula = new TTreeFormula("fLHC",fLHCCut,fChain);   
281   TTreeFormula *fDetectorFormula = new TTreeFormula("fDetector",fDetectorCut,fChain);
282   TTreeFormula *fEventFormula = new TTreeFormula("fEvent",fEventCut,fChain);
283   
284   TEntryList* localList = new TEntryList();
285
286   Int_t iev       = 0;
287   Int_t ientry    = 0;
288   Int_t cEntries  = 0;
289   Int_t current   = -1;          
290   Int_t iAccepted = 0;   
291
292   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
293     fChain->GetEntry(iTagFiles);         
294     if (current != fChain->GetTreeNumber()) {    
295       fRunFormula->UpdateFormulaLeaves();        
296       fLHCFormula->UpdateFormulaLeaves();        
297       fDetectorFormula->UpdateFormulaLeaves();   
298       fEventFormula->UpdateFormulaLeaves();      
299       // Fix for aod tags: for each tree in the chain, merge the entries
300       cEntries = (fChain->GetTree())->GetEntries();
301       iev      = 0;
302       ientry   = 0;
303       //
304       current = fChain->GetTreeNumber();         
305     }    
306     if(fRunFormula->EvalInstance(iTagFiles) == 1) {      
307       if(fLHCFormula->EvalInstance(iTagFiles) == 1) {    
308         if(fDetectorFormula->EvalInstance(iTagFiles) == 1) {
309           if ((iev == 0) || !aod) localList->Reset();    
310           Int_t iEvents = fEventFormula->GetNdata();     
311           const TClonesArray *tagList = tag->GetEventTags();     
312           for(Int_t i = 0; i < iEvents; i++) {   
313             evTag = (AliEventTag *) tagList->At(i);      
314             guid = evTag->GetGUID();     
315             turl = evTag->GetTURL();     
316             path = evTag->GetPath();     
317             localList->SetTreeName(aliceFile.Data());
318             localList->SetFileName(turl.Data());
319             if(fEventFormula->EvalInstance(i) == 1) {
320                 if(aod) localList->Enter(iev);
321                 else localList->Enter(i);
322             }
323             iev++;
324           }//event loop          
325
326           if ((ientry == cEntries-1) || !aod) {  
327               if(path != "") esdChain->AddFile(path);    
328               else if(turl != "") esdChain->AddFile(turl);       
329               fGlobalList->Add(localList);
330               iAccepted += localList->GetN();
331           }
332         }//detector tag cuts
333       }//lhc tag cuts
334     }//run tag cut       
335     tag->Clear();
336     ientry++;
337   }//tag file loop       
338   AliInfo(Form("Accepted events: %d",iAccepted));        
339   esdChain->SetEntryList(fGlobalList,"ne");      
340
341   delete tag;
342   return esdChain;       
343 }
344
345 //___________________________________________________________________________
346 Bool_t AliTagAnalysis::CreateXMLCollection(const char* name, 
347                                            AliRunTagCuts *runTagCuts, 
348                                            AliLHCTagCuts *lhcTagCuts, 
349                                            AliDetectorTagCuts *detTagCuts, 
350                                            AliEventTagCuts *evTagCuts) {
351   //Queries the tag chain using the defined 
352   //event tag cuts from the AliEventTagCuts object
353   //and returns a XML collection
354   AliInfo(Form("Creating the collection........"));
355
356   Bool_t aod = kFALSE;
357   if(fAnalysisType == "AOD") aod = kTRUE;
358
359
360   AliXMLCollection *collection = new AliXMLCollection();
361   collection->SetCollectionName(name);
362   collection->WriteHeader();
363
364   TString guid;
365   TString turl;
366   TString lfn;
367   
368   TTree*      cTree = 0; 
369   TEntryList* localList = new TEntryList();
370   Int_t iAccepted = 0;
371   Int_t iev       = 0;
372   Int_t ientry    = 0;
373   Int_t cEntries  = 0;
374
375   Int_t iRejectedRun = 0;
376   Int_t iRejectedLHC = 0;
377   Int_t iRejectedDet = 0;
378   Int_t iRejectedEvt = 0;
379
380   Int_t iTotalEvents = 0;
381
382   Int_t iAcceptedEvtInFile = 0;
383   Int_t iRejectedEvtInFile = 0;
384
385   //Defining tag objects
386   AliRunTag   *tag   = new AliRunTag;
387   AliEventTag *evTag = new AliEventTag;
388   fChain->SetBranchAddress("AliTAG",&tag);
389
390   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
391
392     fChain->GetEntry(iTagFiles);
393     TTree* tree = fChain->GetTree();
394     if (cTree != tree) {
395         // Fix for aod tags: for each tree in the chain, merge the entries
396         cTree    = tree;
397         cEntries = tree->GetEntries();
398         iev      = 0;
399         ientry   = 0;
400     }
401     //Event list
402     iTotalEvents += tag->GetNEvents();
403     if ((iev == 0) || !aod) localList->Reset();
404     if(runTagCuts->IsAccepted(tag)) {
405       if(lhcTagCuts->IsAccepted(tag->GetLHCTag())) {
406         if(detTagCuts->IsAccepted(tag->GetDetectorTags())) {
407           Int_t iEvents = tag->GetNEvents();
408           const TClonesArray *tagList = tag->GetEventTags();
409           iRejectedEvtInFile = 0;
410           iAcceptedEvtInFile = 0;
411           for(Int_t i = 0; i < iEvents; i++) {
412             evTag = (AliEventTag *) tagList->At(i);
413             guid = evTag->GetGUID(); 
414             turl = evTag->GetTURL(); 
415             lfn = turl(8,turl.Length());
416             if(evTagCuts->IsAccepted(evTag)) {
417                 if(aod) localList->Enter(iev);
418                 else localList->Enter(i);
419                 iAcceptedEvtInFile++;
420             }
421             else {
422               iRejectedEvt++;
423               iRejectedEvtInFile++;
424             }
425             iev++;
426           }//event loop
427           if ((ientry == cEntries-1) || !aod) {
428             iAccepted += localList->GetN();
429             collection->WriteBody(iTagFiles+1,guid,lfn,turl,localList,iAcceptedEvtInFile,iRejectedEvtInFile);
430           }
431         }//detector tag cuts
432         else {
433           iRejectedDet += tag->GetNEvents();
434         }
435       }//lhc tag cuts 
436       else {
437         iRejectedLHC += tag->GetNEvents();
438       }
439     }//run tag cuts
440     else {
441       iRejectedRun += tag->GetNEvents();
442     }
443     tag->Clear();
444     ientry++;
445   }//tag file loop
446   collection->WriteSummary(iTotalEvents, iAccepted, iRejectedRun, iRejectedLHC, iRejectedDet, iRejectedEvt);
447   collection->Export();
448   
449   delete tag;
450   return kTRUE;
451 }
452
453 //___________________________________________________________________________
454 Bool_t AliTagAnalysis::CreateXMLCollection(const char* name, 
455                                            const char *fRunCut, 
456                                            const char *fLHCCut, 
457                                            const char *fDetectorCut, 
458                                            const char *fEventCut) {
459   //Queries the tag chain using the defined 
460   //event tag cuts from the AliEventTagCuts object
461   //and returns a XML collection
462   AliInfo(Form("Creating the collection........"));
463
464   Bool_t aod = kFALSE;
465   if(fAnalysisType == "AOD") aod = kTRUE;
466
467   AliXMLCollection *collection = new AliXMLCollection();
468   collection->SetCollectionName(name);
469   collection->WriteHeader();
470
471   TString guid;
472   TString turl;
473   TString lfn;
474   TEntryList* localList = new TEntryList();
475   
476   Int_t iAccepted = 0;
477   Int_t iev       = 0;
478   Int_t ientry    = 0;
479   Int_t cEntries  = 0;
480
481   Int_t iRejectedRun = 0;
482   Int_t iRejectedLHC = 0;
483   Int_t iRejectedDet = 0;
484   Int_t iRejectedEvt = 0;
485
486   Int_t iTotalEvents = 0;
487
488   Int_t iAcceptedEvtInFile = 0;
489   Int_t iRejectedEvtInFile = 0;
490
491   //Defining tag objects
492   AliRunTag *tag     = new AliRunTag;
493   AliEventTag *evTag = new AliEventTag;
494   fChain->SetBranchAddress("AliTAG",&tag);
495
496   TTreeFormula *fRunFormula = new TTreeFormula("fRun",fRunCut,fChain);
497   TTreeFormula *fLHCFormula = new TTreeFormula("fLHC",fLHCCut,fChain);   
498   TTreeFormula *fDetectorFormula = new TTreeFormula("fDetector",fDetectorCut,fChain);
499   TTreeFormula *fEventFormula = new TTreeFormula("fEvent",fEventCut,fChain);
500
501   Int_t current = -1;
502   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
503
504     fChain->GetEntry(iTagFiles);
505     if (current != fChain->GetTreeNumber()) {
506       fRunFormula->UpdateFormulaLeaves();
507       fLHCFormula->UpdateFormulaLeaves();
508       fDetectorFormula->UpdateFormulaLeaves();
509       fEventFormula->UpdateFormulaLeaves();
510       // Fix for aod tags: for each tree in the chain, merge the entries
511       cEntries = (fChain->GetTree())->GetEntries();
512       iev      = 0;
513       ientry   = 0;
514       //
515       current = fChain->GetTreeNumber();
516     }
517     //Event list
518     iTotalEvents += tag->GetNEvents();
519     if ((iev == 0) || !aod) localList->Reset();
520     if(fRunFormula->EvalInstance(iTagFiles) == 1) {
521       if(fLHCFormula->EvalInstance(iTagFiles) == 1) {    
522         if(fDetectorFormula->EvalInstance(iTagFiles) == 1) {     
523           Int_t iEvents = fEventFormula->GetNdata();
524           const TClonesArray *tagList = tag->GetEventTags();
525           iRejectedEvtInFile = 0;
526           iAcceptedEvtInFile = 0;
527           for(Int_t i = 0; i < iEvents; i++) {
528             evTag = (AliEventTag *) tagList->At(i);
529             guid = evTag->GetGUID(); 
530             turl = evTag->GetTURL(); 
531             lfn = turl(8,turl.Length());
532             if(fEventFormula->EvalInstance(i) == 1) {
533                 if(aod) localList->Enter(iev);
534                 else localList->Enter(i);
535                 iAcceptedEvtInFile++;
536             }
537             else {
538               iRejectedEvt++;
539               iRejectedEvtInFile++;
540             }
541             iev++;
542           }//event loop
543           if ((ientry == cEntries-1) || !aod) {
544             collection->WriteBody(iTagFiles+1,guid,lfn,turl,localList,iAcceptedEvtInFile, iRejectedEvtInFile);
545             iAccepted += localList->GetN();
546           }
547         }//detector tag cuts
548         else {
549           iRejectedDet += tag->GetNEvents();
550         }
551       }//lhc tag cuts 
552       else {
553         iRejectedLHC += tag->GetNEvents();
554       }
555     }//run tag cuts
556     else {
557       iRejectedRun += tag->GetNEvents();
558     }
559     ientry++;
560   }//tag file loop
561   collection->WriteSummary(iTotalEvents, iAccepted, iRejectedRun, iRejectedLHC, iRejectedDet, iRejectedEvt);
562   collection->Export();
563
564   delete tag;
565   return kTRUE;
566 }
567
568 //___________________________________________________________________________
569 TChain *AliTagAnalysis::GetInputChain(const char* system, const char *wn) {
570   //returns the chain+event list - used in batch sessions
571   // this function will be removed once the new root 
572   // improvements are committed
573   TString fsystem = system;
574   Int_t iAccepted = 0;
575
576   TChain *fAnalysisChain = 0;
577   if(fAnalysisType == "ESD") fAnalysisChain = new TChain("esdTree");
578   else if(fAnalysisType == "AOD") fAnalysisChain = new TChain("aodTree");
579   else AliFatal("Only ESD and AOD type is implemented!!!");
580   
581   //Event list
582   TEventList *fEventList = new TEventList();
583   AliXMLCollection *collection = AliXMLCollection::Open(wn);
584
585   collection->Reset();
586   while (collection->Next()) {
587     AliInfo(Form("Adding: %s",collection->GetTURL("")));
588     fAnalysisChain->Add(collection->GetTURL(""));
589     TEntryList *list = (TEntryList *)collection->GetEventList("");
590     for(Int_t i = 0; i < list->GetN(); i++) fEventList->Enter(iAccepted+list->GetEntry(i));
591
592     if(fsystem == "pp") iAccepted += 100;
593     else if(fsystem == "PbPb") iAccepted += 1;
594   }
595
596   fAnalysisChain->SetEventList(fEventList);
597   
598   AliInfo(Form("Number of selected events: %d",fEventList->GetN()));
599
600   return fAnalysisChain;
601 }
602
603 //___________________________________________________________________________
604 TChain *AliTagAnalysis::GetChainFromCollection(const char* collectionname, 
605                                                const char* treename) {
606   //returns the TChain+TEntryList object- used in batch sessions
607   TString aliceFile = treename;
608   Int_t iAccepted = 0;
609   TChain *fAnalysisChain = 0;
610   if(aliceFile == "esdTree") fAnalysisChain = new TChain("esdTree");
611   else if(aliceFile == "aodTree") fAnalysisChain = new TChain("aodTree");
612   else AliFatal("Inconsistent tree name - use esdTree or aodTree!");
613
614   //Event list
615   fGlobalList = new TEntryList();
616   AliXMLCollection *collection = AliXMLCollection::Open(collectionname);
617
618   // Tag selection summary per file
619   TMap *tagCutSummary = new TMap();
620   tagCutSummary->SetName("TagCutSumm");
621
622   collection->Reset();
623   while (collection->Next()) {
624     AliInfo(Form("Adding: %s",collection->GetTURL("")));
625     fAnalysisChain->Add(collection->GetTURL(""));
626     TEntryList *list = (TEntryList *)collection->GetEventList("");
627     list->SetTreeName(aliceFile.Data());
628     list->SetFileName(collection->GetTURL(""));
629     fGlobalList->Add(list);
630     iAccepted += list->GetN();
631     if (collection->GetCutSumm())
632       tagCutSummary->Add(new TObjString(collection->GetTURL("")), new TObjString(collection->GetCutSumm()));
633   }
634
635   fAnalysisChain->SetEntryList(fGlobalList,"ne");
636   
637   AliInfo(Form("Number of selected events: %d",iAccepted));
638
639   TList *aUserInfo = fAnalysisChain->GetUserInfo();
640   aUserInfo->Add(tagCutSummary);
641
642   Int_t iAccEv;
643   Int_t iTotalEvents;
644   Int_t iRejRun;
645   Int_t iRejLHC;
646   Int_t iRejDet;
647   Int_t iRejEvt;
648
649   collection->GetCollectionSummary(&iTotalEvents, &iAccEv, &iRejRun, &iRejLHC, &iRejDet, &iRejEvt);
650  
651   char nstr[2000];
652
653   sprintf(nstr, "TotalEvents=%i", iTotalEvents);
654   TObjString *iTotStr = new TObjString(nstr);
655   aUserInfo->Add(iTotStr);
656
657   sprintf(nstr, "AcceptedEvents=%i", iAccepted);
658   TObjString *iAccStr = new TObjString(nstr);
659   aUserInfo->Add(iAccStr);
660
661   sprintf(nstr, "RejectedRun=%i", iRejRun);
662   TObjString *iRejRunStr = new TObjString(nstr);
663   aUserInfo->Add(iRejRunStr);
664
665   sprintf(nstr, "RejectedLHC=%i", iRejLHC);
666   TObjString *iRejLHCStr = new TObjString(nstr);
667   aUserInfo->Add(iRejLHCStr);
668
669   sprintf(nstr, "RejectedDet=%i", iRejDet);
670   TObjString *iRejDetStr = new TObjString(nstr);
671   aUserInfo->Add(iRejDetStr);
672
673   sprintf(nstr, "RejectedEvt=%i", iRejEvt);
674   TObjString *iRejEvtStr = new TObjString(nstr);
675   aUserInfo->Add(iRejEvtStr);
676
677   return fAnalysisChain;
678 }