From 6ab32c51ca9374a91bb530b375f91a7a5b285a56 Mon Sep 17 00:00:00 2001 From: jbook Date: Mon, 19 Aug 2013 13:33:22 +0000 Subject: [PATCH] - updates by Ionut to the reduced tree event --- .../dielectron/AliAnalysisTaskReducedTree.cxx | 325 +++++++++++++++-- PWGDQ/dielectron/AliAnalysisTaskReducedTree.h | 7 +- PWGDQ/dielectron/AliReducedEvent.cxx | 338 ++++++++++++++++-- PWGDQ/dielectron/AliReducedEvent.h | 168 ++++++++- 4 files changed, 770 insertions(+), 68 deletions(-) diff --git a/PWGDQ/dielectron/AliAnalysisTaskReducedTree.cxx b/PWGDQ/dielectron/AliAnalysisTaskReducedTree.cxx index f96145e4571..398a2e43121 100644 --- a/PWGDQ/dielectron/AliAnalysisTaskReducedTree.cxx +++ b/PWGDQ/dielectron/AliAnalysisTaskReducedTree.cxx @@ -32,13 +32,18 @@ #include #include #include +#include +#include #include +#include +#include #include #include #include #include #include #include +#include #include #include #include @@ -76,6 +81,9 @@ AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree() : fFillLambda(kTRUE), fFillALambda(kTRUE), fFillCaloClusterInfo(kTRUE), + fFillFMDSectorInfo(kFALSE), + fFillFMDChannelInfo(kFALSE), + //fFillCorrectedFMDInfo(kTRUE), fFillFriendInfo(kTRUE), fEventFilter(0x0), fTrackFilter(0x0), @@ -121,6 +129,9 @@ AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree(const char *name) : fFillLambda(kTRUE), fFillALambda(kTRUE), fFillCaloClusterInfo(kTRUE), + fFillFMDSectorInfo(kFALSE), + fFillFMDChannelInfo(kFALSE), + //fFillCorrectedFMDInfo(kTRUE), fFillFriendInfo(kTRUE), fEventFilter(0x0), fTrackFilter(0x0), @@ -153,6 +164,7 @@ AliAnalysisTaskReducedTree::AliAnalysisTaskReducedTree(const char *name) : fGammaMassRange[0] = 0.0; fGammaMassRange[1] = 0.1; DefineInput(0,TChain::Class()); + //DefineInput(2,AliAODForwardMult::Class()); DefineOutput(1, TList::Class()); // QA histograms DefineOutput(2, TTree::Class()); // reduced information tree //if(fFillFriendInfo) DefineOutput(3, TTree::Class()); // reduced information tree with friends @@ -233,7 +245,47 @@ void AliAnalysisTaskReducedTree::UserExec(Option_t *option) if(isSelected==0) { return; } +/* + cout<<"get AOD"<FindListObject("Forward"); + if (!obj) return; + cout<<"got AOD forward"<(obj); + + //if (!aodForward->CheckEvent(mask,ipZmin,ipZmax,cMin,cMax)) return 0; + Double_t ret = 0; + const TH2D& d2Ndetadphi = aodForward->GetHistogram(); + + + cout<GetNbins()<FindListObject("Forward"); +// if (!obj) return;} +// +// aodForward = static_cast(obj); +// +// //if (!aodForward->CheckE vent(fTriggerMask,ipZmin,ipZmax,cMin,cMax)) return 0; +// +// const TH2D& d2Ndetadphi = aodForward->GetHistogram(); + + // fill event histograms before event filter Double_t values[AliDielectronVarManager::kNMaxValues]={0}; AliDielectronVarManager::Fill(InputEvent(),values); @@ -267,6 +319,7 @@ void AliAnalysisTaskReducedTree::UserExec(Option_t *option) fReducedEvent->ClearEvent(); if(fFillFriendInfo) fReducedEventFriend->ClearEvent(); FillEventInfo(); + //if(fFillCorrectedFMDInfo) FillCorrectedFMDInfo(d2Ndetadphi); //Fill corrected FMD info if(fFillV0Info) FillV0PairInfo(); Short_t idie=0; @@ -328,6 +381,7 @@ void AliAnalysisTaskReducedTree::FillEventInfo() fReducedEvent->fTriggerMask = event->GetTriggerMask(); fReducedEvent->fIsPhysicsSelection = (isSelected!=0 ? kTRUE : kFALSE); fReducedEvent->fIsSPDPileup = event->IsPileupFromSPD(3,0.8,3.,2.,5.); + fReducedEvent->fIsSPDPileupMultBins = event->IsPileupFromSPDInMultBins(); AliVVertex* eventVtx = 0x0; if(isESD) eventVtx = const_cast(esdEvent->GetPrimaryVertexTracks()); if(isAOD) eventVtx = const_cast(aodEvent->GetPrimaryVertex()); @@ -339,6 +393,12 @@ void AliAnalysisTaskReducedTree::FillEventInfo() } if(isESD) { eventVtx = const_cast(esdEvent->GetPrimaryVertexTPC()); + fReducedEvent->fEventNumberInFile = esdEvent->GetEventNumberInFile(); + fReducedEvent->fL0TriggerInputs = esdEvent->GetHeader()->GetL0TriggerInputs(); + fReducedEvent->fL1TriggerInputs = esdEvent->GetHeader()->GetL1TriggerInputs(); + fReducedEvent->fL2TriggerInputs = esdEvent->GetHeader()->GetL2TriggerInputs(); + fReducedEvent->fIRIntClosestIntMap[0] = esdEvent->GetHeader()->GetIRInt1ClosestInteractionMap(); + fReducedEvent->fIRIntClosestIntMap[1] = esdEvent->GetHeader()->GetIRInt2ClosestInteractionMap(); if(eventVtx) { fReducedEvent->fVtxTPC[0] = ((AliESDVertex*)eventVtx)->GetXv(); fReducedEvent->fVtxTPC[1] = ((AliESDVertex*)eventVtx)->GetYv(); @@ -354,11 +414,19 @@ void AliAnalysisTaskReducedTree::FillEventInfo() AliESDZDC* zdc = esdEvent->GetESDZDC(); if(zdc) { - for(Int_t i=0; i<4; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN1TowerEnergy()[i]; - for(Int_t i=4; i<8; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN2TowerEnergy()[i-4]; + for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN1TowerEnergy()[i]; + for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZN2TowerEnergy()[i-5]; + for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZP1TowerEnergy()[i]; + for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZP2TowerEnergy()[i-5]; } } if(isAOD) { + fReducedEvent->fIRIntClosestIntMap[0] = aodEvent->GetHeader()->GetIRInt1ClosestInteractionMap(); + fReducedEvent->fIRIntClosestIntMap[1] = aodEvent->GetHeader()->GetIRInt2ClosestInteractionMap(); + fReducedEvent->fEventNumberInFile = aodEvent->GetHeader()->GetEventNumberESDFile(); + fReducedEvent->fL0TriggerInputs = aodEvent->GetHeader()->GetL0TriggerInputs(); + fReducedEvent->fL1TriggerInputs = aodEvent->GetHeader()->GetL1TriggerInputs(); + fReducedEvent->fL2TriggerInputs = aodEvent->GetHeader()->GetL2TriggerInputs(); fReducedEvent->fTimeStamp = 0; fReducedEvent->fNpileupSPD = aodEvent->GetNumberOfPileupVerticesSPD(); fReducedEvent->fNpileupTracks = aodEvent->GetNumberOfPileupVerticesTracks(); @@ -368,11 +436,48 @@ void AliAnalysisTaskReducedTree::FillEventInfo() AliAODZDC* zdc = aodEvent->GetZDCData(); if(zdc) { - for(Int_t i=0; i<4; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNATowerEnergy()[i]; - for(Int_t i=4; i<8; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNCTowerEnergy()[i-4]; + for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNATowerEnergy()[i]; + for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCnEnergy[i] = zdc->GetZNCTowerEnergy()[i-5]; + for(Int_t i=0; i<5; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZPATowerEnergy()[i]; + for(Int_t i=5; i<10; ++i) fReducedEvent->fZDCpEnergy[i] = zdc->GetZPCTowerEnergy()[i-5]; + } + } + + // Fill TZERO information + if(isESD) { + const AliESDTZERO* tzero = esdEvent->GetESDTZERO(); + if(tzero) { + fReducedEvent->fT0start = tzero->GetT0(); + fReducedEvent->fT0zVertex = tzero->GetT0zVertex(); + for(Int_t i = 0;i<24;i++) + fReducedEvent->fT0amplitude[i] = tzero->GetT0amplitude()[i]; + for(Int_t i = 0;i<3;i++) + fReducedEvent->fT0TOF[i] = tzero->GetT0TOF()[i]; + for(Int_t i = 0;i<3;i++) + fReducedEvent->fT0TOFbest[i] = tzero->GetT0TOFbest()[i]; + fReducedEvent->fT0pileup = tzero->GetPileupFlag(); + fReducedEvent->fT0sattelite = tzero->GetSatellite(); + } + } + if(isAOD) { + AliAODTZERO* tzero = aodEvent->GetTZEROData(); + if(tzero) { + fReducedEvent->fT0start = -999.; // not available + fReducedEvent->fT0zVertex = tzero->GetT0zVertex(); + for(Int_t i = 0;i<26;i++) + fReducedEvent->fT0amplitude[i] = tzero->GetAmp(i); + for(Int_t i = 0;i<3;i++) + fReducedEvent->fT0TOF[i] = tzero->GetT0TOF()[i]; + for(Int_t i = 0;i<3;i++) + fReducedEvent->fT0TOFbest[i] = tzero->GetT0TOFbest()[i]; + fReducedEvent->fT0pileup = tzero->GetPileupFlag(); + fReducedEvent->fT0sattelite = tzero->GetSatellite(); } } + if(fFillFMDChannelInfo&&isESD) fReducedEvent->fIsFMDReduced = kFALSE; + if((fFillFMDSectorInfo||fFillFMDChannelInfo)&&isESD) FillFMDInfo(); + AliCentrality *centrality = event->GetCentrality(); if(centrality) { fReducedEvent->fCentrality[0] = centrality->GetCentralityPercentile("V0M"); @@ -386,8 +491,8 @@ void AliAnalysisTaskReducedTree::FillEventInfo() fReducedEvent->fNtracks[0] = event->GetNumberOfTracks(); fReducedEvent->fSPDntracklets = GetSPDTrackletMultiplicity(event, -1.0, 1.0); - for(Int_t ieta=0; ieta<16; ++ieta) - fReducedEvent->fSPDntrackletsEta[ieta] = GetSPDTrackletMultiplicity(event, -1.6+0.2*ieta, -1.6+0.2*(ieta+1)); + for(Int_t ieta=0; ieta<32; ++ieta) + fReducedEvent->fSPDntrackletsEta[ieta] = GetSPDTrackletMultiplicity(event, -1.6+0.1*ieta, -1.6+0.1*(ieta+1)); AliVVZERO* vzero = event->GetVZEROData(); for(Int_t i=0;i<64;++i) @@ -442,6 +547,129 @@ void AliAnalysisTaskReducedTree::FillFriendEventInfo() { } +//_________________________________________________________________________________ +void AliAnalysisTaskReducedTree::FillFMDInfo() +{ + // + // fill reduced FMD information + // + AliVEvent* event = InputEvent(); + Bool_t isESD = (event->IsA()==AliESDEvent::Class()); + + if(!isESD) return; + + AliESDEvent* esdEvent = 0x0; + if(isESD) esdEvent = static_cast(event); + + AliESDFMD* esdFmd = esdEvent->GetFMDData(); + //const AliFMDFloatMap multMap = esdFmd->MultiplicityMap(); + //const AliFMDFloatMap etaMap = esdFmd->EtaMap(); + + //esdFmd->Print(); + Int_t nFMD=0; + Int_t id=-1; + Int_t maxDet=3; + Int_t maxRing=2; + Int_t maxSector; + Int_t maxStrip; + Float_t m=0.0; + Double_t phi; + Char_t ring; + Float_t fmdMult; + Float_t msum=0; + UShort_t fmdDet=0; + Int_t phiBin=0; + + for(UShort_t det = 1; det <= maxDet; ++det) { + (det == 1 ? maxRing=1 : maxRing=2); + for(UShort_t ir = 0; ir < maxRing; ++ir) { + ring = (ir == 0 ? 'I' : 'O'); + (ir == 0 ? maxSector=20 : maxSector=40); + (ir == 0 ? maxStrip=512 : maxStrip=256); + nFMD=-1; + for(UShort_t sec = 0; sec < maxSector; ++sec) { + phi = esdFmd->Phi(det, ring, sec, 0)/180.*TMath::Pi(); + phiBin = Int_t (phi/2/TMath::Pi()*maxSector); + fmdMult = 0; + for(UShort_t str = 0; str < maxStrip; ++str) { + ++id; + m = esdFmd->Multiplicity(det, ring, sec, str); + //cout << "det/ir/sec/str/m :: " << det << "/" << ir << "/" << sec << "/" << str << "/" << m << endl; + if(fFillFMDChannelInfo) + if(m<1.e-6) continue; + if(m == AliESDFMD::kInvalidMult) m=0; + fmdMult += m; + msum+=m; + ++nFMD; + + if(fFillFMDChannelInfo){ + if(m>15.) m=15.; + m = UShort_t(m*4369+0.5); + TClonesArray& fmd = *(fReducedEvent->GetFMD(fmdDet)); + AliReducedFMD *reducedFMD=new(fmd[nFMD]) AliReducedFMD(); + fReducedEvent->fNFMDchannels[fmdDet] += 1; + reducedFMD->fMultiplicity = m; + //reducedFMD->fEta = esdFmd->Eta(det, ring, 0, str); + reducedFMD->fId = id; + } + } // end loop over strips + + if(fFillFMDSectorInfo) { + TClonesArray& fmd = *(fReducedEvent->GetFMD(fmdDet)); + AliReducedFMD *reducedFMD=new(fmd[phiBin]) AliReducedFMD(); + reducedFMD->fMultiplicity = fmdMult; + fReducedEvent->fNFMDchannels[fmdDet] += 1; + //cout<fFMDtotalMult[fmdDet] = msum; + msum=0.0; + ++fmdDet; + id=-1; + } // end loop over rings + } // end loop over detectors +} + +////_________________________________________________________________________________ +//void AliAnalysisTaskReducedTree::FillCorrectedFMDInfo(const TH2D& fmdhist) +//{ +// +// +//Int_t nEta = fmdhist.GetXaxis()->GetNbins(); +//Int_t nPhi = fmdhist.GetYaxis()->GetNbins(); +////Int_t nBins= fmdhist.GetNbins(); +//Float_t eta=0.0; +//Float_t phi=0.0; +//Float_t mult=0.0; +// +// +//Int_t nFMD=0; +////fReducedEvent->fNCorFmdChannels = 0; +//for (Int_t e = 1; e <= nEta; e++) { +// eta = fmdhist.GetXaxis()->GetBinCenter(e); +// for (Int_t p = 1; p <= nPhi; p++) { +// phi = fmdhist.GetYaxis()->GetBinCenter(p); +// mult = fmdhist.GetBinContent(e, p); +// //TClonesArray& Corfmd = *(fReducedEvent->fCorFMD); +// //AliReducedFMD *reducedCorFMD=new(Corfmd[nFMD]) AliReducedCorFMD(); +// std::cout<fNCorFmdChannels += 1; +// nFMD += 1; +////reducedFMD->fCorMultiplicity = mult; +////reducedFMD->fCorEta = eta; +////reducedFMD->fCorPhi = phi; +// +// +//} +// +// +//} + + //_________________________________________________________________________________ void AliAnalysisTaskReducedTree::FillTrackInfo() { @@ -458,16 +686,30 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() // find all the tracks which belong to a V0 stored in the reduced event UShort_t trackIdsV0[4][20000]={{0}}; - Int_t nV0LegsTagged[4] = {0}; + UShort_t trackIdsPureV0[4][20000]={{0}}; + Int_t nV0LegsTagged[4] = {0}; Int_t nPureV0LegsTagged[4] = {0}; Bool_t leg1Found[4]; Bool_t leg2Found[4]; for(Int_t iv0=0;iv0fNV0candidates[1];++iv0) { AliReducedPair* pair = fReducedEvent->GetV0Pair(iv0); if(!pair) continue; - Int_t pairId = 0; - if(pair->fCandidateId==AliReducedPair::kGammaConv) pairId=0; - if(pair->fCandidateId==AliReducedPair::kK0sToPiPi) pairId=1; - if(pair->fCandidateId==AliReducedPair::kLambda0ToPPi) pairId=2; - if(pair->fCandidateId==AliReducedPair::kALambda0ToPPi) pairId=3; + Int_t pairId = 0; Bool_t isPureV0 = kFALSE; + if(pair->fCandidateId==AliReducedPair::kGammaConv) { + pairId=0; + if(pair->IsPureV0Gamma()) isPureV0 = kTRUE; + } + if(pair->fCandidateId==AliReducedPair::kK0sToPiPi) { + pairId=1; + if(pair->IsPureV0K0s()) isPureV0 = kTRUE; + } + if(pair->fCandidateId==AliReducedPair::kLambda0ToPPi) { + pairId=2; + if(pair->IsPureV0Lambda()) isPureV0 = kTRUE; + } + if(pair->fCandidateId==AliReducedPair::kALambda0ToPPi) { + pairId=3; + if(pair->IsPureV0ALambda()) isPureV0 = kTRUE; + } + leg1Found[pairId] = kFALSE; leg2Found[pairId] = kFALSE; for(Int_t it=0;itfLegIds[0]) leg1Found[pairId]=kTRUE; @@ -476,6 +718,17 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() // if the legs of this V0 were not already stored then add them now to the list if(!leg1Found[pairId]) {trackIdsV0[pairId][nV0LegsTagged[pairId]] = pair->fLegIds[0]; ++nV0LegsTagged[pairId];} if(!leg2Found[pairId]) {trackIdsV0[pairId][nV0LegsTagged[pairId]] = pair->fLegIds[1]; ++nV0LegsTagged[pairId];} + + if(isPureV0) { + leg1Found[pairId] = kFALSE; leg2Found[pairId] = kFALSE; + for(Int_t it=0;itfLegIds[0]) leg1Found[pairId]=kTRUE; + if(trackIdsPureV0[pairId][it]==pair->fLegIds[1]) leg2Found[pairId]=kTRUE; + } + // if the legs of this pure V0 were not already stored then add them now to the list + if(!leg1Found[pairId]) {trackIdsPureV0[pairId][nPureV0LegsTagged[pairId]] = pair->fLegIds[0]; ++nPureV0LegsTagged[pairId];} + if(!leg2Found[pairId]) {trackIdsPureV0[pairId][nPureV0LegsTagged[pairId]] = pair->fLegIds[1]; ++nPureV0LegsTagged[pairId];} + } } // find all the tracks which belong to a stored dielectron pair @@ -496,7 +749,10 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() AliESDtrack* esdTrack=0; AliAODTrack* aodTrack=0; Int_t ntracks=event->GetNumberOfTracks(); - Int_t trackId = 0; Bool_t usedForV0[4] = {kFALSE}; Bool_t usedForV0Or = kFALSE; + Int_t trackId = 0; + Bool_t usedForV0[4] = {kFALSE}; + Bool_t usedForPureV0[4] = {kFALSE}; + Bool_t usedForV0Or = kFALSE; Bool_t usedForDielectron = kFALSE; for(Int_t itrack=0; itrackGetTrack(itrack); @@ -519,7 +775,15 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() break; } } - usedForV0Or |= usedForV0[i]; + usedForV0Or = usedForV0Or || usedForV0[i]; + usedForPureV0[i] = kFALSE; + for(Int_t ii=0; iifMomentumInner = values[AliDielectronVarManager::kPIn]; reducedParticle->fDCA[0] = values[AliDielectronVarManager::kImpactParXY]; reducedParticle->fDCA[1] = values[AliDielectronVarManager::kImpactParZ]; + reducedParticle->fTrackLength = values[AliDielectronVarManager::kTrackLength]; reducedParticle->fITSclusterMap = (UChar_t)values[AliDielectronVarManager::kITSclusterMap]; reducedParticle->fITSsignal = values[AliDielectronVarManager::kITSsignal]; @@ -562,31 +827,35 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() reducedParticle->fITSnSig[1] = values[AliDielectronVarManager::kITSnSigmaPio]; reducedParticle->fITSnSig[2] = values[AliDielectronVarManager::kITSnSigmaKao]; reducedParticle->fITSnSig[3] = values[AliDielectronVarManager::kITSnSigmaPro]; + reducedParticle->fITSchi2 = values[AliDielectronVarManager::kITSchi2Cl]; reducedParticle->fTPCNcls = (UChar_t)values[AliDielectronVarManager::kNclsTPC]; reducedParticle->fTPCNclsF = (UChar_t)values[AliDielectronVarManager::kNFclsTPC]; reducedParticle->fTPCNclsIter1 = (UChar_t)values[AliDielectronVarManager::kNclsTPCiter1]; reducedParticle->fTPCsignal = values[AliDielectronVarManager::kTPCsignal]; + reducedParticle->fTPCsignalN = values[AliDielectronVarManager::kTPCsignalN]; reducedParticle->fTPCnSig[0] = values[AliDielectronVarManager::kTPCnSigmaEle]; reducedParticle->fTPCnSig[1] = values[AliDielectronVarManager::kTPCnSigmaPio]; reducedParticle->fTPCnSig[2] = values[AliDielectronVarManager::kTPCnSigmaKao]; reducedParticle->fTPCnSig[3] = values[AliDielectronVarManager::kTPCnSigmaPro]; reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(particle, isAOD); + reducedParticle->fTPCchi2 = values[AliDielectronVarManager::kTPCchi2Cl]; reducedParticle->fTOFbeta = values[AliDielectronVarManager::kTOFbeta]; reducedParticle->fTOFnSig[0] = values[AliDielectronVarManager::kTOFnSigmaEle]; reducedParticle->fTOFnSig[1] = values[AliDielectronVarManager::kTOFnSigmaPio]; reducedParticle->fTOFnSig[2] = values[AliDielectronVarManager::kTOFnSigmaKao]; reducedParticle->fTOFnSig[3] = values[AliDielectronVarManager::kTOFnSigmaPro]; - + Double_t trdProbab[AliPID::kSPECIES]={0.0}; if(fFlowTrackFilter) { // switch on the first bit if this particle should be used for the event plane - if(fFlowTrackFilter->IsSelected(particle)) reducedParticle->fFlags |= (1<<0); + if(fFlowTrackFilter->IsSelected(particle)) reducedParticle->fFlags |= (UShort_t(1)<<0); } for(Int_t iV0type=0;iV0type<4;++iV0type) { - if(usedForV0[iV0type]) reducedParticle->fFlags |= (1<<(iV0type+1)); + if(usedForV0[iV0type]) reducedParticle->fFlags |= (UShort_t(1)<<(iV0type+1)); + if(usedForPureV0[iV0type]) reducedParticle->fFlags |= (UShort_t(1)<<(iV0type+8)); } if(isESD){ @@ -594,23 +863,33 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() reducedParticle->fTrackId = (UShort_t)esdTrack->GetID(); reducedParticle->fTPCCrossedRows = (UChar_t)esdTrack->GetTPCCrossedRows(); //reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(esdTrack); - const AliExternalTrackParam* tpcInner = esdTrack->GetTPCInnerParam(); + const AliExternalTrackParam* tpcInner = esdTrack->GetInnerParam(); reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0); reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0); reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0); + reducedParticle->fTOFdeltaBC = esdTrack->GetTOFDeltaBC(); + reducedParticle->fTRDntracklets[0] = esdTrack->GetTRDntracklets(); reducedParticle->fTRDntracklets[1] = esdTrack->GetTRDntrackletsPID(); - pidResponse->ComputeTRDProbability(esdTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D); + pidResponse->ComputeTRDProbability(esdTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ1D); reducedParticle->fTRDpid[0] = trdProbab[AliPID::kElectron]; reducedParticle->fTRDpid[1] = trdProbab[AliPID::kPion]; - + pidResponse->ComputeTRDProbability(esdTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D); + reducedParticle->fTRDpidLQ2D[0] = trdProbab[AliPID::kElectron]; + reducedParticle->fTRDpidLQ2D[1] = trdProbab[AliPID::kPion]; + for(Int_t idx=0; idx<3; ++idx) if(esdTrack->GetKinkIndex(idx)>0) reducedParticle->fFlags |= (1<<(5+idx)); if(esdTrack->IsEMCAL()) reducedParticle->fCaloClusterId = esdTrack->GetEMCALcluster(); if(esdTrack->IsPHOS()) reducedParticle->fCaloClusterId = esdTrack->GetPHOScluster(); } if(isAOD) { //AliAODTrack *track=static_cast(particle); + const AliExternalTrackParam* tpcInner = aodTrack->GetInnerParam(); + reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0); + reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0); + reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0); + reducedParticle->fTrackId = aodTrack->GetID(); reducedParticle->fITSsignal = aodTrack->GetITSsignal(); if(pidResponse) { @@ -621,9 +900,12 @@ void AliAnalysisTaskReducedTree::FillTrackInfo() } reducedParticle->fTRDntracklets[0] = aodTrack->GetTRDntrackletsPID(); reducedParticle->fTRDntracklets[1] = aodTrack->GetTRDntrackletsPID(); - pidResponse->ComputeTRDProbability(aodTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D); + pidResponse->ComputeTRDProbability(aodTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ1D); reducedParticle->fTRDpid[0] = trdProbab[AliPID::kElectron]; reducedParticle->fTRDpid[1] = trdProbab[AliPID::kPion]; + pidResponse->ComputeTRDProbability(aodTrack,AliPID::kSPECIES,trdProbab,AliTRDPIDResponse::kLQ2D); + reducedParticle->fTRDpidLQ2D[0] = trdProbab[AliPID::kElectron]; + reducedParticle->fTRDpidLQ2D[1] = trdProbab[AliPID::kPion]; if(aodTrack->IsEMCAL()) reducedParticle->fCaloClusterId = aodTrack->GetEMCALcluster(); if(aodTrack->IsPHOS()) reducedParticle->fCaloClusterId = aodTrack->GetPHOScluster(); @@ -856,7 +1138,6 @@ AliReducedPair* AliAnalysisTaskReducedTree::FillV0PairInfo(AliESDv0* v0, Int_t i AliReducedPair* reducedPair=new AliReducedPair(); reducedPair->fCandidateId = id; reducedPair->fPairType = v0->GetOnFlyStatus(); // on the fly status - //reducedPair->fOnTheFly = v0->GetOnFlyStatus(); reducedPair->fLegIds[0] = legPos->GetID(); reducedPair->fLegIds[1] = legNeg->GetID(); if(!reducedPair->fPairType) { // offline diff --git a/PWGDQ/dielectron/AliAnalysisTaskReducedTree.h b/PWGDQ/dielectron/AliAnalysisTaskReducedTree.h index 5b7b42402f4..f64210b897b 100644 --- a/PWGDQ/dielectron/AliAnalysisTaskReducedTree.h +++ b/PWGDQ/dielectron/AliAnalysisTaskReducedTree.h @@ -68,6 +68,8 @@ public: void SetFillLambda(Bool_t flag=kTRUE) {fFillLambda = flag;} void SetFillALambda(Bool_t flag=kTRUE) {fFillALambda = flag;} void SetFillCaloClusterInfo(Bool_t flag=kTRUE) {fFillCaloClusterInfo = flag;} + void SetFillFMDSectorInfo(Bool_t flag=kFALSE) {fFillFMDSectorInfo = flag;} + void SetFillFMDChannelInfo(Bool_t flag=kFALSE) {fFillFMDChannelInfo = flag;} void SetFillFriendInfo(Bool_t flag=kTRUE) {fFillFriendInfo = flag;} // Add dielectron objects to the list. These contain cuts and histogram definitions @@ -90,6 +92,8 @@ public: Bool_t fFillLambda; // fill the lambda V0s Bool_t fFillALambda; // fill the anti-lambda V0s Bool_t fFillCaloClusterInfo; // fill the calorimeter clusters + Bool_t fFillFMDSectorInfo; // fill the FMD info for every sector + Bool_t fFillFMDChannelInfo; // fill the FMD info for every channel Bool_t fFillFriendInfo; // fill friend tree information AliAnalysisCuts *fEventFilter; // event filter @@ -127,11 +131,12 @@ public: AliReducedPair* FillV0PairInfo(AliESDv0* v0, Int_t id, AliESDtrack* legPos, AliESDtrack* legNeg, AliKFVertex* vtxKF, Bool_t chargesAreCorrect); UChar_t EncodeTPCClusterMap(AliVParticle* track, Bool_t isAOD); void FillCaloClusters(); + void FillFMDInfo(); Int_t GetSPDTrackletMultiplicity(AliVEvent* event, Float_t lowEta, Float_t highEta); AliAnalysisTaskReducedTree(const AliAnalysisTaskReducedTree &c); AliAnalysisTaskReducedTree& operator= (const AliAnalysisTaskReducedTree &c); - ClassDef(AliAnalysisTaskReducedTree, 2); //Analysis Task for creating a reduced event information tree + ClassDef(AliAnalysisTaskReducedTree, 3); //Analysis Task for creating a reduced event information tree }; #endif diff --git a/PWGDQ/dielectron/AliReducedEvent.cxx b/PWGDQ/dielectron/AliReducedEvent.cxx index 892c70cb4fa..063716c4898 100644 --- a/PWGDQ/dielectron/AliReducedEvent.cxx +++ b/PWGDQ/dielectron/AliReducedEvent.cxx @@ -13,9 +13,11 @@ #include #include +#include ClassImp(AliReducedTrack) ClassImp(AliReducedPair) +ClassImp(AliReducedFMD) ClassImp(AliReducedEvent) ClassImp(AliReducedEventFriend) ClassImp(AliReducedCaloCluster) @@ -23,6 +25,11 @@ ClassImp(AliReducedCaloCluster) TClonesArray* AliReducedEvent::fgTracks = 0; TClonesArray* AliReducedEvent::fgCandidates = 0; TClonesArray* AliReducedEvent::fgCaloClusters = 0; +TClonesArray* AliReducedEvent::fgFMD1 = 0; +TClonesArray* AliReducedEvent::fgFMD2I = 0; +TClonesArray* AliReducedEvent::fgFMD2O = 0; +TClonesArray* AliReducedEvent::fgFMD3I = 0; +TClonesArray* AliReducedEvent::fgFMD3O = 0; //_______________________________________________________________________________ AliReducedTrack::AliReducedTrack() : @@ -36,20 +43,26 @@ AliReducedTrack::AliReducedTrack() : fTPCEta(0.0), fMomentumInner(0.0), fDCA(), + fTrackLength(0.0), fITSclusterMap(0), fITSsignal(0.0), fITSnSig(), + fITSchi2(0.0), fTPCNcls(0), fTPCCrossedRows(0), fTPCNclsF(0), fTPCNclsIter1(0), fTPCClusterMap(0), fTPCsignal(0), + fTPCsignalN(0), fTPCnSig(), + fTPCchi2(0.0), fTOFbeta(0.0), fTOFnSig(), + fTOFdeltaBC(0), fTRDntracklets(), fTRDpid(), + fTRDpidLQ2D(), fCaloClusterId(-999), fBayesPID(), fFlags(0), @@ -62,6 +75,7 @@ AliReducedTrack::AliReducedTrack() : for(Int_t i=0; i<4; ++i) {fTPCnSig[i]=-999.; fTOFnSig[i]=-999.; fITSnSig[i]=-999.;} for(Int_t i=0; i<3; ++i) {fBayesPID[i]=-999.;} fTRDpid[0]=-999.; fTRDpid[1]=-999.; + fTRDpidLQ2D[0] = -999.; fTRDpidLQ2D[1] = -999.; } @@ -129,16 +143,47 @@ AliReducedPair::~AliReducedPair() { // } + +//_______________________________________________________________________________ +AliReducedFMD::AliReducedFMD() : + fMultiplicity(0), + //fEta(0.0), + fId(0) +{ + AliReducedFMD::Class()->IgnoreTObjectStreamer(); + // + // Constructor + // +} + + +//_______________________________________________________________________________ +AliReducedFMD::~AliReducedFMD() +{ + // + // De-Constructor + // +} + + //____________________________________________________________________________ AliReducedEvent::AliReducedEvent() : TObject(), + fEventTag(0), + fEventNumberInFile(0), + fL0TriggerInputs(0), + fL1TriggerInputs(0), + fL2TriggerInputs(0), fRunNo(0), fBC(0), fTimeStamp(0), fEventType(0), fTriggerMask(0), fIsPhysicsSelection(kTRUE), - fIsSPDPileup(kTRUE), + fIsSPDPileup(kFALSE), + fIsSPDPileupMultBins(kFALSE), + fIRIntClosestIntMap(), + fIsFMDReduced(kTRUE), fVtx(), fNVtxContributors(0), fVtxTPC(), @@ -156,36 +201,65 @@ AliReducedEvent::AliReducedEvent() : fSPDntracklets(0), fVZEROMult(), fZDCnEnergy(), + fZDCpEnergy(), + fT0amplitude(), + fT0TOF(), + fT0TOFbest(), + fT0zVertex(0), + fT0start(0), + fT0pileup(kFALSE), + fT0sattelite(kFALSE), fTracks(0x0), fCandidates(0x0), + fNFMDchannels(), + fFMDtotalMult(), + fFMD1(0x0), + fFMD2I(0x0), + fFMD2O(0x0), + fFMD3I(0x0), + fFMD3O(0x0), fNCaloClusters(0), fCaloClusters(0x0) -//fFMDMult() { // // Constructor // + for(Int_t i=0; i<2; ++i) fIRIntClosestIntMap[i] = 0; for(Int_t i=0; i<3; ++i) {fVtx[i]=-999.; fVtxTPC[i]=-999.;} for(Int_t i=0; i<4; ++i) fCentrality[i]=-1.; fNV0candidates[0]=0; fNV0candidates[1]=0; fNtracks[0]=0; fNtracks[1]=0; - for(Int_t i=0; i<16; ++i) fSPDntrackletsEta[i]=0; + for(Int_t i=0; i<32; ++i) fSPDntrackletsEta[i]=0; for(Int_t i=0; i<32; ++i) fNtracksPerTrackingFlag[i]=0; for(Int_t i=0; i<64; ++i) fVZEROMult[i] = 0.0; - for(Int_t i=0; i<8; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCpEnergy[i]=0.0; + for(Int_t i=0; i<26; ++i) fT0amplitude[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOF[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOFbest[i]=0.0; + for(Int_t i=0; i<5; ++i) fNFMDchannels[i]=0.0; + for(Int_t i=0; i<5; ++i) fFMDtotalMult[i]=0.0; } //____________________________________________________________________________ AliReducedEvent::AliReducedEvent(const Char_t* /*name*/) : TObject(), + fEventTag(0), + fEventNumberInFile(0), + fL0TriggerInputs(0), + fL1TriggerInputs(0), + fL2TriggerInputs(0), fRunNo(0), fBC(0), fTimeStamp(0), fEventType(0), fTriggerMask(0), fIsPhysicsSelection(kTRUE), - fIsSPDPileup(kTRUE), + fIsSPDPileup(kFALSE), + fIsSPDPileupMultBins(kFALSE), + fIRIntClosestIntMap(), + fIsFMDReduced(kTRUE), fVtx(), fNVtxContributors(0), fVtxTPC(), @@ -203,8 +277,23 @@ AliReducedEvent::AliReducedEvent(const Char_t* /*name*/) : fSPDntracklets(0), fVZEROMult(), fZDCnEnergy(), + fZDCpEnergy(), + fT0amplitude(), + fT0TOF(), + fT0TOFbest(), + fT0zVertex(0), + fT0start(0), + fT0pileup(kFALSE), + fT0sattelite(kFALSE), fTracks(0x0), fCandidates(0x0), + fNFMDchannels(), + fFMDtotalMult(), + fFMD1(0x0), + fFMD2I(0x0), + fFMD2O(0x0), + fFMD3I(0x0), + fFMD3O(0x0), fNCaloClusters(0), fCaloClusters(0x0) //fFMDMult() @@ -212,14 +301,21 @@ AliReducedEvent::AliReducedEvent(const Char_t* /*name*/) : // // Constructor // + for(Int_t i=0; i<2; ++i) fIRIntClosestIntMap[i] = 0; for(Int_t i=0; i<3; ++i) {fVtx[i]=-999.; fVtxTPC[i]=-999.;} for(Int_t i=0; i<4; ++i) fCentrality[i]=-1.; fNV0candidates[0]=0; fNV0candidates[1]=0; fNtracks[0]=0; fNtracks[1]=0; - for(Int_t i=0; i<16; ++i) fSPDntrackletsEta[i]=0; + for(Int_t i=0; i<32; ++i) fSPDntrackletsEta[i]=0; for(Int_t i=0; i<32; ++i) fNtracksPerTrackingFlag[i]=0; for(Int_t i=0; i<64; ++i) fVZEROMult[i] = 0.0; - for(Int_t i=0; i<8; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCpEnergy[i]=0.0; + for(Int_t i=0; i<26; ++i) fT0amplitude[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOF[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOFbest[i]=0.0; + for(Int_t i=0; i<5; ++i) fNFMDchannels[i]=0.0; + for(Int_t i=0; i<5; ++i) fFMDtotalMult[i]=0.0; if(!fgTracks) fgTracks = new TClonesArray("AliReducedTrack", 100000); fTracks = fgTracks; @@ -227,6 +323,16 @@ AliReducedEvent::AliReducedEvent(const Char_t* /*name*/) : fCandidates = fgCandidates; if(!fgCaloClusters) fgCaloClusters = new TClonesArray("AliReducedCaloCluster", 50000); fCaloClusters = fgCaloClusters; + if(!fgFMD1) fgFMD1 = new TClonesArray("AliReducedFMD", 10240); + fFMD1 = fgFMD1; + if(!fgFMD2I) fgFMD2I = new TClonesArray("AliReducedFMD", 10240); + fFMD2I = fgFMD2I; + if(!fgFMD2O) fgFMD2O = new TClonesArray("AliReducedFMD", 10240); + fFMD2O = fgFMD2O; + if(!fgFMD3I) fgFMD3I = new TClonesArray("AliReducedFMD", 10240); + fFMD3I = fgFMD3I; + if(!fgFMD3O) fgFMD3O = new TClonesArray("AliReducedFMD", 10240); + fFMD3O = fgFMD3O; } @@ -305,6 +411,101 @@ Float_t AliReducedEvent::MultRingVZEROC(Int_t ring) const return mult; } +//____________________________________________________________________________ +Float_t AliReducedEvent::AmplitudeTZEROA() const +{ + // + // Total TZERO multiplicity in A side + // + Float_t mult=0.0; + for(Int_t i=12;i<24;++i) + mult += fT0amplitude[i]; + return mult; +} + + +//____________________________________________________________________________ +Float_t AliReducedEvent::AmplitudeTZEROC() const +{ + // + // Total TZERO multiplicity in C side + // + Float_t mult=0.0; + for(Int_t i=0;i<12;++i) + mult += fT0amplitude[i]; + return mult; +} + + +//____________________________________________________________________________ +Float_t AliReducedEvent::AmplitudeTZERO() const +{ + // + // Total TZERO multiplicity + // + return AmplitudeTZEROA()+AmplitudeTZEROC(); +} + + + +//____________________________________________________________________________ +Float_t AliReducedEvent::EnergyZDCA() const +{ + // + // Total ZDC energy in A side + // + Float_t energy=0.0; + for(Int_t i=6;i<10;++i){ + if(fZDCnEnergy[i]>0.) { + Float_t zdcNenergyAlpha = TMath::Power(fZDCnEnergy[i], gZdcNalpha); + energy += zdcNenergyAlpha;} + } + return energy; +} + + +//____________________________________________________________________________ +Float_t AliReducedEvent::EnergyZDCC() const +{ + // + // Total ZDC energy in C side + // + Float_t energy=0.0; + for(Int_t i=1;i<5;++i){ + if(fZDCnEnergy[i]>0.) { + Float_t zdcNenergyAlpha = TMath::Power(fZDCnEnergy[i], gZdcNalpha); + energy += zdcNenergyAlpha;} + } + return energy; +} + + +//____________________________________________________________________________ +Float_t AliReducedEvent::EnergyZDC() const +{ + // + // Total ZDC energy + // + return EnergyZDCA()+EnergyZDCC(); +} + + +//____________________________________________________________________________ +Float_t AliReducedEvent::EnergyZDCn(Int_t ch) const +{ + // + // Total ZDC energy in channel + // + Float_t energy=0; + if(ch<0 || ch>9) return -999.; + if(fZDCnEnergy[ch]>0.) { + energy = TMath::Power(fZDCnEnergy[ch], gZdcNalpha); + } + return energy; + +} + + //_____________________________________________________________________________ void AliReducedEvent::ClearEvent() { // @@ -313,6 +514,17 @@ void AliReducedEvent::ClearEvent() { if(fTracks) fTracks->Clear("C"); if(fCandidates) fCandidates->Clear("C"); if(fCaloClusters) fCaloClusters->Clear("C"); + if(fFMD1) fFMD1->Clear("C"); + if(fFMD2I) fFMD2I->Clear("C"); + if(fFMD2O) fFMD2O->Clear("C"); + if(fFMD3I) fFMD3I->Clear("C"); + if(fFMD3O) fFMD3O->Clear("C"); + fEventTag = 0; + fEventNumberInFile = -999; + fL0TriggerInputs=0; + fL1TriggerInputs=0; + fL2TriggerInputs=0; + fIRIntClosestIntMap[0] = 0; fIRIntClosestIntMap[1] = 0; fRunNo = 0; fBC = 0; fTimeStamp = 0; @@ -320,7 +532,12 @@ void AliReducedEvent::ClearEvent() { fTriggerMask = 0; fIsPhysicsSelection = kTRUE; fIsSPDPileup = kFALSE; + fIsSPDPileupMultBins = kFALSE; + fIsFMDReduced = kTRUE; + fNVtxContributors = 0; + fNVtxTPCContributors = 0; fCentQuality = 0; + for(Int_t i=0;i<4;++i) fCentrality[i] = -1.0; fNV0candidates[0] = 0; fNV0candidates[1] = 0; fNpileupSPD=0; fNpileupTracks=0; @@ -329,11 +546,21 @@ void AliReducedEvent::ClearEvent() { fNTRDtracklets=0; fNDielectronCandidates = 0; fNtracks[0] = 0; fNtracks[1] = 0; - for(Int_t i=0; i<16; ++i) fSPDntrackletsEta[i] = 0; + for(Int_t i=0; i<32; ++i) fSPDntrackletsEta[i] = 0; for(Int_t i=0; i<32; ++i) fNtracksPerTrackingFlag[i] = 0; - for(Int_t i=0; i<3; ++i) {fVtx[i]=-999.; fVtxTPC[i]=-999.; fCentrality[i]=-1.;} + for(Int_t i=0; i<3; ++i) {fVtx[i]=-999.; fVtxTPC[i]=-999.;} for(Int_t i=0; i<64; ++i) fVZEROMult[i] = 0.0; - for(Int_t i=0; i<8; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCnEnergy[i]=0.0; + for(Int_t i=0; i<10; ++i) fZDCpEnergy[i]=0.0; + for(Int_t i=0; i<26; ++i) fT0amplitude[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOF[i]=0.0; + for(Int_t i=0; i<3; ++i) fT0TOFbest[i]=0.0; + fT0pileup = kFALSE; + fT0zVertex = -999.; + fT0start = -999.; + fT0sattelite = kFALSE; + for(Int_t i=0; i<5; ++i) fNFMDchannels[i]=0.0; + for(Int_t i=0; i<5; ++i) fFMDtotalMult[i]=0.0; } @@ -622,32 +849,89 @@ void AliReducedEvent::GetVZEROQvector(Double_t Qvec[][2], Int_t det, Float_t* vz //_________________________________________________________________ void AliReducedEvent::GetZDCQvector(Double_t Qvec[][2], Int_t det) const { + // + // Get the reaction plane from the ZDC detector for a given harmonic + // + GetZDCQvector(Qvec, det, fZDCnEnergy); +} + + +//_________________________________________________________________ +void AliReducedEvent::GetZDCQvector(Double_t Qvec[][2], Int_t det, const Float_t* zdcEnergy) const { // // Construct the event plane using the ZDC // ZDC has 2 side (A and C) with 4 calorimeters on each side // The XY position of each calorimeter is specified by the // zdcNTowerCenters_x and zdcNTowerCenters_y arrays - if(!(det==AliReducedEventFriend::kZDCA || - det==AliReducedEventFriend::kZDCC)) return; // bad detector option + if(!(det==AliReducedEventFriend::kZDCA || + det==AliReducedEventFriend::kZDCC )) + return; + + + //Int_t minTower,maxTower; + //Float_t totalEnergy = 0.0; + const Float_t zdcTowerCenter = 1.75; - const Float_t zdcNTowerCentersX[4] = {-zdcTowerCenter, zdcTowerCenter, -zdcTowerCenter, zdcTowerCenter}; - const Float_t zdcNTowerCentersY[4] = {-zdcTowerCenter, -zdcTowerCenter, zdcTowerCenter, zdcTowerCenter}; - Qvec[0][0] = 0.0; Qvec[0][1] = 0.0; // first harmonic Q-vector + + Float_t zdcNTowerCentersX[4] = {0.0}; + Float_t zdcNTowerCentersY[4] = {0.0}; + + + if(det==AliReducedEventFriend::kZDCA){ + zdcNTowerCentersX[0] = zdcTowerCenter; zdcNTowerCentersX[1] =-zdcTowerCenter; + zdcNTowerCentersX[2] = zdcTowerCenter; zdcNTowerCentersX[3] =-zdcTowerCenter; + } + + if(det==AliReducedEventFriend::kZDCC){ + zdcNTowerCentersX[0] = -zdcTowerCenter; zdcNTowerCentersX[1] = zdcTowerCenter; + zdcNTowerCentersX[2] = -zdcTowerCenter; zdcNTowerCentersX[3] = zdcTowerCenter; + } + + zdcNTowerCentersY[0] = -zdcTowerCenter; zdcNTowerCentersY[1] =-zdcTowerCenter; + zdcNTowerCentersY[2] = zdcTowerCenter; zdcNTowerCentersY[3] = zdcTowerCenter; + + + for(Int_t ih=0; ih<6; ih++) {Qvec[ih][0] = 0.0; Qvec[ih][1] = 0.0;} // harmonic Q-vector Float_t zdcNCentroidSum = 0; - Float_t zdcNalpha = 0.5; - for(Int_t i=0; i<4; ++i) { - if(fZDCnEnergy[i+(det==AliReducedEventFriend::kZDCA ? 4 : 0)]>0.0) { - Float_t zdcNenergyAlpha = TMath::Power(fZDCnEnergy[i+(det==AliReducedEventFriend::kZDCA ? 4 : 0)], zdcNalpha); - Qvec[0][0] += zdcNTowerCentersX[i-1]*zdcNenergyAlpha; - Qvec[0][1] += zdcNTowerCentersY[i-1]*zdcNenergyAlpha; - zdcNCentroidSum += zdcNenergyAlpha; + for(Int_t iTow=(det==AliReducedEventFriend::kZDCA ? 6 : 1); iTow<(det==AliReducedEventFriend::kZDCA ? 10 : 5); ++iTow) { + //if(fZDCnEnergy[i+(det==AliReducedEventFriend::kZDCA ? 4 : 0)]>0.0) { + // 1st harmonic + Qvec[0][0] += zdcEnergy[iTow]*zdcNTowerCentersX[(iTow-1)%5]; + Qvec[0][1] += zdcEnergy[iTow]*zdcNTowerCentersY[(iTow-1)%5]; + // 2nd harmonic + Qvec[1][0] += zdcEnergy[iTow]*(2.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5],2.0)-1); + Qvec[1][1] += zdcEnergy[iTow]*(2.0*zdcNTowerCentersX[(iTow-1)%5]*zdcNTowerCentersY[(iTow-1)%5]); + // 3rd harmonic + Qvec[2][0] += zdcEnergy[iTow]*(4.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5],3.0)-3.0*zdcNTowerCentersX[(iTow-1)%5]); + Qvec[2][1] += zdcEnergy[iTow]*(3.0*zdcNTowerCentersY[(iTow-1)%5]-4.0*TMath::Power(zdcNTowerCentersY[(iTow-1)%5],3.0)); + // 4th harmonic + Qvec[3][0] += zdcEnergy[iTow]*(1.0-8.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5]*zdcNTowerCentersY[(iTow-1)%5],2.0)); + Qvec[3][1] += zdcEnergy[iTow]*(4.0*zdcNTowerCentersX[(iTow-1)%5]*zdcNTowerCentersY[(iTow-1)%5]-8.0*zdcNTowerCentersX[(iTow-1)%5]*TMath::Power(zdcNTowerCentersY[(iTow-1)%5],3.0)); + // 5th harmonic + Qvec[4][0] += zdcEnergy[iTow]*(16.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5],5.0)-20.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5], 3.0)+5.0*zdcNTowerCentersX[(iTow-1)%5]); + Qvec[4][1] += zdcEnergy[iTow]*(16.0*TMath::Power(zdcNTowerCentersY[(iTow-1)%5],5.0)-20.0*TMath::Power(zdcNTowerCentersY[(iTow-1)%5], 3.0)+5.0*zdcNTowerCentersY[(iTow-1)%5]); + // 6th harmonic + Qvec[5][0] += zdcEnergy[iTow]*(32.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5],6.0)-48.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5], 4.0)+18.0*TMath::Power(zdcNTowerCentersX[(iTow-1)%5], 2.0)-1.0); + Qvec[5][1] += zdcEnergy[iTow]*(zdcNTowerCentersX[(iTow-1)%5]*zdcNTowerCentersY[(iTow-1)%5]*(32.0*TMath::Power(zdcNTowerCentersY[(iTow-1)%5],4.0)-32.0*TMath::Power(zdcNTowerCentersY[(iTow-1)%5], 2.0)+6.0)); + + zdcNCentroidSum += zdcEnergy[iTow]; + + if(zdcNCentroidSum>0.0) { + Qvec[0][0] /= zdcNCentroidSum; + Qvec[0][1] /= zdcNCentroidSum; + Qvec[1][0] /= zdcNCentroidSum; + Qvec[1][1] /= zdcNCentroidSum; + Qvec[2][0] /= zdcNCentroidSum; + Qvec[2][1] /= zdcNCentroidSum; + Qvec[3][0] /= zdcNCentroidSum; + Qvec[3][1] /= zdcNCentroidSum; + Qvec[4][0] /= zdcNCentroidSum; + Qvec[4][1] /= zdcNCentroidSum; + Qvec[5][0] /= zdcNCentroidSum; + Qvec[5][1] /= zdcNCentroidSum; } } // end loop over channels - - if(zdcNCentroidSum>0.0) { - Qvec[0][0] /= zdcNCentroidSum; - Qvec[0][1] /= zdcNCentroidSum; - } + return; } diff --git a/PWGDQ/dielectron/AliReducedEvent.h b/PWGDQ/dielectron/AliReducedEvent.h index 7f06b74a3fd..12c979a6130 100644 --- a/PWGDQ/dielectron/AliReducedEvent.h +++ b/PWGDQ/dielectron/AliReducedEvent.h @@ -15,6 +15,7 @@ const Int_t fgkNMaxHarmonics = 10; +const Float_t gZdcNalpha= 1.0; //_____________________________________________________________________ class AliReducedTrack : public TObject { @@ -49,12 +50,14 @@ class AliReducedTrack : public TObject { Float_t Pin() const {return fMomentumInner;} Float_t DCAxy() const {return fDCA[0];} Float_t DCAz() const {return fDCA[1];} + Float_t TrackLength() const {return fTrackLength;} UShort_t ITSncls() const; UChar_t ITSclusterMap() const {return fITSclusterMap;} Bool_t ITSLayerHit(Int_t layer) const {return (layer>=0 && layer<6 ? (fITSclusterMap&(1<=0 && specie<=3 ? fITSnSig[specie] : -999.);} + Float_t ITSchi2() const {return fITSchi2;} UChar_t TPCncls() const {return fTPCNcls;} UChar_t TPCFindableNcls() const {return fTPCNclsF;} @@ -64,13 +67,18 @@ class AliReducedTrack : public TObject { Int_t TPCClusterMapBitsFired() const; Bool_t TPCClusterMapBitFired(Int_t bit) const {return (bit>=0 && bit<8 ? (fTPCClusterMap&(1<=0 && specie<=3 ? fTPCnSig[specie] : -999.);} + Float_t TPCchi2() const {return fTPCchi2;} Float_t TOFbeta() const {return fTOFbeta;} Float_t TOFnSig(Int_t specie) const {return (specie>=0 && specie<=3 ? fTOFnSig[specie] : -999.);} + Short_t TOFdeltaBC() const {return fTOFdeltaBC;} Int_t TRDntracklets(Int_t type) const {return (type==0 || type==1 ? fTRDntracklets[type] : -1);} Float_t TRDpid(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpid[specie] : -999.);} + Float_t TRDpidLQ1D(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpid[specie] : -999.);} + Float_t TRDpidLQ2D(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpidLQ2D[specie] : -999.);} Int_t CaloClusterId() const {return fCaloClusterId;} @@ -80,9 +88,13 @@ class AliReducedTrack : public TObject { Bool_t TestFlag(UShort_t iflag) const {return (iflag<8*sizeof(UShort_t) ? fFlags&(UShort_t(1)<=8*sizeof(UShort_t)) return kFALSE; fFlags|=(UShort_t(1)<=0 && i<3 ? fFlags&(UShort_t(1)<<(5+i)) : kFALSE);} Bool_t TestFlagMore(UShort_t iflag) const {return (iflag<8*sizeof(ULong_t) ? fMoreFlags&(ULong_t(1)<=8*sizeof(ULong_t)) return kFALSE; fMoreFlags|=(ULong_t(1)< 0 // BIT6 toggled if the track has kink1 index > 0 // BIT7 toggled if the track has kink2 index > 0 + // BIT8 toggled if track belongs to a pure gamma conversion + // BIT9 toggled if track belongs to a pure K0s + // BIT10 toggled if track belongs to a pure Lambda + // BIT11 toggled if track belongs to a pure ALambda ULong_t fMoreFlags; // Space reserved for more information which might be needed later for analysis AliReducedTrack(const AliReducedTrack &c); AliReducedTrack& operator= (const AliReducedTrack &c); - ClassDef(AliReducedTrack, 3); + ClassDef(AliReducedTrack, 4); }; @@ -182,7 +204,7 @@ class AliReducedPair : public TObject { Float_t Rapidity() const; Float_t Theta() const {return TMath::ACos(TMath::TanH(fEta));} Float_t Lxy() const {return fLxy;} - Float_t Radius() const {return fLxy;} + Float_t DecayRadius() const {return fLxy;} Float_t LxyErr() const {return fLxyErr;} Float_t PointingAngle() const {return fPointingAngle;} Float_t Chi2() const {return fChisquare;} @@ -215,6 +237,36 @@ class AliReducedPair : public TObject { }; +//_____________________________________________________________________ +class AliReducedFMD : public TObject { + + friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object + + public: + AliReducedFMD(); + ~AliReducedFMD(); + + // getters + UShort_t Multiplicity() const {return fMultiplicity;} + //Float_t Eta() const {return fEta;} + UShort_t Id() const {return fId;} + + //void SetIgnoreSteamer(); + + private: + + UShort_t fMultiplicity; + //Float_t fEta; + UShort_t fId; + + + AliReducedFMD(const AliReducedFMD &c); + AliReducedFMD& operator= (const AliReducedFMD &c); + + ClassDef(AliReducedFMD, 1); +}; + + //_________________________________________________________________________ class AliReducedEventFriend : public TObject { @@ -247,7 +299,7 @@ class AliReducedEventFriend : public TObject { Double_t Qx(Int_t det, Int_t harmonic) const {return (det>=0 && det0 && harmonic<=fgkNMaxHarmonics ? fQvector[det][harmonic-1][0] : -999.);} Double_t Qy(Int_t det, Int_t harmonic) const {return (det>=0 && det0 && harmonic<=fgkNMaxHarmonics ? fQvector[det][harmonic-1][1] : -999.);} Double_t EventPlane(Int_t det, Int_t h) const; - UChar_t GetEventPlaneStatus(Int_t det, Int_t h) const {return (det>=0 && det0 && h<=fgkNMaxHarmonics ? fEventPlaneStatus[det][h-1] : 999);} + UChar_t GetEventPlaneStatus(Int_t det, Int_t h) const {return (det>=0 && det0 && h<=fgkNMaxHarmonics ? fEventPlaneStatus[det][h-1] : 999);} Bool_t CheckEventPlaneStatus(Int_t det, Int_t h, EventPlaneStatus flag) const; void CopyEvent(const AliReducedEventFriend* event); @@ -284,11 +336,14 @@ class AliReducedCaloCluster : public TObject { AliReducedCaloCluster(); ~AliReducedCaloCluster(); - Bool_t IsEMCAL() const {return (fType==kEMCAL ? kTRUE : kFALSE);} - Bool_t IsPHOS() const {return (fType==kPHOS ? kTRUE : kFALSE);} - Float_t Energy() const {return fEnergy;} - Float_t Dx() const {return fTrackDx;} - Float_t Dz() const {return fTrackDz;} + Bool_t IsEMCAL() const {return (fType==kEMCAL ? kTRUE : kFALSE);} + Bool_t IsPHOS() const {return (fType==kPHOS ? kTRUE : kFALSE);} + Float_t Energy() const {return fEnergy;} + Float_t Dx() const {return fTrackDx;} + Float_t Dz() const {return fTrackDz;} + Float_t M20() const {return fM20;} + Float_t M02() const {return fM02;} + Float_t Dispersion() const {return fDispersion;} private: Char_t fType; // cluster type (EMCAL/PHOS) @@ -317,6 +372,15 @@ class AliReducedEvent : public TObject { ~AliReducedEvent(); // getters + ULong64_t EventTag() const {return fEventTag;} + Bool_t EventTag(UShort_t bit) const {return (bit<8*sizeof(ULong64_t) ? (fEventTag&(ULong64_t(1)<=0 && id<2 ? fIRIntClosestIntMap[id] : -999);} + Bool_t IsFMDReduced() const {return fIsFMDReduced;} Float_t Vertex(Int_t axis) const {return (axis>=0 && axis<=2 ? fVtx[axis] : 0);} Int_t VertexNContributors() const {return fNVtxContributors;} Float_t VertexTPC(Int_t axis) const {return (axis>=0 && axis<=2 ? fVtxTPC[axis] : 0);} Int_t VertexTPCContributors() const {return fNVtxTPCContributors;} + Float_t VertexTZERO() const {return fT0zVertex;} Int_t NpileupSPD() const {return fNpileupSPD;} Int_t NpileupTracks() const {return fNpileupTracks;} Int_t NPMDtracks() const {return fNPMDtracks;} @@ -344,8 +412,10 @@ class AliReducedEvent : public TObject { Int_t NTracksTotal() const {return fNtracks[0];} Int_t NTracks() const {return fNtracks[1];} Int_t SPDntracklets() const {return fSPDntracklets;} - Int_t SPDntracklets(Int_t bin) const {return (bin>=0 && bin<16 ? fSPDntrackletsEta[bin] : -999);} + Int_t SPDntracklets(Int_t bin) const {return (bin>=0 && bin<32 ? fSPDntrackletsEta[bin] : -999);} Int_t TracksPerTrackingFlag(Int_t flag) const {return (flag>=0 && flag<32 ? fNtracksPerTrackingFlag[flag] : -999);} + UShort_t NFMDchannels(Int_t det) const {return (det>=0 && det<5 ? fNFMDchannels[det] : 0);} + UShort_t FMDtotalMult(Int_t det) const {return (det>=0 && det<5 ? fFMDtotalMult[det] : 0);} Float_t MultChannelVZERO(Int_t channel) const {return (channel>=0 && channel<=63 ? fVZEROMult[channel] : -999.);} Float_t MultVZEROA() const; @@ -354,9 +424,25 @@ class AliReducedEvent : public TObject { Float_t MultRingVZEROA(Int_t ring) const; Float_t MultRingVZEROC(Int_t ring) const; - Float_t EnergyZDC(Int_t channel) const {return (channel>=0 && channel<8 ? fZDCnEnergy[channel] : -999.);} - Float_t EnergyZDCnA(Int_t channel) const {return (channel>=0 && channel<4 ? fZDCnEnergy[channel+4] : -999.);} - Float_t EnergyZDCnC(Int_t channel) const {return (channel>=0 && channel<4 ? fZDCnEnergy[channel] : -999.);} + Float_t AmplitudeTZEROA() const; + Float_t AmplitudeTZEROC() const; + Float_t AmplitudeTZERO() const; + Float_t AmplitudeTZEROch(Int_t ch) const {return (ch>=0 && ch<=25 ? fT0amplitude[ch] : -999.);} + Float_t EventTZEROStartTime() const {return fT0start;} + Float_t EventTZEROStartTimeTOFfirst(Int_t side) const {return (side>=0 && side<3 ? fT0TOF[side] : -999.);} + Float_t EventTZEROStartTimeTOFbest(Int_t side) const {return (side>=0 && side<3 ? fT0TOFbest[side] : -999.);} + Bool_t IsPileupTZERO() const {return fT0pileup;} + Bool_t IsSatteliteCollisionTZERO() const {return fT0sattelite;} + + Float_t EnergyZDCnTree(UShort_t channel) const {return (channel<10 ? fZDCnEnergy[channel] : -999.);}; + Float_t EnergyZDCpTree(UShort_t channel) const {return (channel<10 ? fZDCpEnergy[channel] : -999.);}; + Float_t EnergyZDCn(Int_t channel) const; + Float_t EnergyZDCA() const; + Float_t EnergyZDCC() const; + Float_t EnergyZDC() const; + + Bool_t TestEventTag(UShort_t iflag) const {return (iflag<8*sizeof(ULong64_t) ? fEventTag&(ULong64_t(1)<=8*sizeof(ULong64_t)) return kFALSE; fEventTag|=(ULong64_t(1)<At(i) : 0x0);} @@ -366,7 +452,23 @@ class AliReducedEvent : public TObject { {return (i>=0 && iAt(i+fNV0candidates[1]) : 0x0);} TClonesArray* GetPairs() const {return fCandidates;} TClonesArray* GetTracks() const {return fTracks;} - + TClonesArray* GetFMD(Int_t det) const {return (det==0 ? fFMD1 : + (det==1 ? fFMD2I : + (det==2 ? fFMD2O : + (det==3 ? fFMD3I : + (det==4 ? fFMD3O : + 0)))));} + TClonesArray* GetFMD1() const {return fFMD1;} + TClonesArray* GetFMD2I() const {return fFMD2I;} + TClonesArray* GetFMD2O() const {return fFMD2O;} + TClonesArray* GetFMD3I() const {return fFMD3I;} + TClonesArray* GetFMD3O() const {return fFMD3O;} + AliReducedFMD* GetFMD1Channel(UShort_t ch) const {return (chAt(ch) : 0x0);} + AliReducedFMD* GetFMD2IChannel(UShort_t ch) const {return (chAt(ch) : 0x0);} + AliReducedFMD* GetFMD2OChannel(UShort_t ch) const {return (chAt(ch) : 0x0);} + AliReducedFMD* GetFMD3IChannel(UShort_t ch) const {return (chAt(ch) : 0x0);} + AliReducedFMD* GetFMD3OChannel(UShort_t ch) const {return (chAt(ch) : 0x0);} + Int_t GetNCaloClusters() const {return fNCaloClusters;} AliReducedCaloCluster* GetCaloCluster(Int_t i) const {return (i>=0 && iAt(i) : 0x0);} @@ -376,11 +478,17 @@ class AliReducedEvent : public TObject { void GetVZEROQvector(Double_t Qvec[][2], Int_t det) ; void GetVZEROQvector(Double_t Qvec[][2], Int_t det, Float_t* vzeroMult); void GetZDCQvector(Double_t Qvec[][2], Int_t det) const; + void GetZDCQvector(Double_t Qvec[][2], Int_t det, const Float_t* zdcEnergy) const; void SubtractParticleFromQvector(AliReducedTrack* particle, Double_t Qvec[][2], Int_t det, Float_t etaMin=-0.8, Float_t etaMax=+0.8, Bool_t (*IsTrackSelected)(AliReducedTrack*)=NULL); private: + ULong64_t fEventTag; // Event tags to be used either during analysis or to filter events + Int_t fEventNumberInFile; // Event number in ESD file + UInt_t fL0TriggerInputs; // L0 trigger inputs + UInt_t fL1TriggerInputs; // L1 trigger inputs + UShort_t fL2TriggerInputs; // L2 trigger inputs Int_t fRunNo; // run number UShort_t fBC; // bunch crossing UInt_t fTimeStamp; // time stamp of the event (NEW) @@ -388,6 +496,9 @@ class AliReducedEvent : public TObject { ULong64_t fTriggerMask; // trigger mask Bool_t fIsPhysicsSelection; // PhysicsSelection passed event Bool_t fIsSPDPileup; // identified as pileup event by SPD + Bool_t fIsSPDPileupMultBins; // identified as pileup event by SPD in multiplicity bins + Int_t fIRIntClosestIntMap[2]; // out of bunch interactions, [0]-Int1, [1]-Int2 + Bool_t fIsFMDReduced; // FMD info, if present, is reduced (NEW) Float_t fVtx[3]; // global event vertex vector in cm Int_t fNVtxContributors; // global event vertex contributors Float_t fVtxTPC[3]; // TPC only event vertex @@ -403,11 +514,19 @@ class AliReducedEvent : public TObject { Int_t fNDielectronCandidates; // number of pairs selected as dielectrons Int_t fNtracks[2]; // number of tracks, [0]-total, [1]-selected for the tree Int_t fSPDntracklets; // number of SPD tracklets in |eta|<1.0 - Int_t fSPDntrackletsEta[16]; // number of SPD tracklets in equal eta bins between -1.6 --> +1.6 (NEW) - Int_t fNtracksPerTrackingFlag[32]; // number of tracks for each tracking status bit (NEW) + Int_t fSPDntrackletsEta[32]; // number of SPD tracklets in equal eta bins between -1.6 --> +1.6 + Int_t fNtracksPerTrackingFlag[32]; // number of tracks for each tracking status bit Float_t fVZEROMult[64]; // VZERO multiplicity in all 64 channels - Float_t fZDCnEnergy[8]; // neutron ZDC energy in all 8 channels + Float_t fZDCnEnergy[10]; // neutron ZDC energy in all 8 channels + Float_t fZDCpEnergy[10]; // neutron ZDC energy in all 8 channels + Float_t fT0amplitude[26]; // T0 amplitude in all 24 channels + Float_t fT0TOF[3]; // T0 timing for A&C, A, and C (first time) + Float_t fT0TOFbest[3]; // T0 timing for A&C, A, and C (best time) + Float_t fT0zVertex; // T0 z vertex estimation + Float_t fT0start; // T0 timing + Bool_t fT0pileup; // TZERO pileup flag + Bool_t fT0sattelite; // TZERO flag for collisions from sattelite bunches TClonesArray* fTracks; //-> array containing global tracks static TClonesArray* fgTracks; // global tracks @@ -415,6 +534,19 @@ class AliReducedEvent : public TObject { TClonesArray* fCandidates; //-> array containing pair candidates static TClonesArray* fgCandidates; // pair candidates + UShort_t fNFMDchannels[5]; // number of FMD channels read out (NEW) + UShort_t fFMDtotalMult[5]; // number of FMD channels read out (NEW) + TClonesArray* fFMD1; //-> array containing fmd readout (NEW) + static TClonesArray* fgFMD1; // fmd readout (NEW) + TClonesArray* fFMD2I; //-> array containing fmd readout (NEW) + static TClonesArray* fgFMD2I; // fmd readout (NEW) + TClonesArray* fFMD2O; //-> array containing fmd readout (NEW) + static TClonesArray* fgFMD2O; // fmd readout (NEW) + TClonesArray* fFMD3I; //-> array containing fmd readout (NEW) + static TClonesArray* fgFMD3I; // fmd readout (NEW) + TClonesArray* fFMD3O; //-> array containing fmd readout (NEW) + static TClonesArray* fgFMD3O; // fmd readout (NEW) + Int_t fNCaloClusters; // number of calorimeter clusters TClonesArray* fCaloClusters; //-> array containing calorimeter clusters static TClonesArray* fgCaloClusters; // calorimeter clusters @@ -423,7 +555,7 @@ class AliReducedEvent : public TObject { AliReducedEvent(const AliReducedEvent &c); AliReducedEvent& operator= (const AliReducedEvent &c); - ClassDef(AliReducedEvent, 4); + ClassDef(AliReducedEvent, 5); }; //_______________________________________________________________________________ -- 2.43.5