1 /*************************************************************************
2 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 ///////////////////////////////////////////////////////////////////////////
18 // Analysis task for creating a reduced data tree //
20 ///////////////////////////////////////////////////////////////////////////
27 #include <AliCFContainer.h>
28 #include <AliInputEventHandler.h>
29 #include <AliESDInputHandler.h>
30 #include <AliAODInputHandler.h>
31 #include <AliAnalysisManager.h>
32 #include <AliVEvent.h>
33 #include <AliESDEvent.h>
34 #include <AliAODEvent.h>
35 #include <AliESDHeader.h>
36 #include <AliAODHeader.h>
37 #include <AliAODTrack.h>
38 //#include <AliAODForwardMult.h>
39 //#include <AliForwardUtil.h>
40 #include <AliTriggerAnalysis.h>
41 #include <AliESDtrackCuts.h>
44 #include <AliESDv0Cuts.h>
45 #include <AliESDv0KineCuts.h>
46 #include <AliESDFMD.h>
47 #include <AliVCluster.h>
48 #include <AliAODTracklets.h>
49 #include <AliMultiplicity.h>
50 #include <AliPIDResponse.h>
51 #include "AliDielectron.h"
52 #include "AliDielectronHistos.h"
53 #include "AliDielectronMC.h"
54 #include "AliDielectronVarManager.h"
55 #include "AliFlowTrackCuts.h"
56 #include "AliFlowBayesianPID.h"
58 #include "AliReducedEvent.h"
59 #include "AliAnalysisTaskReducedTree.h"
65 ClassImp(AliAnalysisTaskReducedTree)
68 //_________________________________________________________________________________
69 AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree() :
73 fSelectPhysics(kFALSE),
74 fTriggerMask(AliVEvent::kAny),
75 fRejectPileup(kFALSE),
76 fFillTrackInfo(kTRUE),
77 fFillDielectronInfo(kTRUE),
79 fFillGammaConversions(kTRUE),
83 fFillCaloClusterInfo(kTRUE),
84 fFillFMDSectorInfo(kFALSE),
85 fFillFMDChannelInfo(kFALSE),
86 //fFillCorrectedFMDInfo(kTRUE),
87 fFillFriendInfo(kTRUE),
90 fFlowTrackFilter(0x0),
95 fLambdaProtonCuts(0x0),
97 fGammaElectronCuts(0x0),
106 fFriendTreeFile(0x0),
109 fReducedEventFriend(0x0)
116 //_________________________________________________________________________________
117 AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree(const char *name) :
118 AliAnalysisTaskSE(name),
121 fSelectPhysics(kFALSE),
122 fTriggerMask(AliVEvent::kAny),
123 fRejectPileup(kFALSE),
124 fFillTrackInfo(kTRUE),
125 fFillDielectronInfo(kTRUE),
127 fFillGammaConversions(kTRUE),
131 fFillCaloClusterInfo(kTRUE),
132 fFillFMDSectorInfo(kFALSE),
133 fFillFMDChannelInfo(kFALSE),
134 //fFillCorrectedFMDInfo(kTRUE),
135 fFillFriendInfo(kTRUE),
138 fFlowTrackFilter(0x0),
143 fLambdaProtonCuts(0x0),
144 fLambdaPionCuts(0x0),
145 fGammaElectronCuts(0x0),
154 fFriendTreeFile(0x0),
157 fReducedEventFriend(0x0)
162 fK0sMassRange[0] = 0.4; fK0sMassRange[1] = 0.6;
163 fLambdaMassRange[0] = 1.08; fLambdaMassRange[1] = 1.15;
164 fGammaMassRange[0] = 0.0; fGammaMassRange[1] = 0.1;
166 DefineInput(0,TChain::Class());
167 //DefineInput(2,AliAODForwardMult::Class());
168 DefineOutput(1, TList::Class()); // QA histograms
169 DefineOutput(2, TTree::Class()); // reduced information tree
170 //if(fFillFriendInfo) DefineOutput(3, TTree::Class()); // reduced information tree with friends
171 //DefineOutput(2, TTree::Class()); // reduced information tree with friends
172 //DefineOutput(2, TTree::Class()); // reduced information tree
174 fListHistos.SetName("QAhistograms");
175 fListDielectron.SetOwner();
176 fListHistos.SetOwner(kFALSE);
180 //_________________________________________________________________________________
181 void AliAnalysisTaskReducedTree::UserCreateOutputObjects()
184 // Add all histogram manager histogram lists to the output TList
187 if (!fListHistos.IsEmpty() || fTree || fFriendTree) return; //already initialised
189 TIter nextDie(&fListDielectron);
190 AliDielectron *die=0;
191 while ( (die=static_cast<AliDielectron*>(nextDie())) ){
193 if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
195 if(fV0Histos) fListHistos.Add(const_cast<THashList*>(fV0Histos->GetHistogramList()));
197 if(fFillFriendInfo) {
198 fFriendTree = new TTree("DstFriendTree","Reduced ESD information");
199 fReducedEventFriend = new AliReducedEventFriend();
200 fFriendTree->Branch("Event",&fReducedEventFriend,16000,99);
203 //fTreeFile = new TFile("dstTree.root", "RECREATE");
205 fTree = new TTree("DstTree","Reduced ESD information");
206 fReducedEvent = new AliReducedEvent("DstEvent");
207 fTree->Branch("Event",&fReducedEvent,16000,99);
209 PostData(1, &fListHistos);
211 //if(fFillFriendInfo) PostData(3, fFriendTree);
212 //PostData(2, fFriendTree);
213 //PostData(1, fTree);
216 //_________________________________________________________________________________
217 void AliAnalysisTaskReducedTree::UserExec(Option_t *)
220 // Main loop. Called for every event
222 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
223 Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
224 Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
226 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
227 if (!inputHandler) return;
229 if ( inputHandler->GetPIDResponse() ){
230 AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
232 AliFatal("This task needs the PID response attached to the input event handler!");
235 // Was event selected ?
236 UInt_t isSelected = AliVEvent::kAny;
237 if(fSelectPhysics && inputHandler){
238 if((isESD && inputHandler->GetEventSelection()) || isAOD){
239 isSelected = inputHandler->IsEventSelected();
240 isSelected&=fTriggerMask;
248 cout<<"get AOD"<<endl;
250 AliAODEvent* aodEvent = AliForwardUtil::GetAODEvent(this);
251 if (!aodEvent) return;
252 cout<<"got AOD"<<endl;
254 TObject* obj = aodEvent->FindListObject("Forward");
256 cout<<"got AOD forward"<<endl;
258 AliAODForwardMult* aodForward = static_cast<AliAODForwardMult*>(obj);
260 //if (!aodForward->CheckEvent(mask,ipZmin,ipZmax,cMin,cMax)) return 0;
263 const TH2D& d2Ndetadphi = aodForward->GetHistogram();
266 cout<<d2Ndetadphi.GetXaxis()->GetNbins()<<endl;
270 // AliAODEvent* aodEvent;
272 // AliAODForwardMult* aodForward=NULL;
274 // if(fFillCorrectedFMDInfo){
275 // aodEvent = AliForwardUtil::GetAODEvent(this);
276 // if (!aodEvent) return;
278 // obj = aodEvent->FindListObject("Forward");
279 // if (!obj) return;}
281 // aodForward = static_cast<AliAODForwardMult*>(obj);
283 // //if (!aodForward->CheckE vent(fTriggerMask,ipZmin,ipZmax,cMin,cMax)) return 0;
285 // const TH2D& d2Ndetadphi = aodForward->GetHistogram();
288 // fill event histograms before event filter
289 Double_t values[AliDielectronVarManager::kNMaxValues]={0};
290 AliDielectronVarManager::Fill(InputEvent(),values);
292 TIter nextDie(&fListDielectron);
293 AliDielectron *die=0;
294 while ( (die=static_cast<AliDielectron*>(nextDie())) ){
295 AliDielectronHistos *h=die->GetHistoManager();
297 if (h->GetHistogramList()->FindObject("Event_noCuts"))
298 h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,values);
305 if (!fEventFilter->IsSelected(InputEvent())) return;
310 if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
314 Double_t bz = InputEvent()->GetMagneticField();
315 AliKFParticle::SetField( bz );
317 //Process event in all AliDielectron instances
318 fReducedEvent->ClearEvent();
319 if(fFillFriendInfo) fReducedEventFriend->ClearEvent();
321 //if(fFillCorrectedFMDInfo) FillCorrectedFMDInfo(d2Ndetadphi); //Fill corrected FMD info
322 if(fFillV0Info) FillV0PairInfo();
325 if(fFillDielectronInfo) {
326 while((die=static_cast<AliDielectron*>(nextDie()))){
327 die->Process(InputEvent());
328 FillDielectronPairInfo(die, idie);
334 if(fFillTrackInfo) FillTrackInfo();
335 if(fFillFriendInfo) FillFriendEventInfo(); // Q-vector calculation
338 if(fFillFriendInfo) fFriendTree->Fill();
340 // if there are candidate pairs, add the information to the reduced tree
341 PostData(1, &fListHistos);
343 //if(fFillFriendInfo) PostData(3, fFriendTree);
344 //PostData(2, fFriendTree);
345 //PostData(2, fTree);
349 //_________________________________________________________________________________
350 void AliAnalysisTaskReducedTree::FillEventInfo()
353 // fill reduced event information
355 AliVEvent* event = InputEvent();
356 // Was event selected ?
357 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
358 Bool_t isESD = (event->IsA()==AliESDEvent::Class());
359 Bool_t isAOD = (event->IsA()==AliAODEvent::Class());
361 AliESDEvent* esdEvent = 0x0;
362 if(isESD) esdEvent = static_cast<AliESDEvent*>(event);
363 AliAODEvent* aodEvent = 0x0;
364 if(isAOD) aodEvent = static_cast<AliAODEvent*>(event);
366 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
367 UInt_t isSelected = AliVEvent::kAny;
369 if((isESD && inputHandler->GetEventSelection()) || isAOD){
370 isSelected = inputHandler->IsEventSelected();
371 isSelected&=fTriggerMask;
374 Double_t values[AliDielectronVarManager::kNMaxValues];
375 AliDielectronVarManager::Fill(event, values);
377 fReducedEvent->fRunNo = event->GetRunNumber();
378 fReducedEvent->fBC = event->GetBunchCrossNumber();
379 fReducedEvent->fEventType = event->GetEventType();
380 fReducedEvent->fTriggerMask = event->GetTriggerMask();
381 fReducedEvent->fIsPhysicsSelection = (isSelected!=0 ? kTRUE : kFALSE);
382 fReducedEvent->fIsSPDPileup = event->IsPileupFromSPD(3,0.8,3.,2.,5.);
383 fReducedEvent->fIsSPDPileupMultBins = event->IsPileupFromSPDInMultBins();
384 AliVVertex* eventVtx = 0x0;
385 if(isESD) eventVtx = const_cast<AliESDVertex*>(esdEvent->GetPrimaryVertexTracks());
386 if(isAOD) eventVtx = const_cast<AliAODVertex*>(aodEvent->GetPrimaryVertex());
388 fReducedEvent->fVtx[0] = (isESD ? ((AliESDVertex*)eventVtx)->GetXv() : ((AliAODVertex*)eventVtx)->GetX());
389 fReducedEvent->fVtx[1] = (isESD ? ((AliESDVertex*)eventVtx)->GetYv() : ((AliAODVertex*)eventVtx)->GetY());
390 fReducedEvent->fVtx[2] = (isESD ? ((AliESDVertex*)eventVtx)->GetZv() : ((AliAODVertex*)eventVtx)->GetZ());
391 fReducedEvent->fNVtxContributors = eventVtx->GetNContributors();
394 eventVtx = const_cast<AliESDVertex*>(esdEvent->GetPrimaryVertexTPC());
395 fReducedEvent->fEventNumberInFile = esdEvent->GetEventNumberInFile();
396 fReducedEvent->fL0TriggerInputs = esdEvent->GetHeader()->GetL0TriggerInputs();
397 fReducedEvent->fL1TriggerInputs = esdEvent->GetHeader()->GetL1TriggerInputs();
398 fReducedEvent->fL2TriggerInputs = esdEvent->GetHeader()->GetL2TriggerInputs();
399 fReducedEvent->fIRIntClosestIntMap[0] = esdEvent->GetHeader()->GetIRInt1ClosestInteractionMap();
400 fReducedEvent->fIRIntClosestIntMap[1] = esdEvent->GetHeader()->GetIRInt2ClosestInteractionMap();
402 fReducedEvent->fVtxTPC[0] = ((AliESDVertex*)eventVtx)->GetXv();
403 fReducedEvent->fVtxTPC[1] = ((AliESDVertex*)eventVtx)->GetYv();
404 fReducedEvent->fVtxTPC[2] = ((AliESDVertex*)eventVtx)->GetZv();
405 fReducedEvent->fNVtxTPCContributors = eventVtx->GetNContributors();
407 fReducedEvent->fTimeStamp = esdEvent->GetTimeStamp();
408 fReducedEvent->fNpileupSPD = esdEvent->GetNumberOfPileupVerticesSPD();
409 fReducedEvent->fNpileupTracks = esdEvent->GetNumberOfPileupVerticesTracks();
410 fReducedEvent->fNPMDtracks = esdEvent->GetNumberOfPmdTracks();
411 fReducedEvent->fNTRDtracks = esdEvent->GetNumberOfTrdTracks();
412 fReducedEvent->fNTRDtracklets = esdEvent->GetNumberOfTrdTracklets();
414 AliESDZDC* zdc = esdEvent->GetESDZDC();
416 for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN1TowerEnergy()[i];
417 for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN2TowerEnergy()[i-5];
418 for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZP1TowerEnergy()[i];
419 for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZP2TowerEnergy()[i-5];
423 fReducedEvent->fIRIntClosestIntMap[0] = aodEvent->GetHeader()->GetIRInt1ClosestInteractionMap();
424 fReducedEvent->fIRIntClosestIntMap[1] = aodEvent->GetHeader()->GetIRInt2ClosestInteractionMap();
425 fReducedEvent->fEventNumberInFile = aodEvent->GetHeader()->GetEventNumberESDFile();
426 fReducedEvent->fL0TriggerInputs = aodEvent->GetHeader()->GetL0TriggerInputs();
427 fReducedEvent->fL1TriggerInputs = aodEvent->GetHeader()->GetL1TriggerInputs();
428 fReducedEvent->fL2TriggerInputs = aodEvent->GetHeader()->GetL2TriggerInputs();
429 fReducedEvent->fTimeStamp = 0;
430 fReducedEvent->fNpileupSPD = aodEvent->GetNumberOfPileupVerticesSPD();
431 fReducedEvent->fNpileupTracks = aodEvent->GetNumberOfPileupVerticesTracks();
432 fReducedEvent->fNPMDtracks = aodEvent->GetNPmdClusters();
433 fReducedEvent->fNTRDtracks = 0;
434 fReducedEvent->fNTRDtracklets = 0;
436 AliAODZDC* zdc = aodEvent->GetZDCData();
438 for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNATowerEnergy()[i];
439 for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNCTowerEnergy()[i-5];
440 for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZPATowerEnergy()[i];
441 for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZPCTowerEnergy()[i-5];
445 // Fill TZERO information
447 const AliESDTZERO* tzero = esdEvent->GetESDTZERO();
449 fReducedEvent->fT0start = tzero->GetT0();
450 fReducedEvent->fT0zVertex = tzero->GetT0zVertex();
451 for(Int_t i = 0;i<24;i++)
452 fReducedEvent->fT0amplitude[i] = tzero->GetT0amplitude()[i];
453 for(Int_t i = 0;i<3;i++)
454 fReducedEvent->fT0TOF[i] = tzero->GetT0TOF()[i];
455 for(Int_t i = 0;i<3;i++)
456 fReducedEvent->fT0TOFbest[i] = tzero->GetT0TOFbest()[i];
457 fReducedEvent->fT0pileup = tzero->GetPileupFlag();
458 fReducedEvent->fT0sattelite = tzero->GetSatellite();
462 AliAODTZERO* tzero = aodEvent->GetTZEROData();
464 fReducedEvent->fT0start = -999.; // not available
465 fReducedEvent->fT0zVertex = tzero->GetT0zVertex();
466 for(Int_t i = 0;i<26;i++)
467 fReducedEvent->fT0amplitude[i] = tzero->GetAmp(i);
468 for(Int_t i = 0;i<3;i++)
469 fReducedEvent->fT0TOF[i] = tzero->GetT0TOF()[i];
470 for(Int_t i = 0;i<3;i++)
471 fReducedEvent->fT0TOFbest[i] = tzero->GetT0TOFbest()[i];
472 fReducedEvent->fT0pileup = tzero->GetPileupFlag();
473 fReducedEvent->fT0sattelite = tzero->GetSatellite();
477 if(fFillFMDChannelInfo&&isESD) fReducedEvent->fIsFMDReduced = kFALSE;
478 if((fFillFMDSectorInfo||fFillFMDChannelInfo)&&isESD) FillFMDInfo();
480 AliCentrality *centrality = event->GetCentrality();
482 fReducedEvent->fCentrality[0] = centrality->GetCentralityPercentile("V0M");
483 fReducedEvent->fCentrality[1] = centrality->GetCentralityPercentile("CL1");
484 fReducedEvent->fCentrality[2] = centrality->GetCentralityPercentile("TRK");
485 fReducedEvent->fCentrality[3] = centrality->GetCentralityPercentile("ZEMvsZDC");
486 fReducedEvent->fCentQuality = centrality->GetQuality();
489 //cout << "event vtxZ/cent: " << fReducedEvent->fVtx[2] << "/" << fReducedEvent->fCentrality[0] << endl;
491 fReducedEvent->fNtracks[0] = event->GetNumberOfTracks();
492 fReducedEvent->fSPDntracklets = GetSPDTrackletMultiplicity(event, -1.0, 1.0);
493 for(Int_t ieta=0; ieta<32; ++ieta)
494 fReducedEvent->fSPDntrackletsEta[ieta] = GetSPDTrackletMultiplicity(event, -1.6+0.1*ieta, -1.6+0.1*(ieta+1));
496 AliVVZERO* vzero = event->GetVZEROData();
497 for(Int_t i=0;i<64;++i)
498 fReducedEvent->fVZEROMult[i] = vzero->GetMultiplicity(i);
500 // EMCAL/PHOS clusters
501 if(fFillCaloClusterInfo) FillCaloClusters();
503 // TODO FMD multiplicities
508 //_________________________________________________________________________________
509 void AliAnalysisTaskReducedTree::FillCaloClusters() {
511 // Fill info about the calorimeter clusters
513 AliVEvent* event = InputEvent();
514 Int_t nclusters = event->GetNumberOfCaloClusters();
516 fReducedEvent->fNCaloClusters = 0;
517 for(Int_t iclus=0; iclus<nclusters; ++iclus) {
518 AliVCluster* cluster = event->GetCaloCluster(iclus);
520 TClonesArray& clusters = *(fReducedEvent->fCaloClusters);
521 AliReducedCaloCluster *reducedCluster=new(clusters[fReducedEvent->fNCaloClusters]) AliReducedCaloCluster();
523 reducedCluster->fType = (cluster->IsEMCAL() ? AliReducedCaloCluster::kEMCAL : AliReducedCaloCluster::kPHOS);
524 reducedCluster->fEnergy = cluster->E();
525 reducedCluster->fTrackDx = cluster->GetTrackDx();
526 reducedCluster->fTrackDz = cluster->GetTrackDz();
527 reducedCluster->fM20 = cluster->GetM20();
528 reducedCluster->fM02 = cluster->GetM02();
529 reducedCluster->fDispersion = cluster->GetDispersion();
530 fReducedEvent->fNCaloClusters += 1;
531 } // end loop over clusters
535 //_________________________________________________________________________________
536 void AliAnalysisTaskReducedTree::FillFriendEventInfo() {
538 // Fill event info into the friend tree
540 // Add here calculated Q-vector components from all detectors
541 for(Int_t idet=0; idet<AliReducedEventFriend::kNdetectors; ++idet) {
542 fReducedEvent->GetQvector(fReducedEventFriend->fQvector[idet], idet);
543 for(Int_t ih=0; ih<fgkNMaxHarmonics; ++ih)
544 fReducedEventFriend->fEventPlaneStatus[idet][ih] = AliReducedEventFriend::kRaw;
549 //_________________________________________________________________________________
550 void AliAnalysisTaskReducedTree::FillFMDInfo()
553 // fill reduced FMD information
555 AliVEvent* event = InputEvent();
556 Bool_t isESD = (event->IsA()==AliESDEvent::Class());
560 AliESDEvent* esdEvent = 0x0;
561 if(isESD) esdEvent = static_cast<AliESDEvent*>(event);
563 AliESDFMD* esdFmd = esdEvent->GetFMDData();
564 //const AliFMDFloatMap multMap = esdFmd->MultiplicityMap();
565 //const AliFMDFloatMap etaMap = esdFmd->EtaMap();
582 for(UShort_t det = 1; det <= maxDet; ++det) {
583 (det == 1 ? maxRing=1 : maxRing=2);
584 for(UShort_t ir = 0; ir < maxRing; ++ir) {
585 ring = (ir == 0 ? 'I' : 'O');
586 (ir == 0 ? maxSector=20 : maxSector=40);
587 (ir == 0 ? maxStrip=512 : maxStrip=256);
589 for(UShort_t sec = 0; sec < maxSector; ++sec) {
590 phi = esdFmd->Phi(det, ring, sec, 0)/180.*TMath::Pi();
591 phiBin = Int_t (phi/2/TMath::Pi()*maxSector);
593 for(UShort_t str = 0; str < maxStrip; ++str) {
595 m = esdFmd->Multiplicity(det, ring, sec, str);
596 //cout << "det/ir/sec/str/m :: " << det << "/" << ir << "/" << sec << "/" << str << "/" << m << endl;
597 if(fFillFMDChannelInfo)
598 if(m<1.e-6) continue;
599 if(m == AliESDFMD::kInvalidMult) m=0;
604 if(fFillFMDChannelInfo){
606 m = UShort_t(m*4369+0.5);
607 TClonesArray& fmd = *(fReducedEvent->GetFMD(fmdDet));
608 AliReducedFMD *reducedFMD=new(fmd[nFMD]) AliReducedFMD();
609 fReducedEvent->fNFMDchannels[fmdDet] += 1;
610 reducedFMD->fMultiplicity = m;
611 //reducedFMD->fEta = esdFmd->Eta(det, ring, 0, str);
612 reducedFMD->fId = id;
614 } // end loop over strips
616 if(fFillFMDSectorInfo) {
617 TClonesArray& fmd = *(fReducedEvent->GetFMD(fmdDet));
618 AliReducedFMD *reducedFMD=new(fmd[phiBin]) AliReducedFMD();
619 reducedFMD->fMultiplicity = fmdMult;
620 fReducedEvent->fNFMDchannels[fmdDet] += 1;
621 //cout<<sec<<" "<<fmdMult<<endl;
624 } // end loop over sectors
626 fReducedEvent->fFMDtotalMult[fmdDet] = msum;
630 } // end loop over rings
631 } // end loop over detectors
634 ////_________________________________________________________________________________
635 //void AliAnalysisTaskReducedTree::FillCorrectedFMDInfo(const TH2D& fmdhist)
639 //Int_t nEta = fmdhist.GetXaxis()->GetNbins();
640 //Int_t nPhi = fmdhist.GetYaxis()->GetNbins();
641 ////Int_t nBins= fmdhist.GetNbins();
648 ////fReducedEvent->fNCorFmdChannels = 0;
649 //for (Int_t e = 1; e <= nEta; e++) {
650 // eta = fmdhist.GetXaxis()->GetBinCenter(e);
651 // for (Int_t p = 1; p <= nPhi; p++) {
652 // phi = fmdhist.GetYaxis()->GetBinCenter(p);
653 // mult = fmdhist.GetBinContent(e, p);
654 // //TClonesArray& Corfmd = *(fReducedEvent->fCorFMD);
655 // //AliReducedFMD *reducedCorFMD=new(Corfmd[nFMD]) AliReducedCorFMD();
656 // std::cout<<mult<<" "<<eta<<" "<<phi<<std::endl;
659 // //fReducedEvent->fNCorFmdChannels += 1;
661 ////reducedFMD->fCorMultiplicity = mult;
662 ////reducedFMD->fCorEta = eta;
663 ////reducedFMD->fCorPhi = phi;
672 //_________________________________________________________________________________
673 void AliAnalysisTaskReducedTree::FillTrackInfo()
676 // fill reduced track information
678 AliVEvent* event = InputEvent();
679 Bool_t isESD = (event->IsA()==AliESDEvent::Class());
680 Bool_t isAOD = (event->IsA()==AliAODEvent::Class());
682 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
683 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
684 AliPIDResponse* pidResponse = inputHandler->GetPIDResponse();
686 // find all the tracks which belong to a V0 stored in the reduced event
687 UShort_t trackIdsV0[4][20000]={{0}};
688 UShort_t trackIdsPureV0[4][20000]={{0}};
689 Int_t nV0LegsTagged[4] = {0}; Int_t nPureV0LegsTagged[4] = {0};
690 Bool_t leg1Found[4]; Bool_t leg2Found[4];
691 for(Int_t iv0=0;iv0<fReducedEvent->fNV0candidates[1];++iv0) {
692 AliReducedPair* pair = fReducedEvent->GetV0Pair(iv0);
694 Int_t pairId = 0; Bool_t isPureV0 = kFALSE;
695 if(pair->fCandidateId==AliReducedPair::kGammaConv) {
697 if(pair->IsPureV0Gamma()) isPureV0 = kTRUE;
699 if(pair->fCandidateId==AliReducedPair::kK0sToPiPi) {
701 if(pair->IsPureV0K0s()) isPureV0 = kTRUE;
703 if(pair->fCandidateId==AliReducedPair::kLambda0ToPPi) {
705 if(pair->IsPureV0Lambda()) isPureV0 = kTRUE;
707 if(pair->fCandidateId==AliReducedPair::kALambda0ToPPi) {
709 if(pair->IsPureV0ALambda()) isPureV0 = kTRUE;
712 leg1Found[pairId] = kFALSE; leg2Found[pairId] = kFALSE;
713 for(Int_t it=0;it<nV0LegsTagged[pairId];++it) {
714 if(trackIdsV0[pairId][it]==pair->fLegIds[0]) leg1Found[pairId]=kTRUE;
715 if(trackIdsV0[pairId][it]==pair->fLegIds[1]) leg2Found[pairId]=kTRUE;
717 // if the legs of this V0 were not already stored then add them now to the list
718 if(!leg1Found[pairId]) {trackIdsV0[pairId][nV0LegsTagged[pairId]] = pair->fLegIds[0]; ++nV0LegsTagged[pairId];}
719 if(!leg2Found[pairId]) {trackIdsV0[pairId][nV0LegsTagged[pairId]] = pair->fLegIds[1]; ++nV0LegsTagged[pairId];}
722 leg1Found[pairId] = kFALSE; leg2Found[pairId] = kFALSE;
723 for(Int_t it=0;it<nPureV0LegsTagged[pairId];++it) {
724 if(trackIdsPureV0[pairId][it]==pair->fLegIds[0]) leg1Found[pairId]=kTRUE;
725 if(trackIdsPureV0[pairId][it]==pair->fLegIds[1]) leg2Found[pairId]=kTRUE;
727 // if the legs of this pure V0 were not already stored then add them now to the list
728 if(!leg1Found[pairId]) {trackIdsPureV0[pairId][nPureV0LegsTagged[pairId]] = pair->fLegIds[0]; ++nPureV0LegsTagged[pairId];}
729 if(!leg2Found[pairId]) {trackIdsPureV0[pairId][nPureV0LegsTagged[pairId]] = pair->fLegIds[1]; ++nPureV0LegsTagged[pairId];}
733 // find all the tracks which belong to a stored dielectron pair
734 UShort_t trackIdsDiele[20000]={0};
735 Int_t nDieleLegsTagged = 0;
736 for(Int_t idie=0;idie<fReducedEvent->NDielectrons();++idie) {
737 AliReducedPair* pair = fReducedEvent->GetDielectronPair(idie);
738 leg1Found[0]=kFALSE; leg2Found[0]=kFALSE;
739 for(Int_t it=0; it<nDieleLegsTagged; ++it) {
740 if(trackIdsDiele[it]==pair->fLegIds[0]) leg1Found[0]=kTRUE;
741 if(trackIdsDiele[it]==pair->fLegIds[1]) leg2Found[0]=kTRUE;
743 // if the legs of this dielectron were not already stored then add them now to the list
744 if(!leg1Found[0]) {trackIdsDiele[nDieleLegsTagged] = pair->fLegIds[0]; ++nDieleLegsTagged;}
745 if(!leg2Found[0]) {trackIdsDiele[nDieleLegsTagged] = pair->fLegIds[1]; ++nDieleLegsTagged;}
748 AliESDtrack* esdTrack=0;
749 AliAODTrack* aodTrack=0;
750 Int_t ntracks=event->GetNumberOfTracks();
752 Bool_t usedForV0[4] = {kFALSE};
753 Bool_t usedForPureV0[4] = {kFALSE};
754 Bool_t usedForV0Or = kFALSE;
755 Bool_t usedForDielectron = kFALSE;
756 for(Int_t itrack=0; itrack<ntracks; ++itrack){
757 AliVParticle *particle=event->GetTrack(itrack);
759 esdTrack=static_cast<AliESDtrack*>(particle);
760 trackId = esdTrack->GetID();
763 aodTrack=static_cast<AliAODTrack*>(particle);
764 trackId = aodTrack->GetID();
766 // check whether this track belongs to a V0 stored in the reduced event
767 usedForV0Or = kFALSE;
768 for(Int_t i=0; i<4; ++i) {
769 usedForV0[i] = kFALSE;
770 for(Int_t ii=0; ii<nV0LegsTagged[i]; ++ii) {
771 if(UShort_t(trackId)==trackIdsV0[i][ii]) {
772 usedForV0[i] = kTRUE;
773 //cout << "track " << trackId << " used for V0 type " << i << endl;
777 usedForV0Or = usedForV0Or || usedForV0[i];
778 usedForPureV0[i] = kFALSE;
779 for(Int_t ii=0; ii<nPureV0LegsTagged[i]; ++ii) {
780 if(UShort_t(trackId)==trackIdsPureV0[i][ii]) {
781 usedForPureV0[i] = kTRUE;
782 //cout << "track " << trackId << " used for pure V0 type " << i << endl;
787 // check whether this track belongs to a dielectron stored in the reduced event
788 usedForDielectron = kFALSE;
789 for(Int_t ii=0; ii<nDieleLegsTagged; ++ii) {
790 if(UShort_t(trackId)==trackIdsDiele[ii]) {
791 usedForDielectron = kTRUE;
796 ULong_t status = (isESD ? esdTrack->GetStatus() : aodTrack->GetStatus());
797 //cout << "TRACK" << endl;
798 for(Int_t ibit=0; ibit<32; ++ibit) {
799 if(status & (ULong_t(1)<<ibit)) {
800 //cout << "bit " << ibit << endl;
801 fReducedEvent->fNtracksPerTrackingFlag[ibit] += 1;
806 if(!usedForV0Or && !usedForDielectron && fTrackFilter && !fTrackFilter->IsSelected(particle)) continue;
807 //cout << "storing track " << trackId << endl;
809 TClonesArray& tracks = *(fReducedEvent->fTracks);
810 AliReducedTrack *reducedParticle=new(tracks[fReducedEvent->fNtracks[1]]) AliReducedTrack();
812 Double_t values[AliDielectronVarManager::kNMaxValues];
813 AliDielectronVarManager::Fill(particle, values);
814 reducedParticle->fStatus = status;//(ULong_t)values[AliDielectronVarManager::kTrackStatus];
815 reducedParticle->fGlobalPhi = values[AliDielectronVarManager::kPhi];
816 reducedParticle->fGlobalPt = values[AliDielectronVarManager::kPt]*values[AliDielectronVarManager::kCharge];
817 reducedParticle->fGlobalEta = values[AliDielectronVarManager::kEta];
818 reducedParticle->fMomentumInner = values[AliDielectronVarManager::kPIn];
819 reducedParticle->fDCA[0] = values[AliDielectronVarManager::kImpactParXY];
820 reducedParticle->fDCA[1] = values[AliDielectronVarManager::kImpactParZ];
821 reducedParticle->fTrackLength = values[AliDielectronVarManager::kTrackLength];
823 reducedParticle->fITSclusterMap = (UChar_t)values[AliDielectronVarManager::kITSclusterMap];
824 reducedParticle->fITSsignal = values[AliDielectronVarManager::kITSsignal];
825 reducedParticle->fITSnSig[0] = values[AliDielectronVarManager::kITSnSigmaEle];
826 reducedParticle->fITSnSig[1] = values[AliDielectronVarManager::kITSnSigmaPio];
827 reducedParticle->fITSnSig[2] = values[AliDielectronVarManager::kITSnSigmaKao];
828 reducedParticle->fITSnSig[3] = values[AliDielectronVarManager::kITSnSigmaPro];
829 reducedParticle->fITSchi2 = values[AliDielectronVarManager::kITSchi2Cl];
831 reducedParticle->fTPCNcls = (UChar_t)values[AliDielectronVarManager::kNclsTPC];
832 reducedParticle->fTPCNclsF = (UChar_t)values[AliDielectronVarManager::kNFclsTPC];
833 reducedParticle->fTPCNclsIter1 = (UChar_t)values[AliDielectronVarManager::kNclsTPCiter1];
834 reducedParticle->fTPCsignal = values[AliDielectronVarManager::kTPCsignal];
835 reducedParticle->fTPCsignalN = values[AliDielectronVarManager::kTPCsignalN];
836 reducedParticle->fTPCnSig[0] = values[AliDielectronVarManager::kTPCnSigmaEle];
837 reducedParticle->fTPCnSig[1] = values[AliDielectronVarManager::kTPCnSigmaPio];
838 reducedParticle->fTPCnSig[2] = values[AliDielectronVarManager::kTPCnSigmaKao];
839 reducedParticle->fTPCnSig[3] = values[AliDielectronVarManager::kTPCnSigmaPro];
840 reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(particle, isAOD);
841 reducedParticle->fTPCchi2 = values[AliDielectronVarManager::kTPCchi2Cl];
843 reducedParticle->fTOFbeta = values[AliDielectronVarManager::kTOFbeta];
844 reducedParticle->fTOFnSig[0] = values[AliDielectronVarManager::kTOFnSigmaEle];
845 reducedParticle->fTOFnSig[1] = values[AliDielectronVarManager::kTOFnSigmaPio];
846 reducedParticle->fTOFnSig[2] = values[AliDielectronVarManager::kTOFnSigmaKao];
847 reducedParticle->fTOFnSig[3] = values[AliDielectronVarManager::kTOFnSigmaPro];
849 Double_t trdProbab[AliPID::kSPECIES]={0.0};
851 if(fFlowTrackFilter) {
852 // switch on the first bit if this particle should be used for the event plane
853 if(fFlowTrackFilter->IsSelected(particle)) reducedParticle->fFlags |= (UShort_t(1)<<0);
855 for(Int_t iV0type=0;iV0type<4;++iV0type) {
856 if(usedForV0[iV0type]) reducedParticle->fFlags |= (UShort_t(1)<<(iV0type+1));
857 if(usedForPureV0[iV0type]) reducedParticle->fFlags |= (UShort_t(1)<<(iV0type+8));
861 //AliESDtrack *track=static_cast<AliESDtrack*>(particle);
862 reducedParticle->fTrackId = (UShort_t)esdTrack->GetID();
863 reducedParticle->fTPCCrossedRows = (UChar_t)esdTrack->GetTPCCrossedRows();
864 //reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(esdTrack);
865 const AliExternalTrackParam* tpcInner = esdTrack->GetInnerParam();
866 reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0);
867 reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0);
868 reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0);
870 reducedParticle->fTOFdeltaBC = esdTrack->GetTOFDeltaBC();
872 reducedParticle->fTRDntracklets[0] = esdTrack->GetTRDntracklets();
873 reducedParticle->fTRDntracklets[1] = esdTrack->GetTRDntrackletsPID();
874 pidResponse->ComputeTRDProbability(esdTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ1D);
875 reducedParticle->fTRDpid[0] = trdProbab[AliPID::kElectron];
876 reducedParticle->fTRDpid[1] = trdProbab[AliPID::kPion];
877 pidResponse->ComputeTRDProbability(esdTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D);
878 reducedParticle->fTRDpidLQ2D[0] = trdProbab[AliPID::kElectron];
879 reducedParticle->fTRDpidLQ2D[1] = trdProbab[AliPID::kPion];
881 for(Int_t idx=0; idx<3; ++idx) if(esdTrack->GetKinkIndex(idx)>0) reducedParticle->fFlags |= (1<<(5+idx));
882 if(esdTrack->IsEMCAL()) reducedParticle->fCaloClusterId = esdTrack->GetEMCALcluster();
883 if(esdTrack->IsPHOS()) reducedParticle->fCaloClusterId = esdTrack->GetPHOScluster();
886 //AliAODTrack *track=static_cast<AliAODTrack*>(particle);
887 const AliExternalTrackParam* tpcInner = aodTrack->GetInnerParam();
888 reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0);
889 reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0);
890 reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0);
892 reducedParticle->fTrackId = aodTrack->GetID();
893 reducedParticle->fITSsignal = aodTrack->GetITSsignal();
895 reducedParticle->fITSnSig[0] = pidResponse->NumberOfSigmasITS(aodTrack,AliPID::kElectron);
896 reducedParticle->fITSnSig[1] = pidResponse->NumberOfSigmasITS(aodTrack,AliPID::kPion);
897 reducedParticle->fITSnSig[2] = pidResponse->NumberOfSigmasITS(aodTrack,AliPID::kKaon);
898 reducedParticle->fITSnSig[3] = pidResponse->NumberOfSigmasITS(aodTrack,AliPID::kProton);
900 reducedParticle->fTRDntracklets[0] = aodTrack->GetTRDntrackletsPID();
901 reducedParticle->fTRDntracklets[1] = aodTrack->GetTRDntrackletsPID();
902 pidResponse->ComputeTRDProbability(aodTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ1D);
903 reducedParticle->fTRDpid[0] = trdProbab[AliPID::kElectron];
904 reducedParticle->fTRDpid[1] = trdProbab[AliPID::kPion];
905 pidResponse->ComputeTRDProbability(aodTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D);
906 reducedParticle->fTRDpidLQ2D[0] = trdProbab[AliPID::kElectron];
907 reducedParticle->fTRDpidLQ2D[1] = trdProbab[AliPID::kPion];
909 if(aodTrack->IsEMCAL()) reducedParticle->fCaloClusterId = aodTrack->GetEMCALcluster();
910 if(aodTrack->IsPHOS()) reducedParticle->fCaloClusterId = aodTrack->GetPHOScluster();
911 if(values[AliDielectronVarManager::kKinkIndex0]>0.0) reducedParticle->fFlags |= (1<<5);
914 fReducedEvent->fNtracks[1] += 1;
919 //_________________________________________________________________________________
920 void AliAnalysisTaskReducedTree::FillDielectronPairInfo(AliDielectron* die, Short_t iDie)
923 // fill reduced pair information
925 Bool_t hasMC=AliDielectronMC::Instance()->HasMC();
927 for(Int_t iType=0; iType<3; ++iType) {
929 const TObjArray* array = die->GetPairArray(iType);
930 if(!array || array->GetEntriesFast()==0) continue;
932 for(Int_t iCandidate=0; iCandidate<array->GetEntriesFast(); ++iCandidate) {
933 AliDielectronPair* pair = (AliDielectronPair*)array->At(iCandidate);
934 Double_t values[AliDielectronVarManager::kNMaxValues];
935 AliDielectronVarManager::Fill(pair, values);
937 TClonesArray& tracks = *(fReducedEvent->fCandidates);
938 AliReducedPair *reducedParticle=
939 new (tracks[fReducedEvent->fNV0candidates[1]+fReducedEvent->fNDielectronCandidates]) AliReducedPair();
940 // !!! hardcoded flag for dielectron id
941 reducedParticle->fCandidateId = (iDie==0 ? AliReducedPair::kJpsiToEE : AliReducedPair::kPhiToKK);
942 reducedParticle->fPairType = (Char_t)values[AliDielectronVarManager::kPairType];
943 reducedParticle->fLegIds[0] = (UShort_t)(static_cast<AliVTrack*>(pair->GetFirstDaughter()))->GetID();
944 reducedParticle->fLegIds[1] = (UShort_t)(static_cast<AliVTrack*>(pair->GetSecondDaughter()))->GetID();
945 reducedParticle->fMass[0] = values[AliDielectronVarManager::kM];
946 reducedParticle->fMass[1] = -999.;
947 reducedParticle->fMass[2] = -999.;
948 reducedParticle->fMass[3] = -999.;
949 reducedParticle->fPhi = values[AliDielectronVarManager::kPhi]; // in the [-pi,pi] interval
950 if(reducedParticle->fPhi<0.0) reducedParticle->fPhi = 2.0*TMath::Pi() + reducedParticle->fPhi; // converted to [0,2pi]
951 reducedParticle->fPt = values[AliDielectronVarManager::kPt];
952 reducedParticle->fEta = values[AliDielectronVarManager::kEta];
953 reducedParticle->fLxy = values[AliDielectronVarManager::kPseudoProperTime];
954 reducedParticle->fLxyErr = values[AliDielectronVarManager::kPseudoProperTimeErr];
955 reducedParticle->fPointingAngle = values[AliDielectronVarManager::kCosPointingAngle];
957 reducedParticle->fMCid = 0;
959 AliDielectronMC::Instance()->ConnectMCEvent();
960 const TObjArray* mcSignals = die->GetMCSignals();
961 for(Int_t iSig=0; iSig<mcSignals->GetEntries(); ++iSig) {
963 AliDielectronMC *mc=AliDielectronMC::Instance();
964 if(mc->IsMCTruth(pair, (AliDielectronSignalMC*)mcSignals->At(iSig))) {
965 reducedParticle->fMCid = reducedParticle->fMCid | (1<<iSig);
969 fReducedEvent->fNDielectronCandidates += 1;
970 } // end loop over candidates
971 } // end loop over pair type
975 //_________________________________________________________________________________
976 void AliAnalysisTaskReducedTree::FillV0PairInfo()
979 // fill reduced pair information
981 AliESDEvent* esd = (AliESDEvent*)InputEvent();
982 const AliESDVertex *primaryVertex = esd->GetPrimaryVertex();
983 AliKFVertex primaryVertexKF(*primaryVertex);
985 fReducedEvent->fNV0candidates[0] = InputEvent()->GetNumberOfV0s();
987 if(!(fFillK0s || fFillLambda || fFillALambda || fFillGammaConversions)) return;
989 Double_t valuesPos[AliDielectronVarManager::kNMaxValues];
990 Double_t valuesNeg[AliDielectronVarManager::kNMaxValues];
993 fV0OpenCuts->SetEvent(esd);
994 fV0OpenCuts->SetPrimaryVertex(&primaryVertexKF);
997 fV0StrongCuts->SetEvent(esd);
998 fV0StrongCuts->SetPrimaryVertex(&primaryVertexKF);
1001 Int_t pdgV0=0; Int_t pdgP=0; Int_t pdgN=0;
1002 for(Int_t iV0=0; iV0<InputEvent()->GetNumberOfV0s(); ++iV0) { // loop over V0s
1003 AliESDv0 *v0 = esd->GetV0(iV0);
1005 AliESDtrack* legPos = esd->GetTrack(v0->GetPindex());
1006 AliESDtrack* legNeg = esd->GetTrack(v0->GetNindex());
1008 if(legPos->GetSign() == legNeg->GetSign()) {
1012 Bool_t v0ChargesAreCorrect = (legPos->GetSign()==+1 ? kTRUE : kFALSE);
1013 legPos = (!v0ChargesAreCorrect ? esd->GetTrack(v0->GetNindex()) : legPos);
1014 legNeg = (!v0ChargesAreCorrect ? esd->GetTrack(v0->GetPindex()) : legNeg);
1016 pdgV0=0; pdgP=0; pdgN=0;
1017 Bool_t goodK0s = kTRUE; Bool_t goodLambda = kTRUE; Bool_t goodALambda = kTRUE; Bool_t goodGamma = kTRUE;
1019 goodK0s = kFALSE; goodLambda = kFALSE; goodALambda = kFALSE; goodGamma = kFALSE;
1020 Bool_t processV0 = fV0OpenCuts->ProcessV0(v0, pdgV0, pdgP, pdgN);
1021 if(processV0 && TMath::Abs(pdgV0)==310 && TMath::Abs(pdgP)==211 && TMath::Abs(pdgN)==211) {
1023 if(fK0sPionCuts && (!fK0sPionCuts->IsSelected(legPos) || !fK0sPionCuts->IsSelected(legNeg))) goodK0s = kFALSE;
1025 if(processV0 && pdgV0==3122 && (TMath::Abs(pdgP)==211 || TMath::Abs(pdgP)==2212) && (TMath::Abs(pdgN)==211 || TMath::Abs(pdgN)==2212)) {
1027 if(fLambdaProtonCuts && !fLambdaProtonCuts->IsSelected(legPos)) goodLambda = kFALSE;
1028 if(fLambdaPionCuts && !fLambdaPionCuts->IsSelected(legNeg)) goodLambda = kFALSE;
1030 if(processV0 && pdgV0==-3122 && (TMath::Abs(pdgP)==211 || TMath::Abs(pdgP)==2212) && (TMath::Abs(pdgN)==211 || TMath::Abs(pdgN)==2212)) {
1031 goodALambda = kTRUE;
1032 if(fLambdaProtonCuts && !fLambdaProtonCuts->IsSelected(legNeg)) goodALambda = kFALSE;
1033 if(fLambdaPionCuts && !fLambdaPionCuts->IsSelected(legPos)) goodALambda = kFALSE;
1035 if(processV0 && TMath::Abs(pdgV0)==22 && TMath::Abs(pdgP)==11 && TMath::Abs(pdgN)==11) {
1037 if(fGammaElectronCuts && (!fGammaElectronCuts->IsSelected(legPos) || !fGammaElectronCuts->IsSelected(legNeg))) goodGamma = kFALSE;
1039 //cout << "open cuts pdgV0/pdgP/pdgN/processV0 : " << pdgV0 << "/" << pdgP << "/" << pdgN << "/" << processV0 << endl;
1040 //cout << "good K0s/Lambda/ALambda/Gamma : " << goodK0s << "/" << goodLambda << "/" << goodALambda << "/" << goodGamma << endl;
1043 Bool_t veryGoodK0s = kFALSE; Bool_t veryGoodLambda = kFALSE; Bool_t veryGoodALambda = kFALSE; Bool_t veryGoodGamma = kFALSE;
1044 if(fV0StrongCuts && (goodK0s || goodLambda || goodALambda || goodGamma)) {
1045 pdgV0=0; pdgP=0; pdgN=0;
1046 Bool_t processV0 = fV0StrongCuts->ProcessV0(v0, pdgV0, pdgP, pdgN);
1047 if(processV0 && goodK0s && TMath::Abs(pdgV0)==310 && TMath::Abs(pdgP)==211 && TMath::Abs(pdgN)==211)
1048 veryGoodK0s = kTRUE;
1049 if(processV0 && goodLambda && pdgV0==3122 && (TMath::Abs(pdgP)==211 || TMath::Abs(pdgP)==2212) && (TMath::Abs(pdgN)==211 || TMath::Abs(pdgN)==2212))
1050 veryGoodLambda = kTRUE;
1051 if(processV0 && goodALambda && pdgV0==-3122 && (TMath::Abs(pdgP)==211 || TMath::Abs(pdgP)==2212) && (TMath::Abs(pdgN)==211 || TMath::Abs(pdgN)==2212))
1052 veryGoodALambda = kTRUE;
1053 if(processV0 && goodGamma && TMath::Abs(pdgV0)==22 && TMath::Abs(pdgP)==11 && TMath::Abs(pdgN)==11)
1054 veryGoodGamma = kTRUE;
1055 //cout << "strong cuts pdgV0/pdgP/pdgN/processV0 : " << pdgV0 << "/" << pdgP << "/" << pdgN << "/" << processV0 << endl;
1056 //cout << "very good K0s/Lambda/ALambda/Gamma : " << veryGoodK0s << "/" << veryGoodLambda << "/" << veryGoodALambda << "/" << veryGoodGamma << endl;
1059 if(!((goodK0s && fFillK0s) ||
1060 (goodLambda && fFillLambda) ||
1061 (goodALambda && fFillALambda) ||
1062 (goodGamma && fFillGammaConversions))) continue;
1064 // Fill the V0 information into the tree for 4 hypothesis: K0s, Lambda, Anti-Lambda and gamma conversion
1065 AliReducedPair* k0sReducedPair = FillV0PairInfo(v0, AliReducedPair::kK0sToPiPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
1066 AliReducedPair* lambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kLambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
1067 AliReducedPair* alambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kALambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
1068 AliReducedPair* gammaReducedPair = FillV0PairInfo(v0, AliReducedPair::kGammaConv, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
1070 if(fFillK0s && goodK0s && k0sReducedPair->fMass[0]>fK0sMassRange[0] && k0sReducedPair->fMass[0]<fK0sMassRange[1]) {
1071 TClonesArray& tracks = *(fReducedEvent->fCandidates);
1072 AliReducedPair *goodK0sPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*k0sReducedPair);
1073 goodK0sPair->fMass[0] = k0sReducedPair->fMass[0];
1074 goodK0sPair->fMass[1] = lambdaReducedPair->fMass[0];
1075 goodK0sPair->fMass[2] = alambdaReducedPair->fMass[0];
1076 goodK0sPair->fMass[3] = gammaReducedPair->fMass[0];
1077 if(veryGoodK0s) goodK0sPair->fMCid |= (UInt_t(1)<<1);
1078 fReducedEvent->fNV0candidates[1] += 1;
1079 } else {goodK0s=kFALSE;}
1080 if(fFillLambda && goodLambda && lambdaReducedPair->fMass[0]>fLambdaMassRange[0] && lambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
1081 TClonesArray& tracks = *(fReducedEvent->fCandidates);
1082 AliReducedPair *goodLambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*lambdaReducedPair);
1083 goodLambdaPair->fMass[0] = k0sReducedPair->fMass[0];
1084 goodLambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
1085 goodLambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
1086 goodLambdaPair->fMass[3] = gammaReducedPair->fMass[0];
1087 if(veryGoodLambda) goodLambdaPair->fMCid |= (UInt_t(1)<<2);
1088 fReducedEvent->fNV0candidates[1] += 1;
1089 } else {goodLambda=kFALSE;}
1090 if(fFillALambda && goodALambda && alambdaReducedPair->fMass[0]>fLambdaMassRange[0] && alambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
1091 TClonesArray& tracks = *(fReducedEvent->fCandidates);
1092 AliReducedPair *goodALambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*alambdaReducedPair);
1093 goodALambdaPair->fMass[0] = k0sReducedPair->fMass[0];
1094 goodALambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
1095 goodALambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
1096 goodALambdaPair->fMass[3] = gammaReducedPair->fMass[0];
1097 if(veryGoodALambda) goodALambdaPair->fMCid |= (UInt_t(1)<<3);
1098 fReducedEvent->fNV0candidates[1] += 1;
1099 } else {goodALambda = kFALSE;}
1100 //cout << "gamma mass: " << gammaReducedPair->fMass[0] << endl;
1101 if(fFillGammaConversions && goodGamma && gammaReducedPair->fMass[0]>fGammaMassRange[0] && gammaReducedPair->fMass[0]<fGammaMassRange[1]) {
1102 TClonesArray& tracks = *(fReducedEvent->fCandidates);
1103 AliReducedPair *goodGammaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*gammaReducedPair);
1104 goodGammaPair->fMass[0] = k0sReducedPair->fMass[0];
1105 goodGammaPair->fMass[1] = lambdaReducedPair->fMass[0];
1106 goodGammaPair->fMass[2] = alambdaReducedPair->fMass[0];
1107 goodGammaPair->fMass[3] = gammaReducedPair->fMass[0];
1108 if(veryGoodGamma) goodGammaPair->fMCid |= (UInt_t(1)<<4);
1109 fReducedEvent->fNV0candidates[1] += 1;
1110 } else {goodGamma=kFALSE;}
1111 delete k0sReducedPair;
1112 delete lambdaReducedPair;
1113 delete alambdaReducedPair;
1114 delete gammaReducedPair;
1116 if(!(goodK0s || goodLambda || goodALambda || goodGamma)) continue;
1118 // Fill histograms and the CF container
1119 AliDielectronVarManager::Fill(legPos, valuesPos);
1120 AliDielectronVarManager::Fill(legNeg, valuesNeg);
1122 if(fV0Histos && fV0Histos->GetHistogramList()->FindObject("V0Track_Pos"))
1123 fV0Histos->FillClass("V0Track_Pos", AliDielectronVarManager::kNMaxValues, valuesPos);
1124 if(fV0Histos && fV0Histos->GetHistogramList()->FindObject("V0Track_Neg"))
1125 fV0Histos->FillClass("V0Track_Neg", AliDielectronVarManager::kNMaxValues, valuesNeg);
1126 } // end loop over V0s
1130 //_________________________________________________________________________________
1131 AliReducedPair* AliAnalysisTaskReducedTree::FillV0PairInfo(AliESDv0* v0, Int_t id,
1132 AliESDtrack* legPos, AliESDtrack* legNeg,
1133 AliKFVertex* vtxKF, Bool_t chargesAreCorrect) {
1135 // Create a reduced V0 object and fill it
1137 AliReducedPair* reducedPair=new AliReducedPair();
1138 reducedPair->fCandidateId = id;
1139 reducedPair->fPairType = v0->GetOnFlyStatus(); // on the fly status
1140 reducedPair->fLegIds[0] = legPos->GetID();
1141 reducedPair->fLegIds[1] = legNeg->GetID();
1142 if(!reducedPair->fPairType) { // offline
1143 UInt_t pidPos = AliPID::kPion;
1144 if(id==AliReducedPair::kLambda0ToPPi) pidPos = AliPID::kProton;
1145 if(id==AliReducedPair::kGammaConv) pidPos = AliPID::kElectron;
1146 UInt_t pidNeg = AliPID::kPion;
1147 if(id==AliReducedPair::kALambda0ToPPi) pidNeg = AliPID::kProton;
1148 if(id==AliReducedPair::kGammaConv) pidNeg = AliPID::kElectron;
1149 reducedPair->fMass[0] = v0->GetEffMass(pidPos, pidNeg);
1150 reducedPair->fPhi = v0->Phi();
1151 if(reducedPair->fPhi<0.0) reducedPair->fPhi = 2.0*TMath::Pi() + reducedPair->fPhi; // converted to [0,2pi]
1152 reducedPair->fPt = v0->Pt();
1153 reducedPair->fEta = v0->Eta();
1154 reducedPair->fLxy = v0->GetRr();
1155 reducedPair->fPointingAngle = v0->GetV0CosineOfPointingAngle(vtxKF->GetX(), vtxKF->GetY(), vtxKF->GetZ());
1156 reducedPair->fChisquare = v0->GetChi2V0();
1159 const AliExternalTrackParam *negHelix=v0->GetParamN();
1160 const AliExternalTrackParam *posHelix=v0->GetParamP();
1161 if(!chargesAreCorrect) {
1162 negHelix = v0->GetParamP();
1163 posHelix = v0->GetParamN();
1166 if(id==AliReducedPair::kLambda0ToPPi) pdgPos = 2212;
1167 if(id==AliReducedPair::kGammaConv) pdgPos = -11;
1168 Int_t pdgNeg = -211;
1169 if(id==AliReducedPair::kALambda0ToPPi) pdgNeg = -2212;
1170 if(id==AliReducedPair::kGammaConv) pdgNeg = 11;
1171 AliKFParticle negKF(*(negHelix), pdgPos);
1172 AliKFParticle posKF(*(posHelix), pdgNeg);
1173 AliKFParticle v0Refit;
1176 Double_t massFit=0.0, massErrFit=0.0;
1177 v0Refit.GetMass(massFit,massErrFit);
1178 reducedPair->fMass[0] = massFit;
1179 reducedPair->fPhi = v0Refit.GetPhi();
1180 if(reducedPair->fPhi<0.0) reducedPair->fPhi = 2.0*TMath::Pi() + reducedPair->fPhi; // converted to [0,2pi]
1181 reducedPair->fPt = v0Refit.GetPt();
1182 reducedPair->fEta = v0Refit.GetEta();
1183 reducedPair->fLxy = v0Refit.GetPseudoProperDecayTime(*vtxKF, massFit);
1184 Double_t deltaPos[3];
1185 deltaPos[0] = v0Refit.GetX() - vtxKF->GetX(); deltaPos[1] = v0Refit.GetY() - vtxKF->GetY(); deltaPos[2] = v0Refit.GetZ() - vtxKF->GetZ();
1186 Double_t momV02 = v0Refit.GetPx()*v0Refit.GetPx() + v0Refit.GetPy()*v0Refit.GetPy() + v0Refit.GetPz()*v0Refit.GetPz();
1187 Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2];
1188 reducedPair->fPointingAngle = (deltaPos[0]*v0Refit.GetPx() + deltaPos[1]*v0Refit.GetPy() + deltaPos[2]*v0Refit.GetPz()) /
1189 TMath::Sqrt(momV02*deltaPos2);
1190 reducedPair->fChisquare = v0Refit.GetChi2();
1196 //_________________________________________________________________________________
1197 UChar_t AliAnalysisTaskReducedTree::EncodeTPCClusterMap(AliVParticle* track, Bool_t isAOD) {
1199 // Encode the TPC cluster map into an UChar_t
1200 // Divide the 159 bits from the bit map into 8 groups of adiacent clusters
1201 // For each group enable its corresponding bit if in that group there are more clusters compared to
1204 AliESDtrack* esdTrack=0x0;
1205 AliAODTrack* aodTrack=0x0;
1207 aodTrack=static_cast<AliAODTrack*>(track);
1209 esdTrack=static_cast<AliESDtrack*>(track);
1211 const UChar_t threshold=5;
1212 TBits tpcClusterMap = (isAOD ? aodTrack->GetTPCClusterMap() : esdTrack->GetTPCClusterMap());
1216 for(UChar_t i=0; i<8; ++i) {
1218 for(j=i*20; j<(i+1)*20 && j<159; ++j) n+=tpcClusterMap.TestBitNumber(j);
1219 if(n>=threshold) map |= (1<<i);
1225 //_________________________________________________________________________________
1226 Int_t AliAnalysisTaskReducedTree::GetSPDTrackletMultiplicity(AliVEvent* event, Float_t lowEta, Float_t highEta) {
1228 // Count the number of SPD tracklets in a given eta range
1230 if (!event) return -1;
1232 Int_t nTracklets = 0;
1235 if(event->IsA() == AliAODEvent::Class()) {
1236 AliAODTracklets *tracklets = ((AliAODEvent*)event)->GetTracklets();
1237 nTracklets = tracklets->GetNumberOfTracklets();
1238 for(Int_t nn=0; nn<nTracklets; ++nn) {
1239 Double_t theta = tracklets->GetTheta(nn);
1240 Double_t eta = -TMath::Log(TMath::Tan(theta/2.0));
1241 if(eta < lowEta) continue;
1242 if(eta > highEta) continue;
1245 } else if(event->IsA() == AliESDEvent::Class()) {
1246 nTracklets = ((AliESDEvent*)event)->GetMultiplicity()->GetNumberOfTracklets();
1247 for(Int_t nn=0; nn<nTracklets; ++nn) {
1248 Double_t eta = ((AliESDEvent*)event)->GetMultiplicity()->GetEta(nn);
1249 if(eta < lowEta) continue;
1250 if(eta > highEta) continue;
1259 //_________________________________________________________________________________
1260 void AliAnalysisTaskReducedTree::FinishTaskOutput()
1266 //fTreeFile->Write();
1267 //fTreeFile->Close();