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