Add forward declaration for ROOT
[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  
82 AliTagAnalysis::AddTagsFile(const char* alienUrl, Bool_t checkFile) 
83 {
84   /// Add a single tags file to the chain
85   ///
86   /// If checkFile=kTRUE (default) the file is opened to check
87   /// it can be and that it contains data.
88   /// It's safer but a lot longer...
89   
90   if (!fChain) fChain = new TChain("T");
91
92   if ( checkFile )
93   {
94     return ( fChain->AddFile(alienUrl,-1) > 0 );
95   }
96   else
97   {
98     return ( fChain->AddFile(alienUrl) > 0 );
99   }
100
101 }
102
103 //___________________________________________________________________________
104 void AliTagAnalysis::ChainLocalTags(const char *dirname) {
105   //Searches the entries of the provided direcory
106   //Chains the tags that are stored locally
107   fTagDirName = dirname;
108   TString fTagFilename;
109   
110   if (! fChain)  fChain = new TChain("T");
111   const char * tagPattern = 0x0;
112   if(fAnalysisType == "ESD") tagPattern = "ESD.tag.root";
113   else if(fAnalysisType == "AOD") tagPattern = "AOD.tag.root";
114   else AliFatal("Only ESD and AOD type is implemented!!!");
115
116   // Open the working directory
117   void * dirp = gSystem->OpenDirectory(fTagDirName);
118   const char * name = 0x0;
119   // Add all files matching *pattern* to the chain
120   while((name = gSystem->GetDirEntry(dirp))) {
121     if (strstr(name,tagPattern)) { 
122       fTagFilename = fTagDirName;
123       fTagFilename += "/";
124       fTagFilename += name;
125                 
126       fChain->Add(fTagFilename);  
127       printf("Tag file %s\n", fTagFilename.Data());
128       
129     }//pattern check
130   }//directory loop
131   //AliInfo(Form("Chained tag files: %d ",fChain->GetEntries()));
132  // AliDebug(Form("Chained tag files: %d ",fChain->GetEntries()));
133   fChain->ls();
134   
135 }
136
137
138 //___________________________________________________________________________
139 TChain * AliTagAnalysis::ChainGridTags(TGridResult *res) {
140   //Loops overs the entries of the TGridResult
141    //Chains the tags that are stored in the GRID
142   ftagresult = res;
143   Int_t nEntries = ftagresult->GetEntries();
144  
145   if (! fChain)  fChain = new TChain("T");
146
147   TString gridname = "alien://";
148   TString alienUrl;
149  
150   for(Int_t i = 0; i < nEntries; i++) {
151     alienUrl = ftagresult->GetKey(i,"turl");
152     fChain->Add(alienUrl);
153   }//grid result loop
154   return fChain;
155 }
156
157
158 //___________________________________________________________________________
159 TChain *AliTagAnalysis::QueryTags(AliRunTagCuts *runTagCuts, 
160                                   AliLHCTagCuts *lhcTagCuts, 
161                                   AliDetectorTagCuts *detTagCuts, 
162                                   AliEventTagCuts *evTagCuts) {
163   //Queries the tag chain using the defined 
164   //event tag cuts from the AliEventTagCuts object
165   //and returns a TChain along with the associated TEventList
166   AliInfo(Form("Querying the tags........"));
167
168   TString aliceFile;
169   if(fAnalysisType == "ESD") aliceFile = "esdTree";
170   else if(fAnalysisType == "AOD") aliceFile = "aodTree";
171   else AliFatal("Only ESD and AOD type is implemented!!!");
172
173   //ESD file chain
174   TChain *esdChain = new TChain(aliceFile.Data());
175   //global entry list
176   fGlobalList = new TEntryList();
177   
178   //Defining tag objects
179   AliRunTag   *tag     = new AliRunTag;
180   //  AliEventTag *evTag   = 0x0;
181   AliFileTag  *flTag   = 0x0;
182
183   fChain->SetBranchAddress("AliTAG",&tag);
184
185   TString guid;
186   TString turl;
187   TString path;
188
189   TEntryList* localList = new TEntryList();
190
191   Int_t iAccepted = 0;
192   
193   for(Int_t iEntry = 0; iEntry < fChain->GetEntries(); iEntry++) {
194     fChain->GetEntry(iEntry);
195     evTagCuts->InitializeTriggerClasses(tag->GetActiveTriggerClasses());
196
197     if(runTagCuts->IsAccepted(tag)) {
198       if(lhcTagCuts->IsAccepted(tag->GetLHCTag())) {
199         if(detTagCuts->IsAccepted(tag->GetDetectorTags())) {
200           localList->Reset();
201           Int_t iEvents = tag->GetNEvents();
202           
203           for (int i = 0; i < iEvents; i++) {
204             //      evTag = tag->GetEventTag(i);
205             flTag = tag->GetFileTagForEvent(i);
206             guid = flTag->GetGUID();
207             turl = flTag->GetTURL();
208             path = flTag->GetPath();
209             localList->SetTreeName(aliceFile.Data());
210             if(turl!="") localList->SetFileName(turl.Data());
211             else localList->SetFileName(path.Data());
212
213             if(evTagCuts->IsAccepted(tag->GetEventTag(i))) localList->Enter(i);
214           }
215
216 //        const TClonesArray *tagList = tag->GetEventTags();
217 //        for(Int_t i = 0; i < iEvents; i++) {
218 //          evTag = (AliEventTag *) tagList->At(i);
219 //          guid = evTag->GetGUID(); 
220 //          turl = evTag->GetTURL(); 
221 //          path = evTag->GetPath();
222 //          localList->SetTreeName(aliceFile.Data());
223 //          if(turl!="") localList->SetFileName(turl.Data());
224 //          else localList->SetFileName(path.Data());
225             
226 //          if(evTagCuts->IsAccepted(evTag)) localList->Enter(i);
227 //        }//event loop
228           iAccepted += localList->GetN();
229           if(turl != "")      esdChain->AddFile(turl);
230           else if(path != "") esdChain->AddFile(path);
231           fGlobalList->Add(localList);
232         }//detector tag cuts
233       }//lhc tag cuts
234     }//run tags cut
235     tag->Clear();
236   }//tag file loop
237   AliInfo(Form("Accepted events: %d", iAccepted));
238   esdChain->ls();
239   esdChain->SetEntryList(fGlobalList,"ne");
240   delete tag;
241   delete localList;
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   TString aliceFile;
257   if(fAnalysisType == "ESD") aliceFile = "esdTree";
258   else if(fAnalysisType == "AOD") aliceFile = "aodTree";
259   else AliFatal("Only ESD and AOD type is implemented!!!");
260
261
262   //ESD file chain
263   TChain *esdChain = new TChain(aliceFile.Data());
264   //global entry list
265   fGlobalList = new TEntryList();
266   
267   //Defining tag objects         
268   AliRunTag   *tag   = new AliRunTag;    
269   //  AliEventTag *evTag = 0x0;
270   fChain->SetBranchAddress("AliTAG",&tag);       
271   
272   TString guid;          
273   TString turl;          
274   TString path;          
275   
276   TTreeFormula *fRunFormula = new TTreeFormula("fRun",fRunCut,fChain);   
277   TTreeFormula *fLHCFormula = new TTreeFormula("fLHC",fLHCCut,fChain);   
278   TTreeFormula *fDetectorFormula = new TTreeFormula("fDetector",fDetectorCut,fChain);
279   TTreeFormula *fEventFormula = new TTreeFormula("fEvent",fEventCut,fChain);
280   
281   TEntryList* localList = new TEntryList();
282
283   Int_t current = -1; 
284   Int_t iAccepted = 0;   
285   
286   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
287     fChain->GetEntry(iTagFiles);         
288     if (current != fChain->GetTreeNumber()) {    
289       fRunFormula->UpdateFormulaLeaves();        
290       fLHCFormula->UpdateFormulaLeaves();        
291       fDetectorFormula->UpdateFormulaLeaves();   
292       fEventFormula->UpdateFormulaLeaves();      
293       current = fChain->GetTreeNumber();         
294     }    
295     
296     if(fRunFormula->EvalInstance(iTagFiles) == 1) {      
297       if(fLHCFormula->EvalInstance(iTagFiles) == 1) {    
298         if(fDetectorFormula->EvalInstance(iTagFiles) == 1) {
299           localList->Reset();    
300           //      Int_t iEvents = fEventFormula->GetNdata();     
301           // *** FIXME ***
302
303 //        const TClonesArray *tagList = tag->GetEventTags();     
304 //        for(Int_t i = 0; i < iEvents; i++) {   
305 //          evTag = (AliEventTag *) tagList->At(i);      
306 //          guid = evTag->GetGUID();     
307 //          turl = evTag->GetTURL();     
308 //          path = evTag->GetPath();     
309 //          localList->SetTreeName(aliceFile.Data());
310 //          localList->SetFileName(turl.Data());
311 //          if(fEventFormula->EvalInstance(i) == 1) localList->Enter(i);
312 //        }//event loop          
313
314           if(path != "")      esdChain->AddFile(path);   
315           else if(turl != "") esdChain->AddFile(turl);   
316           fGlobalList->Add(localList);
317           iAccepted += localList->GetN();
318         }//detector tag cuts
319       }//lhc tag cuts
320     }//run tag cut       
321     tag->Clear();
322   }//tag file loop       
323   AliInfo(Form("Accepted events: %d", iAccepted));       
324   esdChain->SetEntryList(fGlobalList,"ne");      
325
326   delete tag;
327   delete localList;
328   return esdChain;       
329 }
330
331 //___________________________________________________________________________
332 Bool_t 
333 AliTagAnalysis::CreateXMLCollection(const char* name, 
334                                     AliRunTagCuts *runTagCuts, 
335                                     AliLHCTagCuts *lhcTagCuts, 
336                                     AliDetectorTagCuts *detTagCuts, 
337                                     AliEventTagCuts *evTagCuts) 
338 {
339   /// Queries the tag chain using the defined run, lhc, detector and event tag objects
340   /// and create a XML collection named "name.xml"
341   /// if any of the runTagCuts, lhcTagCuts, detTagCuts or evTagCuts is NULL
342   /// check on that object will be skipped.
343   
344   AliInfo(Form("Creating the collection........"));
345   
346   if (!fChain) 
347   {
348     AliError("fChain is NULL. Cannot make a collection from that !");
349     return kFALSE;
350   }
351   
352   AliXMLCollection collection;
353   collection.SetCollectionName(name);
354   collection.WriteHeader();
355   
356   TString guid;
357   TString turl;
358   TString lfn;
359   
360   TEntryList localList;
361   Int_t iAccepted = 0;
362     
363   Int_t iRejectedRun = 0;
364   Int_t iRejectedLHC = 0;
365   Int_t iRejectedDet = 0;
366   Int_t iRejectedEvt = 0;
367   
368   Int_t iTotalEvents = 0;
369   
370   Int_t iAcceptedEvtInFile = 0;
371   Int_t iRejectedEvtInFile = 0;
372   
373   //Defining tag objects
374   AliRunTag* tag = new AliRunTag;
375   fChain->SetBranchAddress("AliTAG",&tag);
376
377   Int_t iTagFiles = 0;
378   
379   //  AliEventTag *evTag = 0x0;
380   AliFileTag  *flTag = 0x0;
381
382   //  for(Int_t iTagFiles = 0; iTagFiles < fChain->GetListOfFiles()->GetEntries(); ++iTagFiles) 
383   for(Int_t iRunTags = 0; iRunTags < fChain->GetEntries(); ++iRunTags) 
384   {
385     fChain->GetEntry(iRunTags);
386     //Event list
387     iTotalEvents += tag->GetNEvents();
388     localList.Reset();
389     
390     evTagCuts->InitializeTriggerClasses(tag->GetActiveTriggerClasses());
391     
392     if ( !runTagCuts || ( runTagCuts && runTagCuts->IsAccepted(tag) ) ) 
393       {
394         if ( !lhcTagCuts || ( lhcTagCuts && lhcTagCuts->IsAccepted(tag->GetLHCTag())) ) 
395           {
396             if ( !detTagCuts || ( detTagCuts && detTagCuts->IsAccepted(tag->GetDetectorTags())) )
397               {
398                 for (int iChunk = 0; iChunk < tag->GetNFiles(); iChunk++, iTagFiles++) 
399                   {
400                     iRejectedEvtInFile = 0;
401                     iAcceptedEvtInFile = 0;
402
403                     flTag = tag->GetFileTag(iChunk);
404                     guid = flTag->GetGUID();
405                     turl = flTag->GetTURL();
406                     lfn = turl(8,turl.Length());
407
408                     for (int i = 0; i<flTag->GetNEvents(); i++) 
409                       {
410                         //                      evTag = flTag->GetEventTag(i);
411                 
412                         if( !evTagCuts || ( evTagCuts && evTagCuts->IsAccepted(flTag->GetEventTag(i))) )
413                           {
414                             localList.Enter(i);
415                             iAcceptedEvtInFile++;
416                           }
417                         else 
418                           {
419                             ++iRejectedEvt;
420                             ++iRejectedEvtInFile;
421                           }
422                       }
423                 // *** FIXME ***
424 //              Int_t i(0);
425
426 //              TIter next(tag->GetEventTags());
427 //              AliEventTag* evTag(0x0);
428 //              iRejectedEvtInFile = 0;
429 //              iAcceptedEvtInFile = 0;
430 //              while ( ( evTag = static_cast<AliEventTag*>(next()) ) )
431 //                {
432 //                  guid = evTag->GetGUID(); 
433 //                  turl = evTag->GetTURL(); 
434 //                  lfn = turl(8,turl.Length());
435 //                  if( !evTagCuts || ( evTagCuts && evTagCuts->IsAccepted(evTag)) )
436 //                    {
437 //                      localList.Enter(i);
438 //                      iAcceptedEvtInFile++;
439 //                    }
440 //                  else 
441 //                    {
442 //                      ++iRejectedEvt;
443 //                      ++iRejectedEvtInFile;
444 //                    }
445 //                  ++i;
446 //                }//event loop
447                     iAccepted += localList.GetN();
448                     collection.WriteBody(iTagFiles+1,guid,lfn,turl,&localList,iAcceptedEvtInFile,iRejectedEvtInFile);
449                   } // chunk loop
450               }//detector tag cuts
451             else {
452               iRejectedDet += tag->GetNEvents();
453             }
454           }//lhc tag cuts 
455         else {
456           iRejectedLHC += tag->GetNEvents();
457         }
458       }//run tag cuts
459     else {
460       iRejectedRun += tag->GetNEvents();
461     }
462     tag->Clear();
463   } //tag file loop
464   
465   collection.WriteSummary(iTotalEvents, iAccepted, iRejectedRun, iRejectedLHC, iRejectedDet, iRejectedEvt);
466   collection.Export();
467   
468   return kTRUE;
469 }
470
471 //___________________________________________________________________________
472 Bool_t AliTagAnalysis::CreateXMLCollection(const char* name, 
473                                            const char *fRunCut, 
474                                            const char *fLHCCut, 
475                                            const char *fDetectorCut, 
476                                            const char *fEventCut) {
477   //Queries the tag chain using the defined 
478   //event tag cuts from the AliEventTagCuts object
479   //and returns a XML collection
480   AliInfo(Form("Creating the collection........"));
481
482
483   AliXMLCollection *collection = new AliXMLCollection();
484   collection->SetCollectionName(name);
485   collection->WriteHeader();
486
487   TString guid;
488   TString turl;
489   TString lfn;
490   TEntryList* localList = new TEntryList();
491   
492   Int_t iAccepted = 0;
493
494   Int_t iRejectedRun = 0;
495   Int_t iRejectedLHC = 0;
496   Int_t iRejectedDet = 0;
497   Int_t iRejectedEvt = 0;
498
499   Int_t iTotalEvents = 0;
500
501   Int_t iAcceptedEvtInFile = 0;
502   Int_t iRejectedEvtInFile = 0;
503
504   //Defining tag objects
505   AliRunTag *tag     = new AliRunTag;
506   //  AliEventTag *evTag = 0x0;
507   fChain->SetBranchAddress("AliTAG",&tag);
508
509   TTreeFormula *fRunFormula = new TTreeFormula("fRun",fRunCut,fChain);
510   TTreeFormula *fLHCFormula = new TTreeFormula("fLHC",fLHCCut,fChain);   
511   TTreeFormula *fDetectorFormula = new TTreeFormula("fDetector",fDetectorCut,fChain);
512   TTreeFormula *fEventFormula = new TTreeFormula("fEvent",fEventCut,fChain);
513   
514   Int_t current = -1;
515
516   for(Int_t iTagFiles = 0; iTagFiles < fChain->GetEntries(); iTagFiles++) {
517
518     fChain->GetEntry(iTagFiles);
519     if (current != fChain->GetTreeNumber()) {
520       fRunFormula->UpdateFormulaLeaves();
521       fLHCFormula->UpdateFormulaLeaves();
522       fDetectorFormula->UpdateFormulaLeaves();
523       fEventFormula->UpdateFormulaLeaves();
524       current = fChain->GetTreeNumber();
525      }
526  
527    //Event list
528     iTotalEvents += tag->GetNEvents();
529     localList->Reset();
530     if(fRunFormula->EvalInstance(iTagFiles) == 1) {
531       if(fLHCFormula->EvalInstance(iTagFiles) == 1) {    
532         if(fDetectorFormula->EvalInstance(iTagFiles) == 1) {     
533           //      Int_t iEvents = fEventFormula->GetNdata();
534           // *** FIXME ***
535
536
537 //        const TClonesArray *tagList = tag->GetEventTags();
538 //        iRejectedEvtInFile = 0;
539 //        iAcceptedEvtInFile = 0;
540 //        for(Int_t i = 0; i < iEvents; i++) {
541 //          evTag = (AliEventTag *) tagList->At(i);
542 //          guid = evTag->GetGUID(); 
543 //          turl = evTag->GetTURL(); 
544 //          lfn = turl(8,turl.Length());
545 //          if(fEventFormula->EvalInstance(i) == 1) {
546 //            localList->Enter(i);
547 //            iAcceptedEvtInFile++;
548 //          }
549 //          else {
550 //            iRejectedEvt++;
551 //            iRejectedEvtInFile++;
552 //          }
553 //        }//event loop
554
555           collection->WriteBody(iTagFiles+1,guid,lfn,turl,localList,iAcceptedEvtInFile, iRejectedEvtInFile);
556           iAccepted += localList->GetN();
557         }//detector tag cuts
558         else {
559           iRejectedDet += tag->GetNEvents();
560         }
561       }//lhc tag cuts 
562       else {
563         iRejectedLHC += tag->GetNEvents();
564       }
565     }//run tag cuts
566     else {
567       iRejectedRun += tag->GetNEvents();
568     }
569   }//tag file loop
570   collection->WriteSummary(iTotalEvents, iAccepted, iRejectedRun, iRejectedLHC, iRejectedDet, iRejectedEvt);
571   collection->Export();
572   
573   delete tag;
574   return kTRUE;
575 }
576
577 //___________________________________________________________________________
578 TChain *AliTagAnalysis::GetInputChain(const char* system, const char *wn) {
579   //returns the chain+event list - used in batch sessions
580   // this function will be removed once the new root 
581   // improvements are committed
582   TString fsystem = system;
583   Int_t iAccepted = 0;
584
585   TChain *fAnalysisChain = 0;
586   if(fAnalysisType == "ESD") fAnalysisChain = new TChain("esdTree");
587   else if(fAnalysisType == "AOD") fAnalysisChain = new TChain("aodTree");
588   else AliFatal("Only ESD and AOD type is implemented!!!");
589   
590   //Event list
591   TEventList *fEventList = new TEventList();
592   AliXMLCollection *collection = AliXMLCollection::Open(wn);
593
594   collection->Reset();
595   while (collection->Next()) {
596     AliInfo(Form("Adding: %s",collection->GetTURL("")));
597     fAnalysisChain->Add(collection->GetTURL(""));
598     TEntryList *list = (TEntryList *)collection->GetEventList("");
599     for(Int_t i = 0; i < list->GetN(); i++) fEventList->Enter(iAccepted+list->GetEntry(i));
600
601     if(fsystem == "pp") iAccepted += 100;
602     else if(fsystem == "PbPb") iAccepted += 1;
603   }
604
605   fAnalysisChain->SetEventList(fEventList);
606   
607   AliInfo(Form("Number of selected events: %d",fEventList->GetN()));
608
609   return fAnalysisChain;
610 }
611
612 //___________________________________________________________________________
613 TChain*
614 AliTagAnalysis::CreateChainFromCollection(const char* collectionname, const char* treename)
615 {
616   /// Build a TChain (with its TEntryList object attached) from an XML collection.
617   /// Returned chain must be deleted by the client.
618
619   TString streename(treename);
620   if ( streename != "esdTree" && streename != "aodTree" )
621   {
622     AliErrorClass("Only esdTree and aodTree implemented so far...");
623     return 0x0;
624   }
625   
626   TChain* chain = new TChain(streename.Data());
627
628   // create the event list for the chain. Will be attached to the chain
629   // which thus becomes the owner of it.
630   TEntryList* elist = new TEntryList; 
631   
632   AliXMLCollection* collection = AliXMLCollection::Open(collectionname);
633
634   // Tag selection summary per file
635   TMap* tagCutSummary = new TMap();
636   tagCutSummary->SetName("TagCutSumm");
637
638   Int_t iAccepted = 0;
639   
640   collection->Reset();
641   
642   while (collection->Next()) 
643   {
644     AliDebugClass(1,Form("Adding: %s",collection->GetTURL("")));
645     chain->Add(collection->GetTURL(""));
646     TEntryList *list = collection->GetEventList("");
647     list->SetTreeName(streename.Data());
648     list->SetFileName(collection->GetTURL(""));
649     elist->Add(list);
650     iAccepted += list->GetN();
651     if (collection->GetCutSumm())
652     {
653       tagCutSummary->Add(new TObjString(collection->GetTURL("")), new TObjString(collection->GetCutSumm()));
654     }
655   }
656
657   chain->SetEntryList(elist,"ne"); // ne => do not expand tree name and/or file names
658   
659   AliDebugClass(1,Form("Number of selected events: %d",iAccepted));
660
661   TList *aUserInfo = chain->GetUserInfo();
662   aUserInfo->Add(tagCutSummary);
663
664   Int_t iAccEv;
665   Int_t iTotalEvents;
666   Int_t iRejRun;
667   Int_t iRejLHC;
668   Int_t iRejDet;
669   Int_t iRejEvt;
670
671   collection->GetCollectionSummary(&iTotalEvents, &iAccEv, &iRejRun, &iRejLHC, &iRejDet, &iRejEvt);
672  
673   char nstr[2000];
674
675   sprintf(nstr, "TotalEvents=%i", iTotalEvents);
676   TObjString *iTotStr = new TObjString(nstr);
677   aUserInfo->Add(iTotStr);
678
679   sprintf(nstr, "AcceptedEvents=%i", iAccepted);
680   TObjString *iAccStr = new TObjString(nstr);
681   aUserInfo->Add(iAccStr);
682
683   sprintf(nstr, "RejectedRun=%i", iRejRun);
684   TObjString *iRejRunStr = new TObjString(nstr);
685   aUserInfo->Add(iRejRunStr);
686
687   sprintf(nstr, "RejectedLHC=%i", iRejLHC);
688   TObjString *iRejLHCStr = new TObjString(nstr);
689   aUserInfo->Add(iRejLHCStr);
690
691   sprintf(nstr, "RejectedDet=%i", iRejDet);
692   TObjString *iRejDetStr = new TObjString(nstr);
693   aUserInfo->Add(iRejDetStr);
694
695   sprintf(nstr, "RejectedEvt=%i", iRejEvt);
696   TObjString *iRejEvtStr = new TObjString(nstr);
697   aUserInfo->Add(iRejEvtStr);
698
699   return chain;
700 }