430fb6dcaa32600b7b487df91191b2dcbfe8e7d0
[u/mrichter/AliRoot.git] / STEER / AOD / AliAODHandler.cxx
1
2 /**************************************************************************
3  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /* $Id$ */
18
19 //-------------------------------------------------------------------------
20 //     Implementation of the Virtual Event Handler Interface for AOD
21 //     Author: Andreas Morsch, CERN
22 //-------------------------------------------------------------------------
23
24
25 #include <TTree.h>
26 #include <TFile.h>
27 #include <TString.h>
28 #include <TList.h>
29 #include <TROOT.h>
30
31 #include "AliLog.h"
32 #include "AliAODHandler.h"
33 #include "AliAODEvent.h"
34 #include "AliAODExtension.h"
35 #include "AliAODTracklets.h"
36 #include "AliStack.h"
37 #include "AliAODMCParticle.h"
38 #include "AliAODMCHeader.h"
39 #include "AliMCEventHandler.h"
40 #include "AliMCEvent.h"
41 #include "AliGenEventHeader.h"
42 #include "AliGenHijingEventHeader.h"
43 #include "AliGenDPMjetEventHeader.h"
44 #include "AliGenPythiaEventHeader.h"
45 #include "AliGenCocktailEventHeader.h"
46 #include "AliCodeTimer.h"
47 #include "AliAODBranchReplicator.h"
48 #include "Riostream.h"
49
50 ClassImp(AliAODHandler)
51
52 //______________________________________________________________________________
53 AliAODHandler::AliAODHandler() :
54     AliVEventHandler(),
55     fIsStandard(kTRUE),
56     fFillAOD(kTRUE),
57     fFillAODRun(kTRUE),
58     fFillExtension(kTRUE),
59     fNeedsHeaderReplication(kFALSE),
60     fNeedsTracksBranchReplication(kFALSE),
61     fNeedsVerticesBranchReplication(kFALSE),
62     fNeedsV0sBranchReplication(kFALSE),
63     fNeedsCascadesBranchReplication(kFALSE),
64     fNeedsTrackletsBranchReplication(kFALSE),
65     fNeedsPMDClustersBranchReplication(kFALSE),
66     fNeedsJetsBranchReplication(kFALSE),
67     fNeedsFMDClustersBranchReplication(kFALSE),
68     fNeedsCaloClustersBranchReplication(kFALSE),
69     fNeedsMCParticlesBranchReplication(kFALSE),
70     fNeedsDimuonsBranchReplication(kFALSE),
71     fAODIsReplicated(kFALSE),
72     fAODEvent(NULL),
73     fMCEventH(NULL),
74     fTreeA(NULL),
75     fFileA(NULL),
76     fFileName(""),
77     fExtensions(NULL),
78     fFilters(NULL)
79 {
80   // default constructor
81 }
82
83 //______________________________________________________________________________
84 AliAODHandler::AliAODHandler(const char* name, const char* title):
85     AliVEventHandler(name, title),
86     fIsStandard(kTRUE),
87     fFillAOD(kTRUE),
88     fFillAODRun(kTRUE),
89     fFillExtension(kTRUE),
90     fNeedsHeaderReplication(kFALSE),
91     fNeedsTracksBranchReplication(kFALSE),
92     fNeedsVerticesBranchReplication(kFALSE),
93     fNeedsV0sBranchReplication(kFALSE),
94     fNeedsCascadesBranchReplication(kFALSE),
95     fNeedsTrackletsBranchReplication(kFALSE),
96     fNeedsPMDClustersBranchReplication(kFALSE),
97     fNeedsJetsBranchReplication(kFALSE),
98     fNeedsFMDClustersBranchReplication(kFALSE),
99     fNeedsCaloClustersBranchReplication(kFALSE),
100     fNeedsMCParticlesBranchReplication(kFALSE),
101     fNeedsDimuonsBranchReplication(kFALSE),
102     fAODIsReplicated(kFALSE),
103     fAODEvent(NULL),
104     fMCEventH(NULL),
105     fTreeA(NULL),
106     fFileA(NULL),
107     fFileName(""),
108     fExtensions(NULL),
109     fFilters(NULL)
110 {
111 // Normal constructor.
112 }
113
114 //______________________________________________________________________________
115 AliAODHandler::~AliAODHandler() 
116 {
117  // Destructor.
118   
119   delete fAODEvent;
120
121   if (fFileA)
122   {
123     // is already handled in TerminateIO
124     fFileA->Close();
125     delete fFileA;
126     fTreeA = 0;
127   }
128   delete fTreeA;
129   delete fExtensions;
130   delete fFilters;
131 }
132
133 //______________________________________________________________________________
134 Bool_t AliAODHandler::Init(Option_t* opt)
135 {
136   // Initialize IO
137   //
138   // Create the AODevent object
139     
140   Bool_t createStdAOD = fIsStandard || fFillAOD;
141   if(!fAODEvent && createStdAOD){
142     fAODEvent = new AliAODEvent();
143     if (fIsStandard) 
144       fAODEvent->CreateStdContent();
145   }
146   //
147   // File opening according to execution mode
148   TString option(opt);
149   option.ToLower();
150   if (createStdAOD) {
151     TDirectory *owd = gDirectory;
152     if (option.Contains("proof")) {
153       // proof
154       // Merging via files. Need to access analysis manager via interpreter.
155       gROOT->ProcessLine(Form("AliAnalysisDataContainer *c_common_out = AliAnalysisManager::GetAnalysisManager()->GetCommonOutputContainer();"));
156       gROOT->ProcessLine(Form("AliAnalysisManager::GetAnalysisManager()->OpenProofFile(c_common_out, \"RECREATE\");"));
157       fFileA = gFile;
158     } else {
159       // local and grid
160       fFileA = new TFile(fFileName.Data(), "RECREATE");
161     }
162     CreateTree(1);
163     owd->cd();
164   }  
165   if (fExtensions) {
166      TIter next(fExtensions);
167      AliAODExtension *ext;
168      while ((ext=(AliAODExtension*)next())) ext->Init(option);
169   }   
170   if (fFilters) {
171      TIter nextf(fFilters);
172      AliAODExtension *filteredAOD;
173      while ((filteredAOD=(AliAODExtension*)nextf())) {
174         filteredAOD->SetEvent(fAODEvent);
175         filteredAOD->Init(option);
176      }
177   }   
178   
179   return kTRUE;
180 }
181
182 //______________________________________________________________________________
183 void AliAODHandler::Print(Option_t* opt) const
184 {
185   // Print info about this object
186
187   cout << opt << Form("IsStandard %d filename=%s",fIsStandard,fFileName.Data()) << endl;
188   
189   if ( fExtensions ) 
190   {
191     cout << opt << fExtensions->GetEntries() << " extensions :" << endl;
192     PrintExtensions(*fExtensions);    
193   }
194   if ( fFilters ) 
195   {
196     cout << opt << fFilters->GetEntries() << " filters :" << endl;
197     PrintExtensions(*fFilters);      
198   }
199 }
200
201 //______________________________________________________________________________
202 void AliAODHandler::PrintExtensions(const TObjArray& array) const
203 {
204   // Show the list of aod extensions
205   TIter next(&array);
206   AliAODExtension* ext(0x0);
207   while ( ( ext = static_cast<AliAODExtension*>(next()) ) )
208   {
209     ext->Print("   ");
210   }
211 }
212
213 //______________________________________________________________________________
214 void AliAODHandler::StoreMCParticles(){
215
216   // 
217   // Remap the labels from ESD stack and store
218   // the AODMCParticles, makes only sense if we have
219   // the mcparticles branch
220   // has to be done here since we cannot know in advance 
221   // which particles are needed (e.g. by the tracks etc.)
222   //
223   // Particles have been selected by AliMCEventhanlder->SelectParticle()
224   // To use the MCEventhandler here we need to set it from the outside
225   // can vanish when Handler go to the ANALYSISalice library
226   //
227   // The Branch booking for mcParticles and mcHeader has to happen 
228   // in an external task for now since the AODHandler does not have access
229   // the AnalysisManager. For the same reason the pointer t o the MCEventH
230   // has to passed to the AOD Handler by this task 
231   // (doing this in the steering macro would not work on PROOF)
232
233   if (!fAODEvent) return;
234   TClonesArray *mcarray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName()); 
235   if(!mcarray)return;
236
237   AliAODMCHeader *mcHeader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName()); 
238   if(!mcHeader)return;
239
240   // Get the MC Infos.. Handler needs to be set before 
241   // while adding the branch
242   // This needs to be done, not to depend on the AnalysisManager
243
244   if(!fMCEventH)return;
245   if(!fMCEventH->MCEvent())return;
246   AliStack *pStack = fMCEventH->MCEvent()->Stack();
247   if(!pStack)return;
248
249   fMCEventH->CreateLabelMap();
250
251   //
252   // Get the Event Header 
253   // 
254
255   AliHeader* header = fMCEventH->MCEvent()->Header();
256    // get the MC vertex
257   AliGenEventHeader* genHeader = 0;
258   if (header) genHeader = header->GenEventHeader();
259   if (genHeader) {
260       TArrayF vtxMC(3);
261       genHeader->PrimaryVertex(vtxMC);
262       mcHeader->SetVertex(vtxMC[0],vtxMC[1],vtxMC[2]);
263
264       // we search the MCEventHeaders first 
265       // Two cases, cocktail or not...
266       AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(genHeader);
267       if(genCocktailHeader){
268           // we have a coktail header
269           mcHeader->AddGeneratorName(genHeader->GetName());
270           // Loop from the back so that the first one sets the process type
271           TList* headerList = genCocktailHeader->GetHeaders();
272           for(int i = headerList->GetEntries()-1;i>=0;--i){
273               AliGenEventHeader *headerEntry = dynamic_cast<AliGenEventHeader*>(headerList->At(i));
274          if (!headerEntry) {
275            AliFatal("AliGenEventHeader entry not found in the header list");
276          } else {   
277            SetMCHeaderInfo(mcHeader,headerEntry);
278          }  
279           }
280       }
281       else{
282           // No Cocktail just take the first one
283           SetMCHeaderInfo(mcHeader,genHeader);
284       }
285   }
286   
287
288
289
290
291   // Store the AliAODParticlesMC
292   AliMCEvent* mcEvent = fMCEventH->MCEvent();
293   
294   Int_t np    = mcEvent->GetNumberOfTracks();
295   Int_t nprim = mcEvent->GetNumberOfPrimaries();
296
297
298   Int_t j = 0;
299   TClonesArray& l = *mcarray;
300
301   for(int i = 0; i < np; ++i){
302       if(fMCEventH->IsParticleSelected(i)){
303           Int_t flag = 0;
304           AliMCParticle* mcpart =  (AliMCParticle*) mcEvent->GetTrack(i);
305           if(i<nprim)flag |= AliAODMCParticle::kPrimary;
306           
307           if(mcEvent->IsPhysicalPrimary(i))flag |= AliAODMCParticle::kPhysicalPrim;
308           
309           if(fMCEventH->GetNewLabel(i)!=j){
310               AliError(Form("MISMATCH New label %d j: %d",fMCEventH->GetNewLabel(i),j));
311           }
312
313           AliAODMCParticle mcpartTmp(mcpart,i,flag);
314           
315           mcpartTmp.SetStatus(mcpart->Particle()->GetStatusCode());
316           // 
317           Int_t d0 =  mcpartTmp.GetDaughter(0);
318           Int_t d1 =  mcpartTmp.GetDaughter(1);
319           Int_t m =   mcpartTmp.GetMother();
320           
321           // other than for the track labels, negative values mean
322           // no daughter/mother so preserve it
323           
324           if(d0<0 && d1<0){
325               // no first daughter -> no second daughter
326               // nothing to be done
327               // second condition not needed just for sanity check at the end
328               mcpartTmp.SetDaughter(0,d0);
329               mcpartTmp.SetDaughter(1,d1);
330           } else if(d1 < 0 && d0 >= 0) {
331               // Only one daughter
332               // second condition not needed just for sanity check at the end
333               if(fMCEventH->IsParticleSelected(d0)){
334                   mcpartTmp.SetDaughter(0,fMCEventH->GetNewLabel(d0));
335               } else {
336                   mcpartTmp.SetDaughter(0,-1);
337               }
338               mcpartTmp.SetDaughter(1,d1);
339           }
340           else if (d0 > 0 && d1 > 0 ){
341               // we have two or more daughters loop on the stack to see if they are
342               // selected
343               Int_t d0Tmp = -1;
344               Int_t d1Tmp = -1;
345               for(int id = d0; id<=d1;++id){
346                   if(fMCEventH->IsParticleSelected(id)){
347                       if(d0Tmp==-1){
348                           // first time
349                           d0Tmp = fMCEventH->GetNewLabel(id);
350                           d1Tmp = d0Tmp; // this is to have the same schema as on the stack i.e. with one daugther d0 and d1 are the same 
351                       }
352                       else d1Tmp = fMCEventH->GetNewLabel(id);
353                   }
354               }
355               mcpartTmp.SetDaughter(0,d0Tmp);
356               mcpartTmp.SetDaughter(1,d1Tmp);
357           } else {
358               AliError(Form("Unxpected indices %d %d",d0,d1));
359           }
360           
361           if(m<0){
362               mcpartTmp.SetMother(m);
363           } else {
364               if(fMCEventH->IsParticleSelected(m))mcpartTmp.SetMother(fMCEventH->GetNewLabel(m));
365               else AliError(Form("PROBLEM Mother not selected %d \n", m));
366           }
367
368           new (l[j++]) AliAODMCParticle(mcpartTmp);
369           
370       }
371   }
372   AliInfo(Form("AliAODHandler::StoreMCParticles: Selected %d (Primaries %d / total %d) after validation \n",
373                j,nprim,np));
374   
375   // Set the labels in the AOD output...
376   // Remapping
377
378   // AODTracks
379   TClonesArray* tracks = fAODEvent->GetTracks();
380   if(tracks){
381     for(int it = 0; it < fAODEvent->GetNTracks();++it){
382       AliAODTrack *track = fAODEvent->GetTrack(it);
383       
384       Int_t sign = 1;
385       Int_t label = track->GetLabel();
386       if(label<0){ // preserve the sign for later usage
387         label *= -1;
388         sign  = -1;
389       }
390
391       if (label >= AliMCEvent::BgLabelOffset()) label =  mcEvent->BgLabelToIndex(label);
392       if(label > np || track->GetLabel() == 0){
393         AliWarning(Form("Wrong ESD track label %5d (%5d)",track->GetLabel(), label));
394       }
395       if(fMCEventH->GetNewLabel(label) == 0){
396         AliWarning(Form("New label not found for %5d (%5d)",track->GetLabel(), label));
397       }
398       track->SetLabel(sign*fMCEventH->GetNewLabel(label));
399     }
400   }
401   
402   // AOD calo cluster
403   TClonesArray *clusters = fAODEvent->GetCaloClusters();
404   if(clusters){
405     for (Int_t iClust = 0;iClust < fAODEvent->GetNumberOfCaloClusters(); ++iClust) {
406       AliAODCaloCluster * cluster = fAODEvent->GetCaloCluster(iClust);
407       UInt_t nLabel    = cluster->GetNLabels();
408       // Ugly but do not want to fragment memory by creating 
409       // new Int_t (nLabel)
410       Int_t* labels    = const_cast<Int_t*>(cluster->GetLabels());
411       if (labels){
412         for(UInt_t i = 0;i < nLabel;++i){
413           labels[i] = fMCEventH->GetNewLabel(cluster->GetLabelAt(i));
414         }
415       }
416       //      cluster->SetLabels(labels,nLabel);
417     }// iClust
418   }// clusters
419
420   // AOD tracklets
421   AliAODTracklets *tracklets = fAODEvent->GetTracklets();
422   if(tracklets){
423     for(int it = 0;it < tracklets->GetNumberOfTracklets();++it){
424       int label0 = tracklets->GetLabel(it,0);
425       int label1 = tracklets->GetLabel(it,1);
426       if(label0>=0)label0 = fMCEventH->GetNewLabel(label0);      
427       if(label1>=0)label1 = fMCEventH->GetNewLabel(label1);
428       tracklets->SetLabel(it,0,label0);
429       tracklets->SetLabel(it,1,label1);
430     }
431   }
432
433 }
434
435 //______________________________________________________________________________
436 Bool_t AliAODHandler::FinishEvent()
437 {
438   // Fill data structures
439   if(fFillAOD && fFillAODRun && fAODEvent){
440       fAODEvent->MakeEntriesReferencable();
441       fTreeA->BranchRef();
442       FillTree();
443   }
444
445   if ((fFillAOD && fFillAODRun) || fFillExtension) {
446     if (fExtensions && fFillExtension) {
447       // fFillExtension can be set by the ESD filter or by a delta filter in case of AOD inputs
448       TIter next(fExtensions);
449       AliAODExtension *ext;
450       while ((ext=(AliAODExtension*)next())) ext->FinishEvent();
451     }
452     if (fFilters && fFillAOD && fFillAODRun) {
453       TIter nextf(fFilters);
454       AliAODExtension *ext;
455       while ((ext=(AliAODExtension*)nextf())) {
456               ext->FinishEvent();
457       }  
458     }       
459   }  
460   
461   if (fIsStandard && fAODEvent) 
462   {
463     fAODEvent->ResetStd();    
464   }
465   
466   if (fAODEvent) 
467   {
468     TClonesArray *mcarray = static_cast<TClonesArray*>(fAODEvent->FindListObject(AliAODMCParticle::StdBranchName()));
469     if(mcarray) mcarray->Delete();
470     
471     AliAODMCHeader *mcHeader = static_cast<AliAODMCHeader*>(fAODEvent->FindListObject(AliAODMCHeader::StdBranchName()));
472     if(mcHeader) mcHeader->Reset();
473   }
474   
475   // Reset AOD replication flag
476   fAODIsReplicated = kFALSE;
477   return kTRUE;
478 }
479
480 //______________________________________________________________________________
481 Bool_t AliAODHandler::Terminate()
482 {
483   // Terminate 
484   AddAODtoTreeUserInfo();
485   
486   TIter nextF(fFilters);
487   AliAODExtension *ext;
488   while ((ext=static_cast<AliAODExtension*>(nextF())))
489   {
490     ext->AddAODtoTreeUserInfo();
491   }
492
493   TIter nextE(fExtensions);
494   while ((ext=static_cast<AliAODExtension*>(nextE())))
495   {
496     ext->AddAODtoTreeUserInfo();
497   }
498   
499   return kTRUE;
500 }
501
502 //______________________________________________________________________________
503 Bool_t AliAODHandler::TerminateIO()
504 {
505   // Terminate IO
506   if (fFileA) {
507     fFileA->Write();
508     fFileA->Close();
509     delete fFileA;
510     fFileA = 0;
511     // When closing the file, the tree is also deleted.
512     fTreeA = 0;
513   }
514   
515   TIter nextF(fFilters);
516   AliAODExtension *ext;
517   while ((ext=static_cast<AliAODExtension*>(nextF())))
518   {
519     ext->TerminateIO();
520   }  
521
522   TIter nextE(fExtensions);
523   while ((ext=static_cast<AliAODExtension*>(nextE())))
524   {
525     ext->TerminateIO();
526   }  
527   
528   return kTRUE;
529 }
530
531 //______________________________________________________________________________
532 void AliAODHandler::CreateTree(Int_t flag)
533 {
534     // Creates the AOD Tree
535     fTreeA = new TTree("aodTree", "AliAOD tree");
536     fTreeA->Branch(fAODEvent->GetList());
537     if (flag == 0) fTreeA->SetDirectory(0);
538 }
539
540 //______________________________________________________________________________
541 void AliAODHandler::FillTree()
542 {
543  
544     // Fill the AOD Tree
545     fTreeA->Fill();
546 }
547
548 //______________________________________________________________________________
549 void AliAODHandler::AddAODtoTreeUserInfo()
550 {
551   // Add aod event to tree user info
552   if (fTreeA) fTreeA->GetUserInfo()->Add(fAODEvent);
553   // Now the tree owns our fAODEvent...
554   fAODEvent = 0;
555 }
556
557 //______________________________________________________________________________
558 void AliAODHandler::AddBranch(const char* cname, void* addobj, const char* filename)
559 {
560   // Add a new branch to the aod. Added optional filename parameter if the
561   // branch should be written to a separate file.
562   
563   if (strlen(filename)) 
564   {
565     AliAODExtension *ext = AddExtension(filename);
566     ext->AddBranch(cname, addobj);
567     return;
568   } 
569   
570   // Add branch to all filters
571   // Add branch to all filters
572   if (fFilters) {
573     TIter next(fFilters);
574     AliAODExtension *ext;
575     while ((ext=(AliAODExtension*)next())) ext->AddBranch(cname, addobj);
576   }
577   
578   TDirectory *owd = gDirectory;
579   if (fFileA) 
580   {
581     fFileA->cd();
582   }
583
584   char** apointer = (char**) addobj;
585   TObject* obj = (TObject*) *apointer;
586   
587   fAODEvent->AddObject(obj);
588   
589   const Int_t kSplitlevel = 99; // default value in TTree::Branch()
590   const Int_t kBufsize = 32000; // default value in TTree::Branch()
591   
592   if (!fTreeA->FindBranch(obj->GetName())) 
593   {
594     // Do the same as if we book via 
595     // TTree::Branch(TCollection*)
596     
597     fTreeA->Bronch(obj->GetName(), cname, fAODEvent->GetList()->GetObjectRef(obj),
598                    kBufsize, kSplitlevel - 1);
599   }
600   owd->cd();
601 }
602
603 //______________________________________________________________________________
604 AliAODExtension *AliAODHandler::AddExtension(const char *filename, const char *title)
605 {
606   // Add an AOD extension with some branches in a different file.
607   
608   TString fname(filename);
609   if (!fname.EndsWith(".root")) fname += ".root";
610   if (!fExtensions) {
611     fExtensions = new TObjArray();
612     fExtensions->SetOwner();
613   }   
614   AliAODExtension *ext = (AliAODExtension*)fExtensions->FindObject(fname);
615   if (!ext) {
616     ext = new AliAODExtension(fname, title);
617     fExtensions->Add(ext);
618   }   
619   return ext;
620 }
621
622 //______________________________________________________________________________
623 AliAODExtension *AliAODHandler::GetExtension(const char *filename) const
624 {
625   // Getter for AOD extensions via file name.
626   if (!fExtensions) return NULL;
627   return (AliAODExtension*)fExtensions->FindObject(filename);
628 }   
629
630 //______________________________________________________________________________
631 AliAODExtension *AliAODHandler::AddFilteredAOD(const char *filename, const char *filtername)
632 {
633   // Add an AOD extension that can write only AOD events that pass a user filter.
634   if (!fFilters) {
635     fFilters = new TObjArray();
636     fFilters->SetOwner();
637   } 
638   AliAODExtension *filter = (AliAODExtension*)fFilters->FindObject(filename);
639   if (!filter) {
640     filter = new AliAODExtension(filename, filtername, kTRUE);
641     fFilters->Add(filter);
642   }
643   return filter;
644 }      
645
646 //______________________________________________________________________________
647 AliAODExtension *AliAODHandler::GetFilteredAOD(const char *filename) const
648 {
649   // Getter for AOD filters via file name.
650   if (!fFilters) return NULL;
651   return (AliAODExtension*)fFilters->FindObject(filename);
652 }   
653
654 //______________________________________________________________________________
655 void AliAODHandler::SetOutputFileName(const char* fname)
656 {
657 // Set file name.
658    fFileName = fname;
659 }
660
661 //______________________________________________________________________________
662 const char *AliAODHandler::GetOutputFileName()
663 {
664 // Get file name.
665    return fFileName.Data();
666 }
667
668 //______________________________________________________________________________
669 const char *AliAODHandler::GetExtraOutputs() const
670 {
671   // Get extra outputs as a string separated by commas.
672   static TString eoutputs;
673   eoutputs = "";
674   TObject *obj;
675   if (fExtensions) {
676     TIter next1(fExtensions);
677     while ((obj=next1())) {
678       if (!eoutputs.IsNull()) eoutputs += ",";
679       eoutputs += obj->GetName();
680     }
681   }
682   if (fFilters) {
683     TIter next2(fFilters);
684     while ((obj=next2())) {
685       if (!eoutputs.IsNull()) eoutputs += ",";
686       eoutputs += obj->GetName();
687     }
688   }
689   return eoutputs.Data();
690 }
691
692 //______________________________________________________________________________
693 Bool_t AliAODHandler::HasExtensions() const
694 {
695   // Whether or not we manage extensions
696   
697   if ( fExtensions && fExtensions->GetEntries()>0 ) return kTRUE;
698   
699   return kFALSE;
700 }
701
702 //______________________________________________________________________________
703 void  AliAODHandler::SetMCHeaderInfo(AliAODMCHeader *mcHeader,AliGenEventHeader *genHeader){
704
705
706   // Utility function to cover different cases for the AliGenEventHeader
707   // Needed since different ProcessType and ImpactParamter are not 
708   // in the base class...
709   // We don't encode process types for event cocktails yet
710   // could be done e.g. by adding offsets depnding on the generator
711
712   if(!genHeader)return;
713   mcHeader->AddGeneratorName(genHeader->GetName());
714   AliGenPythiaEventHeader *pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
715     if (pythiaGenHeader) {
716       mcHeader->SetEventType(pythiaGenHeader->ProcessType());
717       mcHeader->SetPtHard(pythiaGenHeader->GetPtHard());
718       return;
719     }
720     
721     AliGenDPMjetEventHeader* dpmJetGenHeader = dynamic_cast<AliGenDPMjetEventHeader*>(genHeader);
722
723   if (dpmJetGenHeader){
724     mcHeader->SetEventType(dpmJetGenHeader->ProcessType());
725     return;
726   } 
727
728   AliGenHijingEventHeader* hijingGenHeader = dynamic_cast<AliGenHijingEventHeader*>(genHeader);
729   if(hijingGenHeader){
730     mcHeader->SetImpactParameter(hijingGenHeader->ImpactParameter());
731     return;
732   }
733   
734   AliWarning(Form("MC Eventheader not known: %s",genHeader->GetName()));
735
736 }
737