Coding violation fixes
[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
259b7a8a 302 if (fDebug > 1) AliInfo("AliAnalysisTaskSE::Exec() \n");
fdda6b64 303//
304 AliAODHandler* handler = (AliAODHandler*)
305 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
306 AliAODInputHandler* aodH = dynamic_cast<AliAODInputHandler*>(fInputHandler);
307//
308// Was event selected ?
bf666461 309 Bool_t isSelected = kTRUE;
9b98c4df 310 if( fInputHandler && fInputHandler->GetEventSelection() && fSelectCollisions) {
bf666461 311 isSelected = fInputHandler->IsEventSelected();
04a79fa0 312 }
9b98c4df 313
fdda6b64 314 if (handler) handler->SetFillAOD(isSelected);
9b98c4df 315
316 if( fInputHandler ) fEntry = fInputHandler->GetReadEntry();
fdda6b64 317
bf666461 318
39b02a2e 319// Notify the change of run number
320 if (InputEvent()->GetRunNumber() != fCurrentRunNumber) {
321 fCurrentRunNumber = InputEvent()->GetRunNumber();
322 NotifyRun();
323 }
04a79fa0 324
259b7a8a 325 else if( fMCEvent )
326 fEntry = fMCEvent->Header()->GetEvent();
4d0a82af 327 if ( !((Entry()-1)%100) && fDebug > 0)
259b7a8a 328 AliInfo(Form("%s ----> Processing event # %lld", CurrentFileName(), Entry()));
3f2431c4 329
fdda6b64 330
331
c185e0db 332
333 if (handler && aodH) {
04a79fa0 334 fMCEvent = aodH->MCEvent();
5a922844 335 Bool_t merging = aodH->GetMergeEvents();
04a79fa0 336
c185e0db 337 if (!(handler->IsStandard()) && !(handler->AODIsReplicated())) {
338 if ((handler->NeedsHeaderReplication()) && (fgAODHeader))
339 {
61d5496b 340 // copy the contents by assigment
341 *fgAODHeader = *(dynamic_cast<AliAODHeader*>(InputEvent()->GetHeader()));
daa81fe5 342 }
5a922844 343 if ((handler->NeedsTracksBranchReplication() || merging) && (fgAODTracks))
c185e0db 344 {
345 TClonesArray* tracks = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracks();
346 new (fgAODTracks) TClonesArray(*tracks);
347 }
417ab5ac 348 if ((handler->NeedsVerticesBranchReplication() || merging) && (fgAODVertices))
c185e0db 349 {
350 TClonesArray* vertices = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetVertices();
351 new (fgAODVertices) TClonesArray(*vertices);
352 }
353 if ((handler->NeedsV0sBranchReplication()) && (fgAODV0s))
354 {
113bc2bd 355 TClonesArray* v0s = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetV0s();
356 new (fgAODV0s) TClonesArray(*v0s);
c185e0db 357 }
358 if ((handler->NeedsTrackletsBranchReplication()) && (fgAODTracklets))
359 {
61d5496b 360 *fgAODTracklets = *(dynamic_cast<AliAODEvent*>(InputEvent()))->GetTracklets();
c185e0db 361 }
362 if ((handler->NeedsPMDClustersBranchReplication()) && (fgAODPMDClusters))
363 {
113bc2bd 364 TClonesArray* pmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetPmdClusters();
365 new (fgAODPMDClusters) TClonesArray(*pmdClusters);
c185e0db 366 }
5a922844 367 if ((handler->NeedsJetsBranchReplication() || merging) && (fgAODJets))
c185e0db 368 {
113bc2bd 369 TClonesArray* jets = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetJets();
370 new (fgAODJets) TClonesArray(*jets);
c185e0db 371 }
372 if ((handler->NeedsFMDClustersBranchReplication()) && (fgAODFMDClusters))
373 {
113bc2bd 374 TClonesArray* fmdClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetFmdClusters();
375 new (fgAODFMDClusters) TClonesArray(*fmdClusters);
c185e0db 376 }
5a922844 377 if ((handler->NeedsCaloClustersBranchReplication() || merging) && (fgAODCaloClusters))
c185e0db 378 {
113bc2bd 379 TClonesArray* caloClusters = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetCaloClusters();
380 new (fgAODCaloClusters) TClonesArray(*caloClusters);
381 }
382
383 if ((handler->NeedsMCParticlesBranchReplication() || merging) && (fgAODMCParticles))
384 {
385 TClonesArray* mcParticles = (TClonesArray*) ((dynamic_cast<AliAODEvent*>(InputEvent()))->FindListObject("mcparticles"));
386 new (fgAODMCParticles) TClonesArray(*mcParticles);
c185e0db 387 }
866d8d78 388
389 if ((handler->NeedsDimuonsBranchReplication() || merging) && (fgAODDimuons))
390 {
391 TClonesArray* dimuons = (dynamic_cast<AliAODEvent*>(InputEvent()))->GetDimuons();
392 new (fgAODDimuons) TClonesArray(*dimuons);
393 }
394
5a922844 395 // Additional merging if needed
396 if (merging) {
113bc2bd 397 // mcParticles
398 TClonesArray* mcparticles = (TClonesArray*) ((aodH->GetEventToMerge())->FindListObject("mcparticles"));
399 Int_t npart = mcparticles->GetEntries();
400 Int_t nc = fgAODMCParticles->GetEntries();
401 Int_t nc0 = nc;
402
403 for (Int_t i = 0; i < npart; i++) {
404 AliAODMCParticle* particle = (AliAODMCParticle*) mcparticles->At(i);
c8de791b 405 new((*fgAODMCParticles)[nc++]) AliAODMCParticle(*particle);
113bc2bd 406 }
407
5a922844 408 // tracks
409 TClonesArray* tracks = aodH->GetEventToMerge()->GetTracks();
410 Int_t ntr = tracks->GetEntries();
113bc2bd 411 nc = fgAODTracks->GetEntries();
5a922844 412 for (Int_t i = 0; i < ntr; i++) {
413 AliAODTrack* track = (AliAODTrack*) tracks->At(i);
414 AliAODTrack* newtrack = new((*fgAODTracks)[nc++]) AliAODTrack(*track);
c8de791b 415
113bc2bd 416 newtrack->SetLabel(newtrack->GetLabel() + nc0);
5a922844 417 }
c8de791b 418
419 for (Int_t i = 0; i < nc; i++)
420 {
421 AliAODTrack* track = (AliAODTrack*) fgAODTracks->At(i);
422 track->ResetBit(kIsReferenced);
423 track->SetUniqueID(0);
424 }
425
426
5a922844 427 // clusters
428 TClonesArray* clusters = aodH->GetEventToMerge()->GetCaloClusters();
429 Int_t ncl = clusters->GetEntries();
430 nc = fgAODCaloClusters->GetEntries();
431 for (Int_t i = 0; i < ncl; i++) {
432 AliAODCaloCluster* cluster = (AliAODCaloCluster*) clusters->At(i);
c8de791b 433 new((*fgAODCaloClusters)[nc++]) AliAODCaloCluster(*cluster);
5a922844 434 }
435 // cells
436 AliAODCaloCells* cellsA = aodH->GetEventToMerge()->GetEMCALCells();
437 Int_t ncells = cellsA->GetNumberOfCells();
438 nc = fgAODEmcalCells->GetNumberOfCells();
439
440 for (Int_t i = 0; i < ncells; i++) {
441 Int_t cn = cellsA->GetCellNumber(i);
442 Int_t pos = fgAODEmcalCells->GetCellPosition(cn);
443 if (pos >= 0) {
444 Double_t amp = cellsA->GetAmplitude(i) + fgAODEmcalCells->GetAmplitude(pos);
445 fgAODEmcalCells->SetCell(pos, cn, amp);
446 } else {
447 Double_t amp = cellsA->GetAmplitude(i);
448 fgAODEmcalCells->SetCell(nc++, cn, amp);
449 fgAODEmcalCells->Sort();
450 }
451 }
113bc2bd 452
453
454 } // merging
c185e0db 455
5a922844 456 handler->SetAODIsReplicated();
3f2431c4 457 }
458 }
459
4d0a82af 460// Call the user analysis
bf666461 461 if (!fSelectCollisions || isSelected)
90a9a634 462 UserExec(option);
463
464// Added protection in case the derived task is not an AOD producer.
60a04972 465 AliAnalysisDataSlot *out0 = GetOutputSlot(0);
466 if (out0 && out0->IsConnected()) PostData(0, fTreeA);
5232d0de 467}
468
4d0a82af 469const char* AliAnalysisTaskSE::CurrentFileName()
470{
471// Returns the current file name
259b7a8a 472 if( fInputHandler )
473 return fInputHandler->GetTree()->GetCurrentFile()->GetName();
474 else if( fMCEvent )
475 return ((AliMCEventHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()))->TreeK()->GetCurrentFile()->GetName();
8803dcb1 476 else return "";
4d0a82af 477}
5232d0de 478
3cee83d7 479void AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char *fname)
164e94ff 480{
481 // Add a new branch to the aod tree
482 AliAODHandler* handler = (AliAODHandler*)
483 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
484 if (handler) {
3cee83d7 485 handler->AddBranch(cname, addobj, fname);
164e94ff 486 }
487}
3cee83d7 488
489Bool_t AliAnalysisTaskSE::IsStandardAOD() const
490{
491// Check if the output AOD handler is configured for standard or delta AOD.
492// Users should first check that AODEvent() returns non-null.
493 AliAODHandler* handler = (AliAODHandler*)
494 ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
495 if (!handler) {
496 Error("IsStandardAOD", "No AOD handler. Please use AODEvent() to check this first");
497 return kTRUE;
498 }
499 return handler->IsStandard();
500}
1ec2c8dc 501
502Bool_t AliAnalysisTaskSE::Notify()
503{
9a587f77 504 return (UserNotify());
1ec2c8dc 505}
506
507