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 <AliAODTrack.h>
36 #include <AliTriggerAnalysis.h>
37 #include <AliESDtrackCuts.h>
40 #include <AliESDv0Cuts.h>
41 #include <AliVCluster.h>
42 #include "AliDielectron.h"
43 #include "AliDielectronHistos.h"
44 #include "AliDielectronMC.h"
45 #include "AliDielectronVarManager.h"
46 #include "AliFlowTrackCuts.h"
47 #include "AliFlowBayesianPID.h"
49 #include "AliReducedEvent.h"
50 #include "AliAnalysisTaskReducedTree.h"
52 ClassImp(AliAnalysisTaskReducedTree)
55 //_________________________________________________________________________________
56 AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree() :
60 fSelectPhysics(kFALSE),
61 fTriggerMask(AliVEvent::kAny),
62 fRejectPileup(kFALSE),
63 fFillTrackInfo(kTRUE),
64 fFillDielectronInfo(kTRUE),
66 fFillCaloClusterInfo(kTRUE),
67 fFillFriendInfo(kTRUE),
70 fFlowTrackFilter(0x0),
74 fLambdaProtonCuts(0x0),
84 fReducedEventFriend(0x0)
91 //_________________________________________________________________________________
92 AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree(const char *name) :
93 AliAnalysisTaskSE(name),
96 fSelectPhysics(kFALSE),
97 fTriggerMask(AliVEvent::kAny),
98 fRejectPileup(kFALSE),
99 fFillTrackInfo(kTRUE),
100 fFillDielectronInfo(kTRUE),
102 fFillCaloClusterInfo(kTRUE),
103 fFillFriendInfo(kTRUE),
106 fFlowTrackFilter(0x0),
110 fLambdaProtonCuts(0x0),
111 fLambdaPionCuts(0x0),
117 fFriendTreeFile(0x0),
120 fReducedEventFriend(0x0)
125 fK0sMassRange[0] = 0.4; fK0sMassRange[1] = 0.6;
126 fLambdaMassRange[0] = 1.08; fLambdaMassRange[1] = 1.15;
128 DefineInput(0,TChain::Class());
129 DefineOutput(1, TList::Class()); // QA histograms
130 //DefineOutput(2, TTree::Class()); // reduced information tree
131 //if(fFillFriendInfo) DefineOutput(3, TTree::Class()); // reduced information tree with friends
132 //DefineOutput(2, TTree::Class()); // reduced information tree with friends
133 DefineOutput(2, TTree::Class()); // reduced information tree
135 fListHistos.SetName("QAhistograms");
136 fListDielectron.SetOwner();
137 fListHistos.SetOwner(kFALSE);
141 //_________________________________________________________________________________
142 void AliAnalysisTaskReducedTree::UserCreateOutputObjects()
145 // Add all histogram manager histogram lists to the output TList
148 if (!fListHistos.IsEmpty() || fTree || fFriendTree) return; //already initialised
150 TIter nextDie(&fListDielectron);
151 AliDielectron *die=0;
152 while ( (die=static_cast<AliDielectron*>(nextDie())) ){
154 if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
156 if(fV0Histos) fListHistos.Add(const_cast<THashList*>(fV0Histos->GetHistogramList()));
158 if(fFillFriendInfo) {
159 fFriendTree = new TTree("DstFriendTree","Reduced ESD information");
160 fReducedEventFriend = new AliReducedEventFriend();
161 fFriendTree->Branch("Event",&fReducedEventFriend,16000,99);
164 //fTreeFile = new TFile("dstTree.root", "RECREATE");
165 fTree = new TTree("DstTree","Reduced ESD information");
166 fReducedEvent = new AliReducedEvent("DstEvent");
167 fTree->Branch("Event",&fReducedEvent,16000,99);
169 PostData(1, &fListHistos);
171 //if(fFillFriendInfo) PostData(3, fFriendTree);
172 //PostData(2, fFriendTree);
173 //PostData(1, fTree);
176 //_________________________________________________________________________________
177 void AliAnalysisTaskReducedTree::UserExec(Option_t *option)
180 // Main loop. Called for every event
183 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
184 Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
185 Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
187 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
188 if (!inputHandler) return;
190 if ( inputHandler->GetPIDResponse() ){
191 AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
193 AliFatal("This task needs the PID response attached to the input event handler!");
196 // Was event selected ?
197 UInt_t isSelected = AliVEvent::kAny;
198 if(fSelectPhysics && inputHandler){
199 if((isESD && inputHandler->GetEventSelection()) || isAOD){
200 isSelected = inputHandler->IsEventSelected();
201 isSelected&=fTriggerMask;
209 // fill event histograms before event filter
210 Double_t values[AliDielectronVarManager::kNMaxValues]={0};
211 AliDielectronVarManager::Fill(InputEvent(),values);
213 TIter nextDie(&fListDielectron);
214 AliDielectron *die=0;
215 while ( (die=static_cast<AliDielectron*>(nextDie())) ){
216 AliDielectronHistos *h=die->GetHistoManager();
218 if (h->GetHistogramList()->FindObject("Event_noCuts"))
219 h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,values);
226 if (!fEventFilter->IsSelected(InputEvent())) return;
231 if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
235 Double_t bz = InputEvent()->GetMagneticField();
236 AliKFParticle::SetField( bz );
238 //Process event in all AliDielectron instances
239 fReducedEvent->ClearEvent();
240 if(fFillFriendInfo) fReducedEventFriend->ClearEvent();
242 if(fFillV0Info) FillV0PairInfo();
245 if(fFillDielectronInfo) {
246 while((die=static_cast<AliDielectron*>(nextDie()))){
247 die->Process(InputEvent());
248 FillDielectronPairInfo(die, idie);
254 if(fFillTrackInfo) FillTrackInfo();
255 if(fFillFriendInfo) FillFriendEventInfo(); // Q-vector calculation
258 if(fFillFriendInfo) fFriendTree->Fill();
260 // if there are candidate pairs, add the information to the reduced tree
261 PostData(1, &fListHistos);
262 //PostData(2, fTree);
263 //if(fFillFriendInfo) PostData(3, fFriendTree);
264 //PostData(2, fFriendTree);
269 //_________________________________________________________________________________
270 void AliAnalysisTaskReducedTree::FillEventInfo()
273 // fill reduced event information
275 AliVEvent* event = InputEvent();
276 // Was event selected ?
277 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
278 Bool_t isESD = (event->IsA()==AliESDEvent::Class());
279 Bool_t isAOD = (event->IsA()==AliAODEvent::Class());
281 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
282 UInt_t isSelected = AliVEvent::kAny;
284 if((isESD && inputHandler->GetEventSelection()) || isAOD){
285 isSelected = inputHandler->IsEventSelected();
286 isSelected&=fTriggerMask;
290 Double_t values[AliDielectronVarManager::kNMaxValues];
291 AliDielectronVarManager::Fill(event, values);
293 fReducedEvent->fRunNo = event->GetRunNumber();
294 fReducedEvent->fBC = event->GetBunchCrossNumber();
295 fReducedEvent->fTriggerMask = event->GetTriggerMask();
296 fReducedEvent->fIsPhysicsSelection = (isSelected!=0 ? kTRUE : kFALSE);
297 AliVVertex* eventVtx = 0x0;
298 if(isESD) eventVtx = const_cast<AliESDVertex*>((static_cast<AliESDEvent*>(event))->GetPrimaryVertexTracks());
299 if(isAOD) eventVtx = const_cast<AliAODVertex*>((static_cast<AliAODEvent*>(event))->GetPrimaryVertex());
301 fReducedEvent->fVtx[0] = (isESD ? ((AliESDVertex*)eventVtx)->GetXv() : ((AliAODVertex*)eventVtx)->GetX());
302 fReducedEvent->fVtx[1] = (isESD ? ((AliESDVertex*)eventVtx)->GetYv() : ((AliAODVertex*)eventVtx)->GetY());
303 fReducedEvent->fVtx[2] = (isESD ? ((AliESDVertex*)eventVtx)->GetZv() : ((AliAODVertex*)eventVtx)->GetZ());
304 fReducedEvent->fNVtxContributors = eventVtx->GetNContributors();
307 eventVtx = const_cast<AliESDVertex*>((static_cast<AliESDEvent*>(event))->GetPrimaryVertexTPC());
309 fReducedEvent->fVtxTPC[0] = ((AliESDVertex*)eventVtx)->GetXv();
310 fReducedEvent->fVtxTPC[1] = ((AliESDVertex*)eventVtx)->GetYv();
311 fReducedEvent->fVtxTPC[2] = ((AliESDVertex*)eventVtx)->GetZv();
312 fReducedEvent->fNVtxTPCContributors = eventVtx->GetNContributors();
316 AliCentrality *centrality = event->GetCentrality();
318 fReducedEvent->fCentrality[0] = centrality->GetCentralityPercentile("V0M");
319 fReducedEvent->fCentrality[1] = centrality->GetCentralityPercentile("CL1");
320 fReducedEvent->fCentrality[2] = centrality->GetCentralityPercentile("TRK");
321 fReducedEvent->fCentrality[3] = centrality->GetCentralityPercentile("ZEMvsZDC");
322 fReducedEvent->fCentQuality = centrality->GetQuality();
325 fReducedEvent->fNtracks[0] = event->GetNumberOfTracks();
326 fReducedEvent->fSPDntracklets = (UChar_t)values[AliDielectronVarManager::kNaccTrckltsEsd10Corr];
328 AliVVZERO* vzero = event->GetVZEROData();
329 for(Int_t i=0;i<64;++i)
330 fReducedEvent->fVZEROMult[i] = vzero->GetMultiplicity(i);
332 AliESDZDC* zdc = (isESD ? (static_cast<AliESDEvent*>(event))->GetESDZDC() : 0x0);
334 for(Int_t i=0; i<4; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN1TowerEnergy()[i];
335 for(Int_t i=4; i<8; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN2TowerEnergy()[i-4];
338 // EMCAL/PHOS clusters
339 if(fFillCaloClusterInfo) FillCaloClusters();
341 // TODO FMD multiplicities
346 //_________________________________________________________________________________
347 void AliAnalysisTaskReducedTree::FillCaloClusters() {
349 // Fill info about the calorimeter clusters
351 AliVEvent* event = InputEvent();
352 Int_t nclusters = event->GetNumberOfCaloClusters();
354 fReducedEvent->fNCaloClusters = 0;
355 for(Int_t iclus=0; iclus<nclusters; ++iclus) {
356 AliVCluster* cluster = event->GetCaloCluster(iclus);
358 TClonesArray& clusters = *(fReducedEvent->fCaloClusters);
359 AliReducedCaloCluster *reducedCluster=new(clusters[fReducedEvent->fNCaloClusters]) AliReducedCaloCluster();
361 reducedCluster->fType = (cluster->IsEMCAL() ? AliReducedCaloCluster::kEMCAL : AliReducedCaloCluster::kPHOS);
362 reducedCluster->fEnergy = cluster->E();
363 reducedCluster->fTrackDx = cluster->GetTrackDx();
364 reducedCluster->fTrackDz = cluster->GetTrackDz();
365 fReducedEvent->fNCaloClusters += 1;
366 } // end loop over clusters
370 //_________________________________________________________________________________
371 void AliAnalysisTaskReducedTree::FillFriendEventInfo() {
373 // Fill event info into the friend tree
375 // Add here calculated Q-vector components from all detectors
376 for(Int_t idet=0; idet<AliReducedEventFriend::kNdetectors; ++idet) {
377 fReducedEvent->GetQvector(fReducedEventFriend->fQvector[idet], idet);
378 for(Int_t ih=0; ih<fgkNMaxHarmonics; ++ih)
379 fReducedEventFriend->fEventPlaneStatus[idet][ih] = AliReducedEventFriend::kRaw;
384 //_________________________________________________________________________________
385 void AliAnalysisTaskReducedTree::FillTrackInfo()
388 // fill reduced track information
390 AliVEvent* event = InputEvent();
391 Bool_t isESD = (event->IsA()==AliESDEvent::Class());
392 Bool_t isAOD = (event->IsA()==AliAODEvent::Class());
394 Int_t ntracks=event->GetNumberOfTracks();
395 for(Int_t itrack=0; itrack<ntracks; ++itrack){
396 AliVParticle *particle=event->GetTrack(itrack);
398 if(fTrackFilter && !fTrackFilter->IsSelected(particle)) continue;
400 TClonesArray& tracks = *(fReducedEvent->fTracks);
401 AliReducedTrack *reducedParticle=new(tracks[fReducedEvent->fNtracks[1]]) AliReducedTrack();
403 Double_t values[AliDielectronVarManager::kNMaxValues];
404 AliDielectronVarManager::Fill(particle, values);
405 reducedParticle->fStatus = (ULong_t)values[AliDielectronVarManager::kTrackStatus];
406 reducedParticle->fGlobalPhi = values[AliDielectronVarManager::kPhi];
407 reducedParticle->fGlobalPt = values[AliDielectronVarManager::kPt]*values[AliDielectronVarManager::kCharge];
408 reducedParticle->fGlobalEta = values[AliDielectronVarManager::kEta];
409 reducedParticle->fMomentumInner = values[AliDielectronVarManager::kPIn];
410 reducedParticle->fDCA[0] = values[AliDielectronVarManager::kImpactParXY];
411 reducedParticle->fDCA[1] = values[AliDielectronVarManager::kImpactParZ];
413 reducedParticle->fITSclusterMap = (UChar_t)values[AliDielectronVarManager::kITSclusterMap];
414 reducedParticle->fITSsignal = values[AliDielectronVarManager::kITSsignal];
416 reducedParticle->fTPCNcls = (UChar_t)values[AliDielectronVarManager::kNclsTPC];
417 reducedParticle->fTPCNclsF = (UChar_t)values[AliDielectronVarManager::kNFclsTPC];
418 reducedParticle->fTPCNclsIter1 = (UChar_t)values[AliDielectronVarManager::kNclsTPCiter1];
419 reducedParticle->fTPCsignal = values[AliDielectronVarManager::kTPCsignal];
420 reducedParticle->fTPCnSig[0] = values[AliDielectronVarManager::kTPCnSigmaEle];
421 reducedParticle->fTPCnSig[1] = values[AliDielectronVarManager::kTPCnSigmaPio];
422 reducedParticle->fTPCnSig[2] = values[AliDielectronVarManager::kTPCnSigmaKao];
423 reducedParticle->fTPCnSig[3] = values[AliDielectronVarManager::kTPCnSigmaPro];
425 reducedParticle->fTOFbeta = values[AliDielectronVarManager::kTOFbeta];
426 reducedParticle->fTOFnSig[0] = values[AliDielectronVarManager::kTOFnSigmaEle];
427 reducedParticle->fTOFnSig[1] = values[AliDielectronVarManager::kTOFnSigmaPio];
428 reducedParticle->fTOFnSig[2] = values[AliDielectronVarManager::kTOFnSigmaKao];
429 reducedParticle->fTOFnSig[3] = values[AliDielectronVarManager::kTOFnSigmaPro];
431 reducedParticle->fTRDpid[0] = values[AliDielectronVarManager::kTRDprobEle];
432 reducedParticle->fTRDpid[1] = values[AliDielectronVarManager::kTRDprobPio];
434 if(fFlowTrackFilter) {
435 // switch on the first bit if this particle should be used for the event plane
436 if(fFlowTrackFilter->IsSelected(particle)) reducedParticle->fFlags |= (1<<0);
440 AliESDtrack *track=static_cast<AliESDtrack*>(particle);
441 reducedParticle->fTrackId = (UShort_t)track->GetID();
442 reducedParticle->fTPCCrossedRows = (UChar_t)track->GetTPCCrossedRows();
443 reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(track);
444 const AliExternalTrackParam* tpcInner = track->GetTPCInnerParam();
445 reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0);
446 reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0);
447 reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0);
448 reducedParticle->fTRDntracklets[0] = track->GetTRDntracklets();
449 reducedParticle->fTRDntracklets[1] = track->GetTRDntrackletsPID();
450 if(track->IsEMCAL()) reducedParticle->fCaloClusterId = track->GetEMCALcluster();
451 if(track->IsPHOS()) reducedParticle->fCaloClusterId = track->GetPHOScluster();
454 AliAODTrack *track=static_cast<AliAODTrack*>(particle);
455 reducedParticle->fTrackId = track->GetID();
456 if(track->IsEMCAL()) reducedParticle->fCaloClusterId = track->GetEMCALcluster();
457 if(track->IsPHOS()) reducedParticle->fCaloClusterId = track->GetPHOScluster();
460 fReducedEvent->fNtracks[1] += 1;
465 //_________________________________________________________________________________
466 void AliAnalysisTaskReducedTree::FillDielectronPairInfo(AliDielectron* die, Short_t iDie)
469 // fill reduced pair information
471 Bool_t hasMC=AliDielectronMC::Instance()->HasMC();
473 for(Int_t iType=0; iType<3; ++iType) {
475 const TObjArray* array = die->GetPairArray(iType);
476 if(!array || array->GetEntriesFast()==0) continue;
478 for(Int_t iCandidate=0; iCandidate<array->GetEntriesFast(); ++iCandidate) {
479 AliDielectronPair* pair = (AliDielectronPair*)array->At(iCandidate);
480 Double_t values[AliDielectronVarManager::kNMaxValues];
481 AliDielectronVarManager::Fill(pair, values);
483 TClonesArray& tracks = *(fReducedEvent->fCandidates);
484 AliReducedPair *reducedParticle=
485 new (tracks[fReducedEvent->fNV0candidates[1]+fReducedEvent->fNDielectronCandidates]) AliReducedPair();
486 // !!! hardcoded flag for dielectron id
487 reducedParticle->fCandidateId = (iDie==0 ? AliReducedPair::kJpsiToEE : AliReducedPair::kPhiToKK);
488 reducedParticle->fPairType = (Char_t)values[AliDielectronVarManager::kPairType];
489 reducedParticle->fLegIds[0] = (UShort_t)(static_cast<AliVTrack*>(pair->GetFirstDaughter()))->GetID();
490 reducedParticle->fLegIds[1] = (UShort_t)(static_cast<AliVTrack*>(pair->GetSecondDaughter()))->GetID();
491 reducedParticle->fMass[0] = values[AliDielectronVarManager::kM];
492 reducedParticle->fMass[1] = -999.;
493 reducedParticle->fMass[2] = -999.;
494 reducedParticle->fPhi = values[AliDielectronVarManager::kPhi]; // in the [-pi,pi] interval
495 if(reducedParticle->fPhi<0.0) reducedParticle->fPhi = 2.0*TMath::Pi() + reducedParticle->fPhi; // converted to [0,2pi]
496 reducedParticle->fPt = values[AliDielectronVarManager::kPt];
497 reducedParticle->fEta = values[AliDielectronVarManager::kEta];
498 reducedParticle->fLxy = values[AliDielectronVarManager::kPseudoProperTime];
499 reducedParticle->fLxyErr = values[AliDielectronVarManager::kPseudoProperTimeErr];
500 reducedParticle->fOpeningAngle = values[AliDielectronVarManager::kOpeningAngle];
502 reducedParticle->fMCid = 0;
504 AliDielectronMC::Instance()->ConnectMCEvent();
505 const TObjArray* mcSignals = die->GetMCSignals();
506 for(Int_t iSig=0; iSig<mcSignals->GetEntries(); ++iSig) {
508 AliDielectronMC *mc=AliDielectronMC::Instance();
509 if(mc->IsMCTruth(pair, (AliDielectronSignalMC*)mcSignals->At(iSig))) {
510 reducedParticle->fMCid = reducedParticle->fMCid | (1<<iSig);
514 fReducedEvent->fNDielectronCandidates += 1;
515 } // end loop over candidates
516 } // end loop over pair type
520 //_________________________________________________________________________________
521 void AliAnalysisTaskReducedTree::FillV0PairInfo()
524 // fill reduced pair information
526 AliESDEvent* esd = (AliESDEvent*)InputEvent();
527 const AliESDVertex *primaryVertex = esd->GetPrimaryVertex();
528 AliKFVertex primaryVertexKF(*primaryVertex);
530 fReducedEvent->fNV0candidates[0] = InputEvent()->GetNumberOfV0s();
532 Double_t valuesPos[AliDielectronVarManager::kNMaxValues];
533 Double_t valuesNeg[AliDielectronVarManager::kNMaxValues];
535 for(Int_t iV0=0; iV0<InputEvent()->GetNumberOfV0s(); ++iV0) { // loop over V0s
536 AliESDv0 *v0 = esd->GetV0(iV0);
538 AliESDtrack* legPos = esd->GetTrack(v0->GetPindex());
539 AliESDtrack* legNeg = esd->GetTrack(v0->GetNindex());
541 if(legPos->GetSign() == legNeg->GetSign()) {
545 Bool_t v0ChargesAreCorrect = (legPos->GetSign()==+1 ? kTRUE : kFALSE);
546 legPos = (!v0ChargesAreCorrect ? esd->GetTrack(v0->GetNindex()) : legPos);
547 legNeg = (!v0ChargesAreCorrect ? esd->GetTrack(v0->GetPindex()) : legNeg);
549 // apply the K0s filter
550 Bool_t goodK0s = kTRUE;
551 if(fK0sPionCuts && (!fK0sPionCuts->IsSelected(legPos) || !fK0sPionCuts->IsSelected(legNeg))) goodK0s = kFALSE;
555 k0sList.Add(legPos); k0sList.Add(legNeg);
556 k0sList.Add(const_cast<AliESDVertex*>(primaryVertex));
557 if(!fK0sCuts->IsSelected(&k0sList)) goodK0s = kFALSE;
560 // apply the lambda filter
561 Bool_t goodLambda = kTRUE;
562 if(fLambdaProtonCuts && !fLambdaProtonCuts->IsSelected(legPos)) goodLambda = kFALSE;
563 if(fLambdaPionCuts && !fLambdaPionCuts->IsSelected(legNeg)) goodLambda = kFALSE;
564 Bool_t goodALambda = kTRUE;
565 if(fLambdaProtonCuts && !fLambdaProtonCuts->IsSelected(legNeg)) goodALambda = kFALSE;
566 if(fLambdaPionCuts && !fLambdaPionCuts->IsSelected(legPos)) goodALambda = kFALSE;
570 lambdaList.Add(legPos); lambdaList.Add(legNeg);
571 lambdaList.Add(const_cast<AliESDVertex*>(primaryVertex));
572 if(!fLambdaCuts->IsSelected(&lambdaList)) {goodLambda = kFALSE; goodALambda = kFALSE;}
575 if(!(goodK0s || goodLambda || goodALambda)) continue;
577 // Fill the V0 information into the tree for 3 hypothesis: K0s, Lambda, Anti-Lambda
578 AliReducedPair* k0sReducedPair = FillV0PairInfo(v0, AliReducedPair::kK0sToPiPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
579 AliReducedPair* lambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kLambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
580 AliReducedPair* alambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kALambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
582 if(goodK0s && k0sReducedPair->fMass[0]>fK0sMassRange[0] && k0sReducedPair->fMass[0]<fK0sMassRange[1]) {
583 TClonesArray& tracks = *(fReducedEvent->fCandidates);
584 AliReducedPair *goodK0sPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*k0sReducedPair);
585 goodK0sPair->fMass[0] = k0sReducedPair->fMass[0];
586 goodK0sPair->fMass[1] = lambdaReducedPair->fMass[0];
587 goodK0sPair->fMass[2] = alambdaReducedPair->fMass[0];
588 fReducedEvent->fNV0candidates[1] += 1;
589 } else {goodK0s=kFALSE;}
590 if(goodLambda && lambdaReducedPair->fMass[0]>fLambdaMassRange[0] && lambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
591 TClonesArray& tracks = *(fReducedEvent->fCandidates);
592 AliReducedPair *goodLambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*lambdaReducedPair);
593 fReducedEvent->fNV0candidates[1] += 1;
594 goodLambdaPair->fMass[0] = k0sReducedPair->fMass[0];
595 goodLambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
596 goodLambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
597 } else {goodLambda=kFALSE;}
598 if(goodALambda && alambdaReducedPair->fMass[0]>fLambdaMassRange[0] && alambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
599 TClonesArray& tracks = *(fReducedEvent->fCandidates);
600 AliReducedPair *goodALambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*alambdaReducedPair);
601 fReducedEvent->fNV0candidates[1] += 1;
602 goodALambdaPair->fMass[0] = k0sReducedPair->fMass[0];
603 goodALambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
604 goodALambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
605 } else {goodALambda = kFALSE;}
606 delete k0sReducedPair;
607 delete lambdaReducedPair;
608 delete alambdaReducedPair;
610 if(!(goodK0s || goodLambda || goodALambda)) continue;
612 // Fill histograms and the CF container
613 AliDielectronVarManager::Fill(legPos, valuesPos);
614 AliDielectronVarManager::Fill(legNeg, valuesNeg);
616 if(fV0Histos && fV0Histos->GetHistogramList()->FindObject("V0Track_Pos"))
617 fV0Histos->FillClass("V0Track_Pos", AliDielectronVarManager::kNMaxValues, valuesPos);
618 if(fV0Histos && fV0Histos->GetHistogramList()->FindObject("V0Track_Neg"))
619 fV0Histos->FillClass("V0Track_Neg", AliDielectronVarManager::kNMaxValues, valuesNeg);
620 } // end loop over V0s
624 //_________________________________________________________________________________
625 AliReducedPair* AliAnalysisTaskReducedTree::FillV0PairInfo(AliESDv0* v0, Int_t id,
626 AliESDtrack* legPos, AliESDtrack* legNeg,
627 AliKFVertex* vtxKF, Bool_t chargesAreCorrect) {
629 // Create a reduced V0 object and fill it
631 AliReducedPair* reducedPair=new AliReducedPair();
632 reducedPair->fCandidateId = id;
633 reducedPair->fPairType = v0->GetOnFlyStatus(); // on the fly status
634 //reducedPair->fOnTheFly = v0->GetOnFlyStatus();
635 reducedPair->fLegIds[0] = legPos->GetID();
636 reducedPair->fLegIds[1] = legNeg->GetID();
637 if(!reducedPair->fPairType) { // offline
638 UInt_t pidPos = AliPID::kPion;
639 if(id==AliReducedPair::kLambda0ToPPi) pidPos = AliPID::kProton;
640 UInt_t pidNeg = AliPID::kPion;
641 if(id==AliReducedPair::kALambda0ToPPi) pidNeg = AliPID::kProton;
642 reducedPair->fMass[0] = v0->GetEffMass(pidPos, pidNeg);
643 reducedPair->fPhi = v0->Phi();
644 if(reducedPair->fPhi<0.0) reducedPair->fPhi = 2.0*TMath::Pi() + reducedPair->fPhi; // converted to [0,2pi]
645 reducedPair->fPt = v0->Pt();
646 reducedPair->fEta = v0->Eta();
647 reducedPair->fLxy = 0.0; //TODO
648 reducedPair->fOpeningAngle = 0.0;
651 const AliExternalTrackParam *negHelix=v0->GetParamN();
652 const AliExternalTrackParam *posHelix=v0->GetParamP();
653 if(!chargesAreCorrect) {
654 negHelix = v0->GetParamP();
655 posHelix = v0->GetParamN();
657 AliKFParticle negKF(*(negHelix),(id==AliReducedPair::kALambda0ToPPi ? -2212 : -211));
658 AliKFParticle posKF(*(posHelix),(id==AliReducedPair::kLambda0ToPPi ? +2212 : +211));
659 AliKFParticle v0Refit;
662 Double_t massFit=0.0, massErrFit=0.0;
663 v0Refit.GetMass(massFit,massErrFit);
664 reducedPair->fMass[0] = massFit;
665 reducedPair->fPhi = v0Refit.GetPhi();
666 if(reducedPair->fPhi<0.0) reducedPair->fPhi = 2.0*TMath::Pi() + reducedPair->fPhi; // converted to [0,2pi]
667 reducedPair->fPt = v0Refit.GetPt();
668 reducedPair->fEta = v0Refit.GetEta();
669 reducedPair->fLxy = v0Refit.GetPseudoProperDecayTime(*vtxKF, massFit);
670 reducedPair->fOpeningAngle = negKF.GetAngle(posKF);
676 //_________________________________________________________________________________
677 UChar_t AliAnalysisTaskReducedTree::EncodeTPCClusterMap(AliESDtrack* track) {
679 // Encode the TPC cluster map into an UChar_t
680 // Divide the 159 bits from the bit map into 8 groups of adiacent clusters
681 // For each group enable its corresponding bit if in that group there are more clusters compared to
684 const UChar_t threshold=5;
685 TBits tpcClusterMap = track->GetTPCClusterMap();
689 for(UChar_t i=0; i<8; ++i) {
691 for(j=i*20; j<(i+1)*20 && j<159; ++j) n+=tpcClusterMap.TestBitNumber(j);
692 if(n>=threshold) map |= (1<<i);
698 //_________________________________________________________________________________
699 void AliAnalysisTaskReducedTree::FinishTaskOutput()
704 //fTreeFile->Write();
705 //fTreeFile->Close();