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