Fix for Coverity #10278
[u/mrichter/AliRoot.git] / STEER / AliAODHandler.cxx
CommitLineData
3fbf06a3 1
ec4af4c1 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
052994fb 24
ec4af4c1 25#include <TTree.h>
e910dd36 26#include <TFile.h>
7970f4ac 27#include <TString.h>
dce1b636 28#include <TList.h>
160959a9 29#include <TROOT.h>
e910dd36 30
da97a08a 31#include "AliLog.h"
ec4af4c1 32#include "AliAODHandler.h"
33#include "AliAODEvent.h"
aa7e002c 34#include "AliAODExtension.h"
da97a08a 35#include "AliAODTracklets.h"
36#include "AliStack.h"
37#include "AliAODMCParticle.h"
dce1b636 38#include "AliAODMCHeader.h"
da97a08a 39#include "AliMCEventHandler.h"
40#include "AliMCEvent.h"
dce1b636 41#include "AliGenEventHeader.h"
42#include "AliGenHijingEventHeader.h"
43#include "AliGenDPMjetEventHeader.h"
44#include "AliGenPythiaEventHeader.h"
45#include "AliGenCocktailEventHeader.h"
26ba01d4 46#include "AliCodeTimer.h"
47#include "AliAODBranchReplicator.h"
48#include "Riostream.h"
ec4af4c1 49
50ClassImp(AliAODHandler)
51
52//______________________________________________________________________________
53AliAODHandler::AliAODHandler() :
f3214a54 54 AliVEventHandler(),
78f7f935 55 fIsStandard(kTRUE),
da97a08a 56 fFillAOD(kTRUE),
41b01ae4 57 fFillAODRun(kTRUE),
ca2834f6 58 fFillExtension(kTRUE),
7c3a9fbf 59 fNeedsHeaderReplication(kFALSE),
75754ba8 60 fNeedsTracksBranchReplication(kFALSE),
61 fNeedsVerticesBranchReplication(kFALSE),
62 fNeedsV0sBranchReplication(kFALSE),
e0107012 63 fNeedsCascadesBranchReplication(kFALSE),
75754ba8 64 fNeedsTrackletsBranchReplication(kFALSE),
65 fNeedsPMDClustersBranchReplication(kFALSE),
66 fNeedsJetsBranchReplication(kFALSE),
67 fNeedsFMDClustersBranchReplication(kFALSE),
68 fNeedsCaloClustersBranchReplication(kFALSE),
3549c522 69 fNeedsMCParticlesBranchReplication(kFALSE),
866d8d78 70 fNeedsDimuonsBranchReplication(kFALSE),
75754ba8 71 fAODIsReplicated(kFALSE),
ec4af4c1 72 fAODEvent(NULL),
da97a08a 73 fMCEventH(NULL),
e910dd36 74 fTreeA(NULL),
75 fFileA(NULL),
9066c676 76 fFileName(""),
582cfeb5 77 fExtensions(NULL),
78 fFilters(NULL)
ec4af4c1 79{
80 // default constructor
81}
82
83//______________________________________________________________________________
84AliAODHandler::AliAODHandler(const char* name, const char* title):
f3214a54 85 AliVEventHandler(name, title),
78f7f935 86 fIsStandard(kTRUE),
da97a08a 87 fFillAOD(kTRUE),
41b01ae4 88 fFillAODRun(kTRUE),
ca2834f6 89 fFillExtension(kTRUE),
7c3a9fbf 90 fNeedsHeaderReplication(kFALSE),
75754ba8 91 fNeedsTracksBranchReplication(kFALSE),
92 fNeedsVerticesBranchReplication(kFALSE),
93 fNeedsV0sBranchReplication(kFALSE),
e0107012 94 fNeedsCascadesBranchReplication(kFALSE),
75754ba8 95 fNeedsTrackletsBranchReplication(kFALSE),
96 fNeedsPMDClustersBranchReplication(kFALSE),
97 fNeedsJetsBranchReplication(kFALSE),
98 fNeedsFMDClustersBranchReplication(kFALSE),
99 fNeedsCaloClustersBranchReplication(kFALSE),
3549c522 100 fNeedsMCParticlesBranchReplication(kFALSE),
866d8d78 101 fNeedsDimuonsBranchReplication(kFALSE),
75754ba8 102 fAODIsReplicated(kFALSE),
ec4af4c1 103 fAODEvent(NULL),
da97a08a 104 fMCEventH(NULL),
e910dd36 105 fTreeA(NULL),
106 fFileA(NULL),
9066c676 107 fFileName(""),
582cfeb5 108 fExtensions(NULL),
109 fFilters(NULL)
ec4af4c1 110{
582cfeb5 111// Normal constructor.
ec4af4c1 112}
113
114//______________________________________________________________________________
115AliAODHandler::~AliAODHandler()
116{
9066c676 117 // Destructor.
14d6fad5 118
119 delete fAODEvent;
120
121 if (fFileA)
122 {
6989bff3 123 // is already handled in TerminateIO
124 fFileA->Close();
125 delete fFileA;
48f1c230 126 fTreeA = 0;
6989bff3 127 }
14d6fad5 128 delete fTreeA;
129 delete fExtensions;
130 delete fFilters;
ec4af4c1 131}
132
7970f4ac 133//______________________________________________________________________________
300d5701 134Bool_t AliAODHandler::Init(Option_t* opt)
ec4af4c1 135{
6989bff3 136 // Initialize IO
137 //
138 // Create the AODevent object
e0107012 139
4e6d5854 140 Bool_t createStdAOD = fIsStandard || fFillAOD;
aa399a26 141 if(!fAODEvent && createStdAOD){
ec4af4c1 142 fAODEvent = new AliAODEvent();
c8fe2783 143 if (fIsStandard)
144 fAODEvent->CreateStdContent();
6989bff3 145 }
146 //
147 // File opening according to execution mode
7970f4ac 148 TString option(opt);
149 option.ToLower();
aa399a26 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 }
9066c676 165 if (fExtensions) {
166 TIter next(fExtensions);
167 AliAODExtension *ext;
168 while ((ext=(AliAODExtension*)next())) ext->Init(option);
169 }
582cfeb5 170 if (fFilters) {
171 TIter nextf(fFilters);
172 AliAODExtension *filteredAOD;
173 while ((filteredAOD=(AliAODExtension*)nextf())) {
174 filteredAOD->SetEvent(fAODEvent);
175 filteredAOD->Init(option);
14d6fad5 176 }
582cfeb5 177 }
14d6fad5 178
6989bff3 179 return kTRUE;
ec4af4c1 180}
181
9066c676 182//______________________________________________________________________________
26ba01d4 183void 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;
b5b9155e 192 PrintExtensions(*fExtensions);
26ba01d4 193 }
194 if ( fFilters )
195 {
196 cout << opt << fFilters->GetEntries() << " filters :" << endl;
b5b9155e 197 PrintExtensions(*fFilters);
26ba01d4 198 }
199}
200
201//______________________________________________________________________________
b5b9155e 202void AliAODHandler::PrintExtensions(const TObjArray& array) const
26ba01d4 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//______________________________________________________________________________
da97a08a 214void AliAODHandler::StoreMCParticles(){
dce1b636 215
da97a08a 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
dce1b636 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)
da97a08a 232
aa399a26 233 if (!fAODEvent) return;
da97a08a 234 TClonesArray *mcarray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
235 if(!mcarray)return;
da97a08a 236
dce1b636 237 AliAODMCHeader *mcHeader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName());
238 if(!mcHeader)return;
239
da97a08a 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
dce1b636 251 //
252 // Get the Event Header
253 //
254
255 AliHeader* header = fMCEventH->MCEvent()->Header();
9efd8e10 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));
c9e2b9f3 274 if (!headerEntry) {
275 AliFatal("AliGenEventHeader entry not found in the header list");
276 } else {
277 SetMCHeaderInfo(mcHeader,headerEntry);
278 }
9efd8e10 279 }
280 }
281 else{
282 // No Cocktail just take the first one
283 SetMCHeaderInfo(mcHeader,genHeader);
284 }
dce1b636 285 }
9efd8e10 286
dce1b636 287
288
289
290
291 // Store the AliAODParticlesMC
93836e1b 292 AliMCEvent* mcEvent = fMCEventH->MCEvent();
293
294 Int_t np = mcEvent->GetNumberOfTracks();
295 Int_t nprim = mcEvent->GetNumberOfPrimaries();
da97a08a 296
297
298 Int_t j = 0;
299 TClonesArray& l = *mcarray;
300
93836e1b 301 for(int i = 0; i < np; ++i){
302 if(fMCEventH->IsParticleSelected(i)){
303 Int_t flag = 0;
6cd07d0a 304 AliMCParticle* mcpart = (AliMCParticle*) mcEvent->GetTrack(i);
93836e1b 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));
da97a08a 311 }
da97a08a 312
93836e1b 313 AliAODMCParticle mcpart_tmp(mcpart,i,flag);
314
6326aeae 315 mcpart_tmp.SetStatus(mcpart->Particle()->GetStatusCode());
93836e1b 316 //
317 Int_t d0 = mcpart_tmp.GetDaughter(0);
318 Int_t d1 = mcpart_tmp.GetDaughter(1);
319 Int_t m = mcpart_tmp.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 mcpart_tmp.SetDaughter(0,d0);
329 mcpart_tmp.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 mcpart_tmp.SetDaughter(0,fMCEventH->GetNewLabel(d0));
335 } else {
336 mcpart_tmp.SetDaughter(0,-1);
337 }
338 mcpart_tmp.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 d0_tmp = -1;
344 Int_t d1_tmp = -1;
345 for(int id = d0; id<=d1;++id){
346 if(fMCEventH->IsParticleSelected(id)){
347 if(d0_tmp==-1){
348 // first time
349 d0_tmp = fMCEventH->GetNewLabel(id);
350 d1_tmp = d0_tmp; // 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 d1_tmp = fMCEventH->GetNewLabel(id);
353 }
354 }
355 mcpart_tmp.SetDaughter(0,d0_tmp);
356 mcpart_tmp.SetDaughter(1,d1_tmp);
357 } else {
358 AliError(Form("Unxpected indices %d %d",d0,d1));
359 }
360
361 if(m<0){
362 mcpart_tmp.SetMother(m);
363 } else {
364 if(fMCEventH->IsParticleSelected(m))mcpart_tmp.SetMother(fMCEventH->GetNewLabel(m));
365 else AliError(Form("PROBLEM Mother not selected %d \n", m));
366 }
6326aeae 367
93836e1b 368 new (l[j++]) AliAODMCParticle(mcpart_tmp);
369
da97a08a 370 }
da97a08a 371 }
93836e1b 372 AliInfo(Form("AliAODHandler::StoreMCParticles: Selected %d (Primaries %d / total %d) after validation \n",
da97a08a 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
91dece68 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
93836e1b 391 if (label >= AliMCEvent::BgLabelOffset()) label = mcEvent->BgLabelToIndex(label);
93836e1b 392 if(label > np || track->GetLabel() == 0){
393 AliWarning(Form("Wrong ESD track label %5d (%5d)",track->GetLabel(), label));
da97a08a 394 }
93836e1b 395 if(fMCEventH->GetNewLabel(label) == 0){
396 AliWarning(Form("New label not found for %5d (%5d)",track->GetLabel(), label));
da97a08a 397 }
91dece68 398 track->SetLabel(sign*fMCEventH->GetNewLabel(label));
da97a08a 399 }
400 }
401
402 // AOD calo cluster
403 TClonesArray *clusters = fAODEvent->GetCaloClusters();
404 if(clusters){
c8fe2783 405 for (Int_t iClust = 0;iClust < fAODEvent->GetNumberOfCaloClusters(); ++iClust) {
da97a08a 406 AliAODCaloCluster * cluster = fAODEvent->GetCaloCluster(iClust);
c8fe2783 407 UInt_t nLabel = cluster->GetNLabels();
da97a08a 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){
c8fe2783 413 labels[i] = fMCEventH->GetNewLabel(cluster->GetLabelAt(i));
da97a08a 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
9066c676 435//______________________________________________________________________________
5f380da9 436Bool_t AliAODHandler::FinishEvent()
ec4af4c1 437{
da97a08a 438 // Fill data structures
4e6d5854 439 if(fFillAOD && fFillAODRun && fAODEvent){
b8b7dd5c 440 fAODEvent->MakeEntriesReferencable();
e0107012 441 fTreeA->BranchRef();
b8b7dd5c 442 FillTree();
4e6d5854 443 }
f133e976 444
ca2834f6 445 if ((fFillAOD && fFillAODRun) || fFillExtension) {
307b6330 446 if (fExtensions && fFillExtension) {
447 // fFillExtension can be set by the ESD filter or by a delta filter in case of AOD inputs
14d6fad5 448 TIter next(fExtensions);
449 AliAODExtension *ext;
450 while ((ext=(AliAODExtension*)next())) ext->FinishEvent();
451 }
307b6330 452 if (fFilters && fFillAOD && fFillAODRun) {
14d6fad5 453 TIter nextf(fFilters);
454 AliAODExtension *ext;
455 while ((ext=(AliAODExtension*)nextf())) {
b8b7dd5c 456 ext->FinishEvent();
14d6fad5 457 }
458 }
aa399a26 459 }
14d6fad5 460
dddc33c5 461 if (fIsStandard && fAODEvent)
14d6fad5 462 {
463 fAODEvent->ResetStd();
464 }
465
466 if (fAODEvent)
467 {
468 TClonesArray *mcarray = static_cast<TClonesArray*>(fAODEvent->FindListObject(AliAODMCParticle::StdBranchName()));
ef89f372 469 if(mcarray) mcarray->Delete();
470
14d6fad5 471 AliAODMCHeader *mcHeader = static_cast<AliAODMCHeader*>(fAODEvent->FindListObject(AliAODMCHeader::StdBranchName()));
ef89f372 472 if(mcHeader) mcHeader->Reset();
473 }
14d6fad5 474
da97a08a 475 // Reset AOD replication flag
476 fAODIsReplicated = kFALSE;
477 return kTRUE;
ec4af4c1 478}
479
7970f4ac 480//______________________________________________________________________________
ec4af4c1 481Bool_t AliAODHandler::Terminate()
482{
9066c676 483 // Terminate
484 AddAODtoTreeUserInfo();
14d6fad5 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
9066c676 499 return kTRUE;
ec4af4c1 500}
501
7970f4ac 502//______________________________________________________________________________
ec4af4c1 503Bool_t AliAODHandler::TerminateIO()
504{
9066c676 505 // Terminate IO
506 if (fFileA) {
aa399a26 507 fFileA->Write();
9066c676 508 fFileA->Close();
509 delete fFileA;
510 fFileA = 0;
48f1c230 511 // When closing the file, the tree is also deleted.
512 fTreeA = 0;
9066c676 513 }
14d6fad5 514
515 TIter nextF(fFilters);
516 AliAODExtension *ext;
517 while ((ext=static_cast<AliAODExtension*>(nextF())))
518 {
519 ext->TerminateIO();
9066c676 520 }
14d6fad5 521
522 TIter nextE(fExtensions);
523 while ((ext=static_cast<AliAODExtension*>(nextE())))
524 {
525 ext->TerminateIO();
582cfeb5 526 }
14d6fad5 527
9066c676 528 return kTRUE;
ec4af4c1 529}
530
7970f4ac 531//______________________________________________________________________________
954526ed 532void AliAODHandler::CreateTree(Int_t flag)
ec4af4c1 533{
534 // Creates the AOD Tree
f3214a54 535 fTreeA = new TTree("aodTree", "AliAOD tree");
ec4af4c1 536 fTreeA->Branch(fAODEvent->GetList());
954526ed 537 if (flag == 0) fTreeA->SetDirectory(0);
ec4af4c1 538}
539
7970f4ac 540//______________________________________________________________________________
ec4af4c1 541void AliAODHandler::FillTree()
542{
866d8d78 543
ec4af4c1 544 // Fill the AOD Tree
e0107012 545 fTreeA->Fill();
ec4af4c1 546}
547
7970f4ac 548//______________________________________________________________________________
ec4af4c1 549void AliAODHandler::AddAODtoTreeUserInfo()
550{
dce1b636 551 // Add aod event to tree user info
aa399a26 552 if (fTreeA) fTreeA->GetUserInfo()->Add(fAODEvent);
48f1c230 553 // Now the tree owns our fAODEvent...
554 fAODEvent = 0;
ec4af4c1 555}
490e9023 556
7970f4ac 557//______________________________________________________________________________
9066c676 558void AliAODHandler::AddBranch(const char* cname, void* addobj, const char* filename)
490e9023 559{
14d6fad5 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 }
dce1b636 583
14d6fad5 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();
490e9023 601}
7970f4ac 602
603//______________________________________________________________________________
9066c676 604AliAODExtension *AliAODHandler::AddExtension(const char *filename, const char *title)
605{
14d6fad5 606 // Add an AOD extension with some branches in a different file.
26ba01d4 607
14d6fad5 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;
9066c676 620}
582cfeb5 621
622//______________________________________________________________________________
623AliAODExtension *AliAODHandler::GetExtension(const char *filename) const
624{
14d6fad5 625 // Getter for AOD extensions via file name.
626 if (!fExtensions) return NULL;
627 return (AliAODExtension*)fExtensions->FindObject(filename);
582cfeb5 628}
629
630//______________________________________________________________________________
631AliAODExtension *AliAODHandler::AddFilteredAOD(const char *filename, const char *filtername)
632{
14d6fad5 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;
582cfeb5 644}
645
646//______________________________________________________________________________
647AliAODExtension *AliAODHandler::GetFilteredAOD(const char *filename) const
648{
14d6fad5 649 // Getter for AOD filters via file name.
650 if (!fFilters) return NULL;
651 return (AliAODExtension*)fFilters->FindObject(filename);
582cfeb5 652}
14d6fad5 653
9066c676 654//______________________________________________________________________________
7970f4ac 655void AliAODHandler::SetOutputFileName(const char* fname)
656{
657// Set file name.
658 fFileName = fname;
659}
660
661//______________________________________________________________________________
662const char *AliAODHandler::GetOutputFileName()
663{
664// Get file name.
665 return fFileName.Data();
666}
dce1b636 667
9066c676 668//______________________________________________________________________________
90d50a8c 669const char *AliAODHandler::GetExtraOutputs() const
670{
14d6fad5 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//______________________________________________________________________________
693Bool_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;
90d50a8c 700}
701
702//______________________________________________________________________________
dce1b636 703void 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
9066c676 710 // could be done e.g. by adding offsets depnding on the generator
dce1b636 711
dce1b636 712 if(!genHeader)return;
4986ae9e 713 mcHeader->AddGeneratorName(genHeader->GetName());
dce1b636 714 AliGenPythiaEventHeader *pythiaGenHeader = dynamic_cast<AliGenPythiaEventHeader*>(genHeader);
715 if (pythiaGenHeader) {
716 mcHeader->SetEventType(pythiaGenHeader->ProcessType());
0fd37a1f 717 mcHeader->SetPtHard(pythiaGenHeader->GetPtHard());
dce1b636 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}
9066c676 737