adding reference data for Calib
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisTaskSE.cxx
CommitLineData
5232d0de 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18#include <TROOT.h>
19#include <TSystem.h>
20#include <TInterpreter.h>
21#include <TChain.h>
22#include <TFile.h>
23#include <TList.h>
24
25#include "AliAnalysisTaskSE.h"
26#include "AliAnalysisManager.h"
90a9a634 27#include "AliAnalysisCuts.h"
60a04972 28#include "AliAnalysisDataSlot.h"
90a9a634 29
5232d0de 30#include "AliESDEvent.h"
620ad672 31#include "AliESDfriend.h"
5232d0de 32#include "AliESD.h"
33#include "AliAODEvent.h"
3f2431c4 34#include "AliAODHeader.h"
c185e0db 35#include "AliAODTracklets.h"
5a922844 36#include "AliAODCaloCells.h"
113bc2bd 37#include "AliAODMCParticle.h"
5232d0de 38#include "AliVEvent.h"
39#include "AliAODHandler.h"
3f2431c4 40#include "AliAODInputHandler.h"
5232d0de 41#include "AliMCEventHandler.h"
42#include "AliInputEventHandler.h"
620ad672 43#include "AliESDInputHandler.h"
5232d0de 44#include "AliMCEvent.h"
45#include "AliStack.h"
4d0a82af 46#include "AliLog.h"
866d8d78 47#include "AliAODDimuon.h"
5232d0de 48
49
50ClassImp(AliAnalysisTaskSE)
51
52////////////////////////////////////////////////////////////////////////
90a9a634 53AliAODHeader* AliAnalysisTaskSE::fgAODHeader = NULL;
54TClonesArray* AliAnalysisTaskSE::fgAODTracks = NULL;
55TClonesArray* AliAnalysisTaskSE::fgAODVertices = NULL;
56TClonesArray* AliAnalysisTaskSE::fgAODV0s = NULL;
57TClonesArray* AliAnalysisTaskSE::fgAODPMDClusters = NULL;
58TClonesArray* AliAnalysisTaskSE::fgAODJets = NULL;
59TClonesArray* AliAnalysisTaskSE::fgAODFMDClusters = NULL;
60TClonesArray* AliAnalysisTaskSE::fgAODCaloClusters = NULL;
61TClonesArray* AliAnalysisTaskSE::fgAODMCParticles = NULL;
62AliAODTracklets* AliAnalysisTaskSE::fgAODTracklets = NULL;
63AliAODCaloCells* AliAnalysisTaskSE::fgAODEmcalCells = NULL;
64AliAODCaloCells* AliAnalysisTaskSE::fgAODPhosCells = NULL;
866d8d78 65TClonesArray* AliAnalysisTaskSE::fgAODDimuons = NULL;
5232d0de 66
67AliAnalysisTaskSE::AliAnalysisTaskSE():
68 AliAnalysisTask(),
69 fDebug(0),
80d13558 70 fEntry(0),
5232d0de 71 fInputEvent(0x0),
620ad672 72 fESDfriend(0x0),
80d13558 73 fInputHandler(0x0),
5232d0de 74 fOutputAOD(0x0),
75 fMCEvent(0x0),
9a587f77 76 fTreeA(0x0),
77 fCurrentRunNumber(-1),
90a9a634 78 fHistosQA(0x0),
79 fSelectCollisions(0)
5232d0de 80{
81 // Default constructor
82}
83
84AliAnalysisTaskSE::AliAnalysisTaskSE(const char* name):
85 AliAnalysisTask(name, "AnalysisTaskSE"),
86 fDebug(0),
80d13558 87 fEntry(0),
5232d0de 88 fInputEvent(0x0),
620ad672 89 fESDfriend(0x0),
80d13558 90 fInputHandler(0x0),
5232d0de 91 fOutputAOD(0x0),
92 fMCEvent(0x0),
1ec2c8dc 93 fTreeA(0x0),
94 fCurrentRunNumber(-1),
90a9a634 95 fHistosQA(0x0),
96 fSelectCollisions(0)
5232d0de 97{
98 // Default constructor
99 DefineInput (0, TChain::Class());
100 DefineOutput(0, TTree::Class());
101}
102
26f071d8 103AliAnalysisTaskSE::AliAnalysisTaskSE(const AliAnalysisTaskSE& obj):
104 AliAnalysisTask(obj),
105 fDebug(0),
80d13558 106 fEntry(0),
26f071d8 107 fInputEvent(0x0),
620ad672 108 fESDfriend(0x0),
80d13558 109 fInputHandler(0x0),
26f071d8 110 fOutputAOD(0x0),
111 fMCEvent(0x0),
1ec2c8dc 112 fTreeA(0x0),
113 fCurrentRunNumber(-1),
90a9a634 114 fHistosQA(0x0),
115 fSelectCollisions(0)
26f071d8 116{
117// Copy constructor
1ec2c8dc 118 fDebug = obj.fDebug;
119 fEntry = obj.fEntry;
120 fInputEvent = obj.fInputEvent;
620ad672 121 fESDfriend = obj.fESDfriend;
1ec2c8dc 122 fInputHandler = obj.fInputHandler;
123 fOutputAOD = obj.fOutputAOD;
124 fMCEvent = obj.fMCEvent;
125 fTreeA = obj.fTreeA;
126 fCurrentRunNumber = obj.fCurrentRunNumber;
127 fHistosQA = obj.fHistosQA;
90a9a634 128
26f071d8 129}
130
131
132AliAnalysisTaskSE& AliAnalysisTaskSE::operator=(const AliAnalysisTaskSE& other)
133{
134// Assignment
135 AliAnalysisTask::operator=(other);
1ec2c8dc 136 fDebug = other.fDebug;
137 fEntry = other.fEntry;
138 fInputEvent = other.fInputEvent;
620ad672 139 fESDfriend = other.fESDfriend;
1ec2c8dc 140 fInputHandler = other.fInputHandler;
141 fOutputAOD = other.fOutputAOD;
142 fMCEvent = other.fMCEvent;
143 fTreeA = other.fTreeA;
144 fCurrentRunNumber = other.fCurrentRunNumber;
145 fHistosQA = other.fHistosQA;
90a9a634 146 fSelectCollisions = other.fSelectCollisions;
26f071d8 147 return *this;
148}
5232d0de 149
150
151void AliAnalysisTaskSE::ConnectInputData(Option_t* /*option*/)
152{
153// Connect the input data
154 if (fDebug > 1) printf("AnalysisTaskSE::ConnectInputData() \n");
155//
156// ESD
157//
f0b15803 158 fInputHandler = (AliInputEventHandler*)
259b7a8a 159 ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
5232d0de 160//
161// Monte Carlo
162//
163 AliMCEventHandler* mcH = 0;
164 mcH = (AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
04a79fa0 165 if (mcH) {
166 fMCEvent = mcH->MCEvent();
167 }
259b7a8a 168
169 if (fInputHandler) {
620ad672 170 if ((fInputHandler->GetTree())->GetBranch("ESDfriend."))
171 fESDfriend = ((AliESDInputHandler*)fInputHandler)->GetESDfriend();
172
173 fInputEvent = fInputHandler->GetEvent();
259b7a8a 174 } else if( fMCEvent ) {
175 AliWarning("No Input Event Handler connected, only MC Truth Event Handler") ;
176 } else {
177 AliError("No Input Event Handler connected") ;
178 return ;
179 }
5232d0de 180}
181
182void AliAnalysisTaskSE::CreateOutputObjects()
183{
184// Create the output container
185//
186// Default AOD
187 if (fDebug > 1) printf("AnalysisTaskSE::CreateOutPutData() \n");
188
189 AliAODHandler* handler = (AliAODHandler*)
259b7a8a 190 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
5232d0de 191
5a922844 192 Bool_t merging = kFALSE;
193 AliAODInputHandler* aodIH = static_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
194 if (aodIH) {
195 if (aodIH->GetMergeEvents()) merging = kTRUE;
196 }
197
90a9a634 198
c185e0db 199 // Check if AOD replication has been required
200
3b9a675c 201 if (handler) {
202 fOutputAOD = handler->GetAOD();
203 fTreeA = handler->GetTree();
d7c65b93 204 if (fOutputAOD && !(handler->IsStandard())) {
c185e0db 205 if ((handler->NeedsHeaderReplication()) && !(fgAODHeader))
206 {
87022830 207 if (fDebug > 1) AliInfo("Replicating header");
208 fgAODHeader = new AliAODHeader;
209 handler->AddBranch("AliAODHeader", &fgAODHeader);
c185e0db 210 }
5a922844 211 if ((handler->NeedsTracksBranchReplication() || merging) && !(fgAODTracks))
c185e0db 212 {
213 if (fDebug > 1) AliInfo("Replicating track branch\n");
214 fgAODTracks = new TClonesArray("AliAODTrack",500);
87022830 215 fgAODTracks->SetName("tracks");
c185e0db 216 handler->AddBranch("TClonesArray", &fgAODTracks);
217 }
4dd8a1c8 218 if ((handler->NeedsVerticesBranchReplication() || merging) && !(fgAODVertices))
c185e0db 219 {
220 if (fDebug > 1) AliInfo("Replicating vertices branch\n");
221 fgAODVertices = new TClonesArray("AliAODVertex",500);
87022830 222 fgAODVertices->SetName("vertices");
c185e0db 223 handler->AddBranch("TClonesArray", &fgAODVertices);
224 }
225 if ((handler->NeedsV0sBranchReplication()) && !(fgAODV0s))
226 {
227 if (fDebug > 1) AliInfo("Replicating V0s branch\n");
228 fgAODV0s = new TClonesArray("AliAODv0",500);
87022830 229 fgAODV0s->SetName("v0s");
c185e0db 230 handler->AddBranch("TClonesArray", &fgAODV0s);
231 }
232 if ((handler->NeedsTrackletsBranchReplication()) && !(fgAODTracklets))
233 {
234 if (fDebug > 1) AliInfo("Replicating Tracklets branch\n");
87022830 235 fgAODTracklets = new AliAODTracklets("tracklets","tracklets");
c185e0db 236 handler->AddBranch("AliAODTracklets", &fgAODTracklets);
237 }
238 if ((handler->NeedsPMDClustersBranchReplication()) && !(fgAODPMDClusters))
239 {
240 if (fDebug > 1) AliInfo("Replicating PMDClusters branch\n");
241 fgAODPMDClusters = new TClonesArray("AliAODPmdCluster",500);
87022830 242 fgAODPMDClusters->SetName("pmdClusters");
c185e0db 243 handler->AddBranch("TClonesArray", &fgAODPMDClusters);
244 }
5a922844 245 if ((handler->NeedsJetsBranchReplication() || merging) && !(fgAODJets))
c185e0db 246 {
247 if (fDebug > 1) AliInfo("Replicating Jets branch\n");
248 fgAODJets = new TClonesArray("AliAODJet",500);
87022830 249 fgAODJets->SetName("jets");
c185e0db 250 handler->AddBranch("TClonesArray", &fgAODJets);
251 }
252 if ((handler->NeedsFMDClustersBranchReplication()) && !(fgAODFMDClusters))
253 {
254 AliInfo("Replicating FMDClusters branch\n");
255 fgAODFMDClusters = new TClonesArray("AliAODFmdCluster",500);
87022830 256 fgAODFMDClusters->SetName("fmdClusters");
c185e0db 257 handler->AddBranch("TClonesArray", &fgAODFMDClusters);
258 }
5a922844 259 if ((handler->NeedsCaloClustersBranchReplication() || merging) && !(fgAODCaloClusters))
c185e0db 260 {
261 if (fDebug > 1) AliInfo("Replicating CaloClusters branch\n");
262 fgAODCaloClusters = new TClonesArray("AliAODCaloCluster",500);
87022830 263 fgAODCaloClusters->SetName("caloClusters");
c185e0db 264 handler->AddBranch("TClonesArray", &fgAODCaloClusters);
5a922844 265
266 fgAODEmcalCells = new AliAODCaloCells();
267 fgAODEmcalCells->SetName("emcalCells");
268 handler->AddBranch("AliAODCaloCells", &fgAODEmcalCells);
269
270 fgAODPhosCells = new AliAODCaloCells();
271 fgAODPhosCells->SetName("phosCells");
272 handler->AddBranch("AliAODCaloCells", &fgAODPhosCells);
c185e0db 273 }
113bc2bd 274 if ((handler->NeedsMCParticlesBranchReplication() || merging) && !(fgAODMCParticles))
275 {
276 if (fDebug > 1) AliInfo("Replicating MCParticles branch\n");
277 fgAODMCParticles = new TClonesArray("AliAODMCParticle",500);
278 fgAODMCParticles->SetName("mcparticles");
279 handler->AddBranch("TClonesArray", &fgAODMCParticles);
280 }
866d8d78 281 if ((handler->NeedsDimuonsBranchReplication() || merging) && !(fgAODDimuons))
282 {
283 if (fDebug > 1) AliInfo("Replicating dimuon branch\n");
284 fgAODDimuons = new TClonesArray("AliAODDimuon",0);
285 fgAODDimuons->SetName("dimuons");
286 handler->AddBranch("TClonesArray", &fgAODDimuons);
287 }
288
5a922844 289 // cache the pointerd in the AODEvent
290 fOutputAOD->GetStdContent();
3f2431c4 291 }
3b9a675c 292 } else {
293 AliWarning("No AOD Event Handler connected.") ;
294 }
5232d0de 295 UserCreateOutputObjects();
296}
297
298void AliAnalysisTaskSE::Exec(Option_t* option)
299{
300//
301// Exec analysis of one event
27704f6c 302 if ( fDebug >= 10)
303 printf("Task is active %5d\n", IsActive());
8f6e7d10 304
259b7a8a 305 if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
fdda6b64 306//
307 AliAODHandler* handler = (AliAODHandler*)
308 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
309 AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
310//
311// Was event selected ?
bf666461 312 Bool_t isSelected = kTRUE;
9b98c4df 313 if( fInputHandler && fInputHandler->GetEventSelection() && fSelectCollisions) {
bf666461 314 isSelected = fInputHandler->IsEventSelected();
04a79fa0 315 }
9b98c4df 316
fdda6b64 317 if (handler) handler->SetFillAOD(isSelected);
9b98c4df 318
80ce1b4e 319 if( fInputHandler ) {
320 fEntry = fInputHandler->GetReadEntry();
321 fESDfriend = ((AliESDInputHandler*)fInputHandler)->GetESDfriend();
322 }
323
bf666461 324
39b02a2e 325// Notify the change of run number
276b8751 326 if (InputEvent() && (InputEvent()->GetRunNumber() != fCurrentRunNumber)) {
39b02a2e 327 fCurrentRunNumber = InputEvent()->GetRunNumber();
328 NotifyRun();
329 }
04a79fa0 330
259b7a8a 331 else if( fMCEvent )
332 fEntry = fMCEvent->Header()->GetEvent();
4d0a82af 333 if ( !((Entry()-1)%100) && fDebug > 0)
259b7a8a 334 AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
3f2431c4 335
fdda6b64 336
337
c185e0db 338
339 if (handler && aodH) {
04a79fa0 340 fMCEvent = aodH->MCEvent();
5a922844 341 Bool_t merging = aodH->GetMergeEvents();
04a79fa0 342
c185e0db 343 if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
344 if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
345 {
61d5496b 346 // copy the contents by assigment
347 *fgAODHeader = *(dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
daa81fe5 348 }
5a922844 349 if ((handler->NeedsTracksBranchReplication() || merging) && (fgAODTracks))
c185e0db 350 {
351 TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
352 new (fgAODTracks) TClonesArray(*tracks);
353 }
417ab5ac 354 if ((handler->NeedsVerticesBranchReplication() || merging) && (fgAODVertices))
c185e0db 355 {
356 TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
357 new (fgAODVertices) TClonesArray(*vertices);
358 }
359 if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
360 {
113bc2bd 361 TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
362 new (fgAODV0s) TClonesArray(*v0s);
c185e0db 363 }
364 if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
365 {
61d5496b 366 *fgAODTracklets = *(dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
c185e0db 367 }
368 if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
369 {
113bc2bd 370 TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
371 new (fgAODPMDClusters) TClonesArray(*pmdClusters);
c185e0db 372 }
5a922844 373 if ((handler->NeedsJetsBranchReplication() || merging) && (fgAODJets))
c185e0db 374 {
113bc2bd 375 TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
376 new (fgAODJets) TClonesArray(*jets);
c185e0db 377 }
378 if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
379 {
113bc2bd 380 TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
381 new (fgAODFMDClusters) TClonesArray(*fmdClusters);
c185e0db 382 }
5a922844 383 if ((handler->NeedsCaloClustersBranchReplication() || merging) && (fgAODCaloClusters))
c185e0db 384 {
113bc2bd 385 TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
386 new (fgAODCaloClusters) TClonesArray(*caloClusters);
387 }
388
389 if ((handler->NeedsMCParticlesBranchReplication() || merging) && (fgAODMCParticles))
390 {
391 TClonesArray* mcParticles = (TClonesArray*) ((dynamic_cast<AliAODEvent*>(InputEvent()))->FindListObject("mcparticles"));
392 new (fgAODMCParticles) TClonesArray(*mcParticles);
c185e0db 393 }
866d8d78 394
395 if ((handler->NeedsDimuonsBranchReplication() || merging) && (fgAODDimuons))
396 {
8f6e7d10 397 fgAODDimuons->Clear();
398 TClonesArray& dimuons = *fgAODDimuons;
399 TClonesArray& tracksnew = *fgAODTracks;
400
401 Int_t nMuonTrack[10];
402 for(Int_t imuon = 0; imuon < 10; imuon++) nMuonTrack[imuon] = 0;
403 Int_t nMuons=0;
404 for(Int_t ii=0; ii < fgAODTracks->GetEntries(); ii++){
405 AliAODTrack *track = (AliAODTrack*) fgAODTracks->At(ii);
406 if(track->IsMuonTrack()) {
407 nMuonTrack[nMuons]= ii;
408 nMuons++;
409 }
410 }
411 Int_t jDimuons=0;
412 if(nMuons >= 2){
413 for(Int_t i = 0; i < nMuons; i++){
414 Int_t index0 = nMuonTrack[i];
415 for(Int_t j = i+1; j < nMuons; j++){
416 Int_t index1 = nMuonTrack[j];
8f6e7d10 417 tracksnew.At(index0)->ResetBit(kIsReferenced);
418 tracksnew.At(index0)->SetUniqueID(0);
419 tracksnew.At(index1)->ResetBit(kIsReferenced);
420 tracksnew.At(index1)->SetUniqueID(0);
421 new(dimuons[jDimuons++]) AliAODDimuon(tracksnew.At(index0),tracksnew.At(index1));
422 }
423 }
424 }
866d8d78 425 }
8f6e7d10 426
5a922844 427 // Additional merging if needed
428 if (merging) {
113bc2bd 429 // mcParticles
430 TClonesArray* mcparticles = (TClonesArray*) ((aodH->GetEventToMerge())->FindListObject("mcparticles"));
431 Int_t npart = mcparticles->GetEntries();
432 Int_t nc = fgAODMCParticles->GetEntries();
433 Int_t nc0 = nc;
434
435 for (Int_t i = 0; i < npart; i++) {
436 AliAODMCParticle* particle = (AliAODMCParticle*) mcparticles->At(i);
c8de791b 437 new((*fgAODMCParticles)[nc++]) AliAODMCParticle(*particle);
113bc2bd 438 }
439
5a922844 440 // tracks
441 TClonesArray* tracks = aodH->GetEventToMerge()->GetTracks();
442 Int_t ntr = tracks->GetEntries();
113bc2bd 443 nc = fgAODTracks->GetEntries();
5a922844 444 for (Int_t i = 0; i < ntr; i++) {
445 AliAODTrack* track = (AliAODTrack*) tracks->At(i);
446 AliAODTrack* newtrack = new((*fgAODTracks)[nc++]) AliAODTrack(*track);
113bc2bd 447 newtrack->SetLabel(newtrack->GetLabel() + nc0);
5a922844 448 }
c8de791b 449
450 for (Int_t i = 0; i < nc; i++)
451 {
452 AliAODTrack* track = (AliAODTrack*) fgAODTracks->At(i);
453 track->ResetBit(kIsReferenced);
454 track->SetUniqueID(0);
455 }
456
457
5a922844 458 // clusters
459 TClonesArray* clusters = aodH->GetEventToMerge()->GetCaloClusters();
460 Int_t ncl = clusters->GetEntries();
461 nc = fgAODCaloClusters->GetEntries();
462 for (Int_t i = 0; i < ncl; i++) {
463 AliAODCaloCluster* cluster = (AliAODCaloCluster*) clusters->At(i);
c8de791b 464 new((*fgAODCaloClusters)[nc++]) AliAODCaloCluster(*cluster);
5a922844 465 }
466 // cells
467 AliAODCaloCells* cellsA = aodH->GetEventToMerge()->GetEMCALCells();
468 Int_t ncells = cellsA->GetNumberOfCells();
469 nc = fgAODEmcalCells->GetNumberOfCells();
470
471 for (Int_t i = 0; i < ncells; i++) {
472 Int_t cn = cellsA->GetCellNumber(i);
473 Int_t pos = fgAODEmcalCells->GetCellPosition(cn);
474 if (pos >= 0) {
475 Double_t amp = cellsA->GetAmplitude(i) + fgAODEmcalCells->GetAmplitude(pos);
476 fgAODEmcalCells->SetCell(pos, cn, amp);
477 } else {
478 Double_t amp = cellsA->GetAmplitude(i);
479 fgAODEmcalCells->SetCell(nc++, cn, amp);
480 fgAODEmcalCells->Sort();
481 }
482 }
113bc2bd 483
484
485 } // merging
c185e0db 486
5a922844 487 handler->SetAODIsReplicated();
3f2431c4 488 }
489 }
490
4d0a82af 491// Call the user analysis
bf666461 492 if (!fSelectCollisions || isSelected)
90a9a634 493 UserExec(option);
494
495// Added protection in case the derived task is not an AOD producer.
60a04972 496 AliAnalysisDataSlot *out0 = GetOutputSlot(0);
497 if (out0 && out0->IsConnected()) PostData(0, fTreeA);
5232d0de 498}
499
4d0a82af 500const char* AliAnalysisTaskSE::CurrentFileName()
501{
502// Returns the current file name
259b7a8a 503 if( fInputHandler )
504 return fInputHandler->GetTree()->GetCurrentFile()->GetName();
505 else if( fMCEvent )
506 return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
8803dcb1 507 else return "";
4d0a82af 508}
5232d0de 509
3cee83d7 510void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char *fname)
164e94ff 511{
512 // Add a new branch to the aod tree
513 AliAODHandler* handler = (AliAODHandler*)
514 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
515 if (handler) {
3cee83d7 516 handler->AddBranch(cname, addobj, fname);
164e94ff 517 }
518}
3cee83d7 519
520Bool_t AliAnalysisTaskSE::IsStandardAOD() const
521{
522// Check if the output AOD handler is configured for standard or delta AOD.
523// Users should first check that AODEvent() returns non-null.
524 AliAODHandler* handler = (AliAODHandler*)
525 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
526 if (!handler) {
527 Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
528 return kTRUE;
529 }
530 return handler->IsStandard();
531}
1ec2c8dc 532
533Bool_t AliAnalysisTaskSE::Notify()
534{
9a587f77 535 return (UserNotify());
1ec2c8dc 536}
537
538