#include <AliVZDC.h>
#include <AliESDv0.h>
#include <AliESDv0Cuts.h>
+#include <AliESDv0KineCuts.h>
#include <AliVCluster.h>
#include "AliDielectron.h"
#include "AliDielectronHistos.h"
#include "AliReducedEvent.h"
#include "AliAnalysisTaskReducedTree.h"
+#include <iostream>
+using std::cout;
+using std::endl;
+
ClassImp(AliAnalysisTaskReducedTree)
fFillTrackInfo(kTRUE),
fFillDielectronInfo(kTRUE),
fFillV0Info(kTRUE),
+ fFillGammaConversions(kTRUE),
+ fFillK0s(kTRUE),
+ fFillLambda(kTRUE),
+ fFillALambda(kTRUE),
fFillCaloClusterInfo(kTRUE),
fFillFriendInfo(kTRUE),
fEventFilter(0x0),
fFlowTrackFilter(0x0),
fK0sCuts(0x0),
fLambdaCuts(0x0),
+ fGammaConvCuts(0x0),
fK0sPionCuts(0x0),
fLambdaProtonCuts(0x0),
fLambdaPionCuts(0x0),
+ fGammaElectronCuts(0x0),
fK0sMassRange(),
fLambdaMassRange(),
+ fGammaMassRange(),
fV0Histos(0x0),
fTreeFile(0x0),
fTree(0x0),
fFillTrackInfo(kTRUE),
fFillDielectronInfo(kTRUE),
fFillV0Info(kTRUE),
+ fFillGammaConversions(kTRUE),
+ fFillK0s(kTRUE),
+ fFillLambda(kTRUE),
+ fFillALambda(kTRUE),
fFillCaloClusterInfo(kTRUE),
fFillFriendInfo(kTRUE),
fEventFilter(0x0),
fFlowTrackFilter(0x0),
fK0sCuts(0x0),
fLambdaCuts(0x0),
+ fGammaConvCuts(0x0),
fK0sPionCuts(0x0),
fLambdaProtonCuts(0x0),
fLambdaPionCuts(0x0),
+ fGammaElectronCuts(0x0),
fK0sMassRange(),
fLambdaMassRange(),
+ fGammaMassRange(),
fV0Histos(0x0),
fTreeFile(0x0),
fTree(0x0),
//
fK0sMassRange[0] = 0.4; fK0sMassRange[1] = 0.6;
fLambdaMassRange[0] = 1.08; fLambdaMassRange[1] = 1.15;
+ fGammaMassRange[0] = 0.0; fGammaMassRange[1] = 0.1;
DefineInput(0,TChain::Class());
DefineOutput(1, TList::Class()); // QA histograms
- //DefineOutput(2, TTree::Class()); // reduced information tree
+ DefineOutput(2, TTree::Class()); // reduced information tree
//if(fFillFriendInfo) DefineOutput(3, TTree::Class()); // reduced information tree with friends
//DefineOutput(2, TTree::Class()); // reduced information tree with friends
- DefineOutput(2, TTree::Class()); // reduced information tree
+ //DefineOutput(2, TTree::Class()); // reduced information tree
fListHistos.SetName("QAhistograms");
fListDielectron.SetOwner();
// if there are candidate pairs, add the information to the reduced tree
PostData(1, &fListHistos);
- //PostData(2, fTree);
+ PostData(2, fTree);
//if(fFillFriendInfo) PostData(3, fFriendTree);
//PostData(2, fFriendTree);
- PostData(2, fTree);
+ //PostData(2, fTree);
}
Bool_t isESD = (event->IsA()==AliESDEvent::Class());
Bool_t isAOD = (event->IsA()==AliAODEvent::Class());
+ // 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};
+ Bool_t leg1Found[4]; Bool_t leg2Found[4];
+ for(Int_t iv0=0;iv0<fReducedEvent->fNV0candidates[1];++iv0) {
+ AliReducedPair* pair = fReducedEvent->GetV0Pair(iv0);
+ 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;
+ leg1Found[pairId] = kFALSE; leg2Found[pairId] = kFALSE;
+ for(Int_t it=0;it<nV0LegsTagged[pairId];++it) {
+ if(trackIdsV0[pairId][it]==pair->fLegIds[0]) leg1Found[pairId]=kTRUE;
+ if(trackIdsV0[pairId][it]==pair->fLegIds[1]) leg2Found[pairId]=kTRUE;
+ }
+ // 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];}
+ }
+
+ AliESDtrack* esdTrack=0;
+ AliAODTrack* aodTrack=0;
Int_t ntracks=event->GetNumberOfTracks();
+ Int_t trackId = 0; Bool_t usedForV0[4] = {kFALSE}; Bool_t usedForV0Or = kFALSE;
for(Int_t itrack=0; itrack<ntracks; ++itrack){
AliVParticle *particle=event->GetTrack(itrack);
- //apply track cuts
- if(fTrackFilter && !fTrackFilter->IsSelected(particle)) continue;
+ if(isESD) {
+ esdTrack=static_cast<AliESDtrack*>(particle);
+ trackId = esdTrack->GetID();
+ }
+ if(isAOD) {
+ aodTrack=static_cast<AliAODTrack*>(particle);
+ trackId = aodTrack->GetID();
+ }
+ // check whether this track belongs to a V0 stored in the reduced event
+ usedForV0Or = kFALSE;
+ for(Int_t i=0; i<4; ++i) {
+ usedForV0[i] = kFALSE;
+ for(Int_t ii=0; ii<nV0LegsTagged[i]; ++ii) {
+ if(UShort_t(trackId)==trackIdsV0[i][ii]) {
+ usedForV0[i] = kTRUE;
+ break;
+ }
+ }
+ usedForV0Or |= usedForV0[i];
+ }
+ //apply track cuts
+ if(!usedForV0Or && fTrackFilter && !fTrackFilter->IsSelected(particle)) continue;
+
TClonesArray& tracks = *(fReducedEvent->fTracks);
AliReducedTrack *reducedParticle=new(tracks[fReducedEvent->fNtracks[1]]) AliReducedTrack();
reducedParticle->fITSclusterMap = (UChar_t)values[AliDielectronVarManager::kITSclusterMap];
reducedParticle->fITSsignal = values[AliDielectronVarManager::kITSsignal];
+ reducedParticle->fITSnSig[0] = values[AliDielectronVarManager::kITSnSigmaEle];
+ reducedParticle->fITSnSig[1] = values[AliDielectronVarManager::kITSnSigmaPio];
+ reducedParticle->fITSnSig[2] = values[AliDielectronVarManager::kITSnSigmaKao];
+ reducedParticle->fITSnSig[3] = values[AliDielectronVarManager::kITSnSigmaPro];
reducedParticle->fTPCNcls = (UChar_t)values[AliDielectronVarManager::kNclsTPC];
reducedParticle->fTPCNclsF = (UChar_t)values[AliDielectronVarManager::kNFclsTPC];
// switch on the first bit if this particle should be used for the event plane
if(fFlowTrackFilter->IsSelected(particle)) reducedParticle->fFlags |= (1<<0);
}
+ // switch bits to show wheter the track is used in a V0
+ for(Int_t iV0type=0;iV0type<4;++iV0type) {
+ if(usedForV0[iV0type]) reducedParticle->fFlags |= (1<<(iV0type+1));
+ }
if(isESD){
- AliESDtrack *track=static_cast<AliESDtrack*>(particle);
- reducedParticle->fTrackId = (UShort_t)track->GetID();
- reducedParticle->fTPCCrossedRows = (UChar_t)track->GetTPCCrossedRows();
- reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(track);
- const AliExternalTrackParam* tpcInner = track->GetTPCInnerParam();
+ reducedParticle->fTrackId = (UShort_t)esdTrack->GetID();
+ reducedParticle->fTPCCrossedRows = (UChar_t)esdTrack->GetTPCCrossedRows();
+ reducedParticle->fTPCClusterMap = EncodeTPCClusterMap(esdTrack);
+ const AliExternalTrackParam* tpcInner = esdTrack->GetTPCInnerParam();
reducedParticle->fTPCPhi = (tpcInner ? tpcInner->Phi() : 0.0);
reducedParticle->fTPCPt = (tpcInner ? tpcInner->Pt() : 0.0);
reducedParticle->fTPCEta = (tpcInner ? tpcInner->Eta() : 0.0);
- reducedParticle->fTRDntracklets[0] = track->GetTRDntracklets();
- reducedParticle->fTRDntracklets[1] = track->GetTRDntrackletsPID();
- if(track->IsEMCAL()) reducedParticle->fCaloClusterId = track->GetEMCALcluster();
- if(track->IsPHOS()) reducedParticle->fCaloClusterId = track->GetPHOScluster();
+ reducedParticle->fTRDntracklets[0] = esdTrack->GetTRDntracklets();
+ reducedParticle->fTRDntracklets[1] = esdTrack->GetTRDntrackletsPID();
+ 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<AliAODTrack*>(particle);
- reducedParticle->fTrackId = track->GetID();
- if(track->IsEMCAL()) reducedParticle->fCaloClusterId = track->GetEMCALcluster();
- if(track->IsPHOS()) reducedParticle->fCaloClusterId = track->GetPHOScluster();
+ reducedParticle->fTrackId = aodTrack->GetID();
+ if(aodTrack->IsEMCAL()) reducedParticle->fCaloClusterId = aodTrack->GetEMCALcluster();
+ if(aodTrack->IsPHOS()) reducedParticle->fCaloClusterId = aodTrack->GetPHOScluster();
+ if(values[AliDielectronVarManager::kKinkIndex0]>0.0) reducedParticle->fFlags |= (1<<5);
}
fReducedEvent->fNtracks[1] += 1;
reducedParticle->fEta = values[AliDielectronVarManager::kEta];
reducedParticle->fLxy = values[AliDielectronVarManager::kPseudoProperTime];
reducedParticle->fLxyErr = values[AliDielectronVarManager::kPseudoProperTimeErr];
- reducedParticle->fOpeningAngle = values[AliDielectronVarManager::kOpeningAngle];
-
+ reducedParticle->fPointingAngle = values[AliDielectronVarManager::kCosPointingAngle];
+
reducedParticle->fMCid = 0;
if(hasMC) {
AliDielectronMC::Instance()->ConnectMCEvent();
Double_t valuesPos[AliDielectronVarManager::kNMaxValues];
Double_t valuesNeg[AliDielectronVarManager::kNMaxValues];
-
+
+ fGammaConvCuts->SetEvent(esd);
+ fGammaConvCuts->SetPrimaryVertex(&primaryVertexKF);
+
+ Int_t pdgV0=0; Int_t pdgP=0; Int_t pdgN=0;
for(Int_t iV0=0; iV0<InputEvent()->GetNumberOfV0s(); ++iV0) { // loop over V0s
AliESDv0 *v0 = esd->GetV0(iV0);
// apply the K0s filter
Bool_t goodK0s = kTRUE;
if(fK0sPionCuts && (!fK0sPionCuts->IsSelected(legPos) || !fK0sPionCuts->IsSelected(legNeg))) goodK0s = kFALSE;
- if(fK0sCuts) {
+ if(goodK0s && fK0sCuts) {
TList k0sList;
k0sList.Add(v0);
k0sList.Add(legPos); k0sList.Add(legNeg);
if(!fLambdaCuts->IsSelected(&lambdaList)) {goodLambda = kFALSE; goodALambda = kFALSE;}
}
- if(!(goodK0s || goodLambda || goodALambda)) continue;
+ // apply the gamma conversion filter
+ Bool_t goodGamma = kTRUE;
+ //cout << "fGammaElectronCuts " << fGammaElectronCuts << endl;
+ if(fGammaElectronCuts && (!fGammaElectronCuts->IsSelected(legPos) || !fGammaElectronCuts->IsSelected(legNeg))) goodGamma = kFALSE;
+ //cout << "goodGamma1 " << goodGamma << endl;
+ goodGamma = goodGamma && fGammaConvCuts->ProcessV0(v0, pdgV0, pdgP, pdgN);
+ //cout << "goodGamma2 " << goodGamma << endl;
+ //cout << "pdg V0/p/n: " << pdgV0 << "/" << pdgP << "/" << pdgN << endl;
+ if(pdgV0!=22 || TMath::Abs(pdgP)!=11 || TMath::Abs(pdgN)!=11) goodGamma = kFALSE;
+ //cout << "goodGamma3 " << goodGamma << endl;
+
+ if(!(goodK0s || goodLambda || goodALambda || goodGamma)) continue;
- // Fill the V0 information into the tree for 3 hypothesis: K0s, Lambda, Anti-Lambda
+ // Fill the V0 information into the tree for 4 hypothesis: K0s, Lambda, Anti-Lambda and gamma conversion
AliReducedPair* k0sReducedPair = FillV0PairInfo(v0, AliReducedPair::kK0sToPiPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
AliReducedPair* lambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kLambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
AliReducedPair* alambdaReducedPair = FillV0PairInfo(v0, AliReducedPair::kALambda0ToPPi, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
-
- if(goodK0s && k0sReducedPair->fMass[0]>fK0sMassRange[0] && k0sReducedPair->fMass[0]<fK0sMassRange[1]) {
+ AliReducedPair* gammaReducedPair = FillV0PairInfo(v0, AliReducedPair::kGammaConv, legPos, legNeg, &primaryVertexKF, v0ChargesAreCorrect);
+
+ if(fFillK0s && goodK0s && k0sReducedPair->fMass[0]>fK0sMassRange[0] && k0sReducedPair->fMass[0]<fK0sMassRange[1]) {
TClonesArray& tracks = *(fReducedEvent->fCandidates);
AliReducedPair *goodK0sPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*k0sReducedPair);
goodK0sPair->fMass[0] = k0sReducedPair->fMass[0];
goodK0sPair->fMass[1] = lambdaReducedPair->fMass[0];
goodK0sPair->fMass[2] = alambdaReducedPair->fMass[0];
+ goodK0sPair->fMass[3] = gammaReducedPair->fMass[0];
fReducedEvent->fNV0candidates[1] += 1;
} else {goodK0s=kFALSE;}
- if(goodLambda && lambdaReducedPair->fMass[0]>fLambdaMassRange[0] && lambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
+ if(fFillLambda && goodLambda && lambdaReducedPair->fMass[0]>fLambdaMassRange[0] && lambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
TClonesArray& tracks = *(fReducedEvent->fCandidates);
AliReducedPair *goodLambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*lambdaReducedPair);
fReducedEvent->fNV0candidates[1] += 1;
goodLambdaPair->fMass[0] = k0sReducedPair->fMass[0];
goodLambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
goodLambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
+ goodLambdaPair->fMass[3] = gammaReducedPair->fMass[0];
} else {goodLambda=kFALSE;}
- if(goodALambda && alambdaReducedPair->fMass[0]>fLambdaMassRange[0] && alambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
+ if(fFillALambda && goodALambda && alambdaReducedPair->fMass[0]>fLambdaMassRange[0] && alambdaReducedPair->fMass[0]<fLambdaMassRange[1]) {
TClonesArray& tracks = *(fReducedEvent->fCandidates);
AliReducedPair *goodALambdaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*alambdaReducedPair);
fReducedEvent->fNV0candidates[1] += 1;
goodALambdaPair->fMass[0] = k0sReducedPair->fMass[0];
goodALambdaPair->fMass[1] = lambdaReducedPair->fMass[0];
goodALambdaPair->fMass[2] = alambdaReducedPair->fMass[0];
+ goodALambdaPair->fMass[3] = gammaReducedPair->fMass[0];
} else {goodALambda = kFALSE;}
+ //cout << "gamma mass: " << gammaReducedPair->fMass[0] << endl;
+ if(fFillGammaConversions && goodGamma && gammaReducedPair->fMass[0]>fGammaMassRange[0] && gammaReducedPair->fMass[0]<fGammaMassRange[1]) {
+ TClonesArray& tracks = *(fReducedEvent->fCandidates);
+ AliReducedPair *goodGammaPair = new (tracks[fReducedEvent->fNV0candidates[1]]) AliReducedPair(*gammaReducedPair);
+ goodGammaPair->fMass[0] = k0sReducedPair->fMass[0];
+ goodGammaPair->fMass[1] = lambdaReducedPair->fMass[0];
+ goodGammaPair->fMass[2] = alambdaReducedPair->fMass[0];
+ goodGammaPair->fMass[3] = gammaReducedPair->fMass[0];
+ fReducedEvent->fNV0candidates[1] += 1;
+ } else {goodGamma=kFALSE;}
delete k0sReducedPair;
delete lambdaReducedPair;
delete alambdaReducedPair;
-
- if(!(goodK0s || goodLambda || goodALambda)) continue;
+ delete gammaReducedPair;
+
+ if(!(goodK0s || goodLambda || goodALambda || goodGamma)) continue;
// Fill histograms and the CF container
AliDielectronVarManager::Fill(legPos, valuesPos);
if(!reducedPair->fPairType) { // offline
UInt_t pidPos = AliPID::kPion;
if(id==AliReducedPair::kLambda0ToPPi) pidPos = AliPID::kProton;
+ if(id==AliReducedPair::kGammaConv) pidPos = AliPID::kElectron;
UInt_t pidNeg = AliPID::kPion;
if(id==AliReducedPair::kALambda0ToPPi) pidNeg = AliPID::kProton;
+ if(id==AliReducedPair::kGammaConv) pidNeg = AliPID::kElectron;
reducedPair->fMass[0] = v0->GetEffMass(pidPos, pidNeg);
reducedPair->fPhi = v0->Phi();
if(reducedPair->fPhi<0.0) reducedPair->fPhi = 2.0*TMath::Pi() + reducedPair->fPhi; // converted to [0,2pi]
reducedPair->fPt = v0->Pt();
reducedPair->fEta = v0->Eta();
- reducedPair->fLxy = 0.0; //TODO
- reducedPair->fOpeningAngle = 0.0;
+ reducedPair->fLxy = v0->GetRr();
+ reducedPair->fPointingAngle = v0->GetV0CosineOfPointingAngle(vtxKF->GetX(), vtxKF->GetY(), vtxKF->GetZ());
}
else {
const AliExternalTrackParam *negHelix=v0->GetParamN();
negHelix = v0->GetParamP();
posHelix = v0->GetParamN();
}
- AliKFParticle negKF(*(negHelix),(id==AliReducedPair::kALambda0ToPPi ? -2212 : -211));
- AliKFParticle posKF(*(posHelix),(id==AliReducedPair::kLambda0ToPPi ? +2212 : +211));
+ Int_t pdgPos = 211;
+ if(id==AliReducedPair::kLambda0ToPPi) pdgPos = 2212;
+ if(id==AliReducedPair::kGammaConv) pdgPos = -11;
+ Int_t pdgNeg = -211;
+ if(id==AliReducedPair::kALambda0ToPPi) pdgNeg = -2212;
+ if(id==AliReducedPair::kGammaConv) pdgNeg = 11;
+ AliKFParticle negKF(*(negHelix), pdgPos);
+ AliKFParticle posKF(*(posHelix), pdgNeg);
AliKFParticle v0Refit;
v0Refit += negKF;
v0Refit += posKF;
reducedPair->fPt = v0Refit.GetPt();
reducedPair->fEta = v0Refit.GetEta();
reducedPair->fLxy = v0Refit.GetPseudoProperDecayTime(*vtxKF, massFit);
- reducedPair->fOpeningAngle = negKF.GetAngle(posKF);
+ Double_t deltaPos[3];
+ deltaPos[0] = v0Refit.GetX() - vtxKF->GetX(); deltaPos[1] = v0Refit.GetY() - vtxKF->GetY(); deltaPos[2] = v0Refit.GetZ() - vtxKF->GetZ();
+ Double_t momV02 = v0Refit.GetPx()*v0Refit.GetPx() + v0Refit.GetPy()*v0Refit.GetPy() + v0Refit.GetPz()*v0Refit.GetPz();
+ Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2];
+ reducedPair->fPointingAngle = (deltaPos[0]*v0Refit.GetPx() + deltaPos[1]*v0Refit.GetPy() + deltaPos[2]*v0Refit.GetPz()) /
+ TMath::Sqrt(momV02*deltaPos2);
}
return reducedPair;
}
class TTree;
class TFile;
class AliESDv0Cuts;
+class AliESDv0KineCuts;
class AliKFVertex;
class AliReducedEvent;
class AliReducedEventFriend;
void SetK0sPionCuts(AliAnalysisCuts * const filter) {fK0sPionCuts=filter;}
void SetLambdaProtonCuts(AliAnalysisCuts * const filter) {fLambdaProtonCuts=filter;}
void SetLambdaPionCuts(AliAnalysisCuts * const filter) {fLambdaPionCuts=filter;}
+ void SetGammaElectronCuts(AliAnalysisCuts* const filter) {fGammaElectronCuts=filter;}
void SetK0sCuts(AliESDv0Cuts* const cuts) {fK0sCuts = cuts;}
void SetLambdaCuts(AliESDv0Cuts* const cuts) {fLambdaCuts = cuts;}
+ void SetGammaConvCuts(AliESDv0KineCuts* const cuts) {fGammaConvCuts = cuts;}
void SetK0sMassRange(Double_t min=0.4, Double_t max=0.6) {fK0sMassRange[0]=min; fK0sMassRange[1]=max;}
void SetLambdaMassRange(Double_t min=1.08, Double_t max=1.15) {fLambdaMassRange[0]=min; fLambdaMassRange[1]=max;}
+ void SetGammaConvMassRange(Double_t min=0.0, Double_t max=0.1) {fGammaMassRange[0]=min; fGammaMassRange[1]=max;}
void SetV0Histograms(AliDielectronHistos * const histos) {fV0Histos=histos;}
// Toggle on/off information branches
- void SetFillTrackInfo(Bool_t flag=kTRUE) {fFillTrackInfo = flag;}
- void SetFillDielectronInfo(Bool_t flag=kTRUE) {fFillDielectronInfo = flag;}
- void SetFillV0Info(Bool_t flag=kTRUE) {fFillV0Info = flag;}
- void SetFillCaloClusterInfo(Bool_t flag=kTRUE) {fFillCaloClusterInfo = flag;}
- void SetFillFriendInfo(Bool_t flag=kTRUE) {fFillFriendInfo = flag;}
+ void SetFillTrackInfo(Bool_t flag=kTRUE) {fFillTrackInfo = flag;}
+ void SetFillDielectronInfo(Bool_t flag=kTRUE) {fFillDielectronInfo = flag;}
+ void SetFillV0Info(Bool_t flag=kTRUE) {fFillV0Info = flag;}
+ void SetFillGammaConversions(Bool_t flag=kTRUE) {fFillGammaConversions = flag;}
+ void SetFillK0s(Bool_t flag=kTRUE) {fFillK0s = flag;}
+ 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 SetFillFriendInfo(Bool_t flag=kTRUE) {fFillFriendInfo = flag;}
// Add dielectron objects to the list. These contain cuts and histogram definitions
void AddDielectron(AliDielectron * const die) { fListDielectron.Add(die); }
Bool_t fFillTrackInfo; // fill track information
Bool_t fFillDielectronInfo; // fill dielectrons
Bool_t fFillV0Info; // fill the V0 information
+ Bool_t fFillGammaConversions; // fill gamma conversions
+ Bool_t fFillK0s; // fill the K0s V0s
+ Bool_t fFillLambda; // fill the lambda V0s
+ Bool_t fFillALambda; // fill the anti-lambda V0s
Bool_t fFillCaloClusterInfo; // fill the calorimeter clusters
Bool_t fFillFriendInfo; // fill friend tree information
AliESDv0Cuts *fK0sCuts; // v0 standard filter for K0s->pi+pi-
AliESDv0Cuts *fLambdaCuts; // v0 standard filter for Lambda0->p + pi
+ AliESDv0KineCuts *fGammaConvCuts; // v0 standard filter for gamma conversions
AliAnalysisCuts *fK0sPionCuts; // filter for pions from K0s
AliAnalysisCuts *fLambdaProtonCuts;// filter for protons from Lambda
AliAnalysisCuts *fLambdaPionCuts; // filter for pions from Lambda
- Double_t fK0sMassRange[2]; // mass range for allowed K0s pairs
- Double_t fLambdaMassRange[2]; // mass range for allowed Lambda pairs
+ AliAnalysisCuts *fGammaElectronCuts; // filter for electrons from gamma conversions
+ Double_t fK0sMassRange[2]; // mass range for allowed K0s pairs
+ Double_t fLambdaMassRange[2]; // mass range for allowed Lambda pairs
+ Double_t fGammaMassRange[2]; // mass range for allowed Gamma conversion pairs
AliDielectronHistos* fV0Histos; // histogram manager for V0s
TFile *fTreeFile; //! output file containing the tree
TTree *fTree; //! Reduced event tree
- TTree *fFriendTreeFile; //! output file containing the friend tree
+ TFile *fFriendTreeFile; //! output file containing the friend tree
TTree *fFriendTree; //! Reduced event tree with friend info (event plane, etc.)
AliReducedEvent *fReducedEvent; //! reduced event wise information
AliReducedEventFriend *fReducedEventFriend; //! friend reduced event wise information
AliAnalysisTaskReducedTree(const AliAnalysisTaskReducedTree &c);
AliAnalysisTaskReducedTree& operator= (const AliAnalysisTaskReducedTree &c);
- ClassDef(AliAnalysisTaskReducedTree, 1); //Analysis Task for creating a reduced event information tree
+ ClassDef(AliAnalysisTaskReducedTree, 2); //Analysis Task for creating a reduced event information tree
};
#endif
fDCA(),
fITSclusterMap(0),
fITSsignal(0.0),
+ fITSnSig(),
fTPCNcls(0),
fTPCCrossedRows(0),
fTPCNclsF(0),
fTRDpid(),
fCaloClusterId(-999),
fBayesPID(),
- fFlags(0)
+ fFlags(0),
+ fMoreFlags(0)
{
//
// Constructor
//
fDCA[0] = 0.0; fDCA[1]=0.0;
- for(Int_t i=0; i<4; ++i) {fTPCnSig[i]=-999.; fTOFnSig[i]=-999.;}
+ 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.;
}
fEta(0.0),
fLxy(0.0),
fLxyErr(0.0),
- fOpeningAngle(-1.0),
- //fOnTheFly(kFALSE),
+ fPointingAngle(0.0),
fMCid(0)
{
//
// Constructor
//
fLegIds[0] = -1; fLegIds[1] = -1;
- fMass[0]=-999.; fMass[1]=-999.; fMass[2]=-999.;
+ fMass[0]=-999.; fMass[1]=-999.; fMass[2]=-999.; fMass[3]=-999.;
}
fEta(c.Eta()),
fLxy(c.Lxy()),
fLxyErr(c.LxyErr()),
- fOpeningAngle(c.OpeningAngle()),
- //fOnTheFly(c.IsOnTheFly()),
+ fPointingAngle(c.PointingAngle()),
fMCid(c.MCid())
{
//
//
fLegIds[0] = c.LegId(0);
fLegIds[1] = c.LegId(1);
- fMass[0] = c.Mass(0); fMass[1] = c.Mass(1); fMass[2] = c.Mass(2);
+ fMass[0] = c.Mass(0); fMass[1] = c.Mass(1); fMass[2] = c.Mass(2); fMass[3] = c.Mass(3);
}
//_______________________________________________________________________________
void AliReducedEvent::GetQvector(Double_t Qvec[][2], Int_t det,
- Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
- Bool_t (*IsTrackSelected)(AliReducedTrack*)/*=NULL*/) {
+ Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
+ Bool_t (*IsTrackSelected)(AliReducedTrack*)/*=NULL*/) {
//
// Get the event plane for a specified detector
//
//_________________________________________________________________
Int_t AliReducedEvent::GetTPCQvector(Double_t Qvec[][2], Int_t det,
- Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
- Bool_t (*IsTrackSelected)(AliReducedTrack*)/*=NULL*/) {
+ Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
+ Bool_t (*IsTrackSelected)(AliReducedTrack*)/*=NULL*/) {
//
// Construct the event plane using tracks in the barrel
//
if(absWeight>2.0) absWeight = 2.0; // pt is the weight used for the event plane
}
weight = absWeight;
- //if(track->Eta()<0.0) weight *= -1.0;
-
+
++nUsedTracks;
x = TMath::Cos(track->Phi());
y = TMath::Sin(track->Phi());
//____________________________________________________________________________
void AliReducedEvent::SubtractParticleFromQvector(
AliReducedTrack* particle, Double_t Qvec[][2], Int_t det,
- Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
+ Float_t etaMin/*=-0.8*/, Float_t etaMax/*=+0.8*/,
Bool_t (*IsTrackSelected)(AliReducedTrack*)/*=NULL*/) {
//
// subtract a particle from the event Q-vector
Float_t eta = particle->Eta();
if(eta<etaMin) return;
if(eta>etaMax) return;
-
+
Float_t charge = particle->Charge();
if(det==AliReducedEventFriend::kTPCpos && charge<0) return;
if(det==AliReducedEventFriend::kTPCneg && charge>0) return;
const Int_t fgkNMaxHarmonics = 10;
-/*class AliCorrelationReducedTrack;
-class AliCorrelationReducedPair;
-class AliReducedEventFriend;
-class AliReducedEvent;
-class AliCorrelationReducedCaloCluster;*/
//_____________________________________________________________________
class AliReducedTrack : public TObject {
UChar_t ITSclusterMap() const {return fITSclusterMap;}
Bool_t ITSLayerHit(Int_t layer) const {return (layer>=0 && layer<6 ? (fITSclusterMap&(1<<layer)) : kFALSE);};
Float_t ITSsignal() const {return fITSsignal;}
+ Float_t ITSnSig(Int_t specie) const {return (specie>=0 && specie<=3 ? fITSnSig[specie] : -999.);}
UChar_t TPCncls() const {return fTPCNcls;}
UChar_t TPCFindableNcls() const {return fTPCNclsF;}
Float_t TRDpid(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpid[specie] : -999.);}
Int_t CaloClusterId() const {return fCaloClusterId;}
- //Float_t CaloEnergy(AliReducedEvent* event) const {if(fCaloClusterId>0) return event->GetCaloCluster(fCaloClusterId)->Energy();}
- //Float_t CaloDx(AliReducedEvent* event) const {if(fCaloClusterId>0) return event->GetCaloCluster(fCaloClusterId)->Dx();}
- //Float_t CaloDz(AliReducedEvent* event) const {if(fCaloClusterId>0) return event->GetCaloCluster(fCaloClusterId)->Dz();}
-
+
Float_t BayesPID(Int_t specie) const {return (specie>=0 && specie<=2 ? fBayesPID[specie] : -999.);}
- Bool_t UsedForQvector() const {return fFlags&(1<<0);}
+
+ Bool_t UsedForQvector() const {return fFlags&(1<<0);}
+ Bool_t TestFlag(UShort_t iflag) const {return (iflag<sizeof(UShort_t) ? fFlags&(1<<iflag) : kFALSE);}
+ Bool_t SetFlag(UShort_t iflag) {if (iflag>=sizeof(UShort_t)) return kFALSE; fFlags|=(1<<iflag); return kTRUE;}
+ Bool_t IsGammaLeg() const {return fFlags&(1<<1);}
+ Bool_t IsK0sLeg() const {return fFlags&(1<<2);}
+ Bool_t IsLambdaLeg() const {return fFlags&(1<<3);}
+ Bool_t IsALambdaLeg() const {return fFlags&(1<<4);}
+ Bool_t IsKink(Int_t i=0) const {return (i>=0 && i<3 ? fFlags&(1<<(5+i)) : kFALSE);}
+ Bool_t TestFlagMore(UShort_t iflag) const {return (iflag<sizeof(ULong_t) ? fMoreFlags&(1<<iflag) : kFALSE);}
+ Bool_t SetFlagMore(UShort_t iflag) {if(iflag>=sizeof(ULong_t)) return kFALSE; fMoreFlags|=(1<<iflag); return kTRUE;}
private:
UShort_t fTrackId; // track id
// ITS
UChar_t fITSclusterMap; // ITS cluster map
Float_t fITSsignal; // ITS signal
+ Float_t fITSnSig[4]; // 0-electron; 1-pion; 2-kaon; 3-proton
// TPC
UChar_t fTPCNcls; // TPC ncls
// TRD
UChar_t fTRDntracklets[2]; // 0 - AliESDtrack::GetTRDntracklets(); 1 - AliESDtrack::GetTRDntrackletsPID() TODO: use only 1 char
- Float_t fTRDpid[2]; // TRD pid probabilities, [0]-electron, [1]-pion
+ Float_t fTRDpid[2]; // TRD electron probabilities, [0]- 1D likelihood, [1]- 2D likelihood
// EMCAL/PHOS
Int_t fCaloClusterId; // ID for the calorimeter cluster (if any)
// Bayesian PID
- Float_t fBayesPID[3]; // Combined Bayesian PID pi/K/p
-
- UShort_t fFlags; // BIT0 toggled if track used for TPC event plane TODO combine with other posible flags, use for MC pid?
- // TODO flag for which TPC part used for pid --> Char_t used in 2011 data
-
+ Float_t fBayesPID[3]; // Combined Bayesian PID pi/K/p
+
+ UShort_t fFlags; // BIT0 toggled if track used for TPC event plane
+ // BIT1 toggled if track belongs to a gamma conversion
+ // BIT2 toggled if track belongs to a K0s
+ // BIT3 toggled if track belongs to a Lambda
+ // BIT4 toggled if track belongs to an Anti-Lambda
+ // BIT5 toggled if the track has kink0 index > 0
+ // BIT6 toggled if the track has kink1 index > 0
+ // BIT7 toggled if the track has kink2 index > 0
+ 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, 2);
+ ClassDef(AliReducedTrack, 3);
};
kALambda0ToPPi,
kJpsiToEE,
kUpsilon,
+ kGammaConv,
kNMaxCandidateTypes
};
AliReducedPair();
Char_t CandidateId() const {return fCandidateId;}
Char_t PairType() const {return fPairType;}
Int_t LegId(Int_t leg) const {return (leg==0 || leg==1 ? fLegIds[leg] : -1);}
- Float_t Mass(Int_t idx=0) const {return (idx>=0 && idx<3 ? fMass[idx] : -999.);}
+ Float_t Mass(Int_t idx=0) const {return (idx>=0 && idx<4 ? fMass[idx] : -999.);}
Float_t Px() const {return fPt*TMath::Cos(fPhi);}
Float_t Py() const {return fPt*TMath::Sin(fPhi);}
Float_t Pz() const {return fPt*TMath::SinH(fEta);}
Float_t Theta() const {return TMath::ACos(TMath::TanH(fEta));}
Float_t Lxy() const {return fLxy;}
Float_t LxyErr() const {return fLxyErr;}
- Float_t OpeningAngle() const {return fOpeningAngle;}
+ Float_t PointingAngle() const {return fPointingAngle;}
Bool_t IsOnTheFly() const {return fPairType;}
UInt_t MCid() const {return fMCid;}
Bool_t CheckMC(const Int_t flag) const {return (flag<32 ? (fMCid&(1<<flag)) : kFALSE);}
Char_t fCandidateId; // candidate type (K0s, Lambda, J/psi, phi, etc)
Char_t fPairType; // 0 ++; 1 +-; 2 -- for dielectron pairs; 0- offline, 1- on the fly for V0 candidates
UShort_t fLegIds[2]; // leg ids
- Float_t fMass[3]; // invariant mass for pairs (2 extra mass values for other V0 pid assumptions)
- // idx=0 -> K0s assumption; idx=1 -> Lambda; idx=2 -> anti-Lambda
+ Float_t fMass[4]; // invariant mass for pairs (3 extra mass values for other V0 pid assumptions)
+ // idx=0 -> K0s assumption; idx=1 -> Lambda; idx=2 -> anti-Lambda; idx=3 -> gamma conversion
Float_t fPhi; // pair phi in the [0,2*pi) interval
Float_t fPt; // pair pt
Float_t fEta; // pair eta
Float_t fLxy; // pseudo-proper decay length
Float_t fLxyErr; // error on Lxy
- Float_t fOpeningAngle; // opening angle TODO remove ???
+ Float_t fPointingAngle; // angle between the pair momentum vector and the secondary vertex position vector
UInt_t fMCid; // Bit map with Monte Carlo info about the pair
AliReducedPair& operator= (const AliReducedPair &c);
- ClassDef(AliReducedPair, 1);
+ ClassDef(AliReducedPair, 2);
};
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 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);
+ 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:
Int_t fRunNo; // run number
case kALambda0ToPPi:
mass = fMass[2];
break;
+ case kGammaConv:
+ mass = fMass[3];
+ break;
default:
mass = fMass[0];
break;
AliAnalysisTaskReducedTree *task=new AliAnalysisTaskReducedTree("DSTTreeMaker");
task->SetTriggerMask(AliVEvent::kMB+AliVEvent::kCentral+AliVEvent::kSemiCentral);
//if(trainConfig=="pp") task->SetRejectPileup();
- if(!hasMC) task->UsePhysicsSelection(kFALSE);
+ if(!hasMC) task->UsePhysicsSelection(kTRUE);
mgr->AddTask(task);
- task->SetFillV0Info(kFALSE);
+ // task->SetFillV0Info(kFALSE);
+ //task->SetFillGammaConversions(kFALSE);
+ task->SetFillK0s(kFALSE);
+ task->SetFillLambda(kFALSE);
+ task->SetFillALambda(kFALSE);
task->SetFillCaloClusterInfo(kFALSE);
+ task->SetFillDielectronInfo(kFALSE);
task->SetFillFriendInfo(kFALSE);
task->SetEventFilter(CreateEventFilter());
task->SetK0sPionCuts(CreateK0sPionCuts());
task->SetLambdaProtonCuts(CreateLambdaProtonCuts());
task->SetLambdaPionCuts(CreateLambdaPionCuts());
+ task->SetGammaElectronCuts(CreateGammaConvElectronCuts());
task->SetK0sCuts(CreateK0sCuts());
task->SetK0sMassRange(0.44,0.55);
task->SetLambdaMassRange(1.090,1.14);
task->SetLambdaCuts(CreateLambdaCuts());
+ task->SetGammaConvCuts(CreateGammaConvCuts(AliESDv0KineCuts::kPurity, AliESDv0KineCuts::kPbPb));
+ task->SetGammaConvMassRange(0.0,0.1);
//task->SetV0Histograms(CreateV0Histograms());
- task->AddDielectron(ConfigDielectron(0)); // J/psi -> e+e-
+ //task->AddDielectron(ConfigDielectron(0)); // J/psi -> e+e-
//task->AddDielectron(ConfigDielectron(1)); // phi -> K+K-
//create output container
mgr->CreateContainer("qaHistos",
TList::Class(),
AliAnalysisManager::kOutputContainer,
- "dstTree.root");
+ "dst_Histos.root");
AliAnalysisDataContainer *cOutputHist2 =
mgr->CreateContainer("dstTree",
// basic track quality cuts (basicQ)
esdTrackCuts->SetMaxDCAToVertexZ(10.0);
esdTrackCuts->SetMaxDCAToVertexXY(3.0);
- esdTrackCuts->SetEtaRange( -0.9 , 0.9 );
+ esdTrackCuts->SetEtaRange( -1.0 , 1.0 );
//esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
- //esdTrackCuts->SetRequireITSRefit(kTRUE);
+ esdTrackCuts->SetRequireITSRefit(kTRUE);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
- esdTrackCuts->SetPRange(0.8,1e30);
+ esdTrackCuts->SetPRange(0.2,1e30);
+ //esdTrackCuts->SetPtRange(0.15,1e30);
//esdTrackCuts->SetMinNClustersTPC(60);
//esdTrackCuts->SetMaxChi2PerClusterTPC(4);
// esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
// esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
cuts->AddCut(esdTrackCuts);
-
+
+ AliDielectronPID *electronPid = new AliDielectronPID("PID","PID cut");
+ electronPid->AddCut(AliDielectronPID::kTPC,AliPID::kElectron,-3.0, 4.0, 0.0, 0.0, kFALSE, AliDielectronPID::kRequire); // TPC 3-sigma inclusion for electron
+ electronPid->AddCut(AliDielectronPID::kTOF,AliPID::kProton, -3.0, 3.0, -2.0, 2.0, kTRUE, AliDielectronPID::kRequire,AliDielectronVarManager::kTPCnSigmaPro); // TPC exclusion for proton
+ cuts->AddCut(electronPid);
+
return cuts;
}
// Cuts on the K0s pions (tracking cuts, pid cuts, ...)
//
AliESDtrackCuts *pionCuts = new AliESDtrackCuts;
- pionCuts->SetPtRange(0.15,100.0);
+ pionCuts->SetPtRange(0.1,100.0);
+ pionCuts->SetRequireTPCRefit(kTRUE);
+ pionCuts->SetMinNClustersTPC(50);
return pionCuts;
}
// Cuts on the Lambda pions (tracking cuts, pid cuts, ...)
//
AliESDtrackCuts *pionCuts = new AliESDtrackCuts;
- pionCuts->SetPtRange(0.15,100.0);
+ pionCuts->SetPtRange(0.1,100.0);
return pionCuts;
}
// Cuts on the Lambda protons (tracking cuts, pid cuts, ...)
//
AliESDtrackCuts *protonCuts = new AliESDtrackCuts;
- protonCuts->SetPtRange(0.15,100.0);
+ protonCuts->SetPtRange(0.1,100.0);
return protonCuts;
}
+//______________________________________________________________________________________
+AliAnalysisCuts* CreateGammaConvElectronCuts() {
+ //
+ // Cuts for the selection of electrons from gamma conversions
+ //
+ AliESDtrackCuts* electronCuts = new AliESDtrackCuts;
+ electronCuts->SetRequireTPCRefit(kTRUE);
+ electronCuts->SetMinNClustersTPC(50);
+ return electronCuts;
+}
+
+
//______________________________________________________________________________________
AliESDv0Cuts* CreateK0sCuts() {
//
//cuts->SetMaxDcaV0Daughters(0.3);
//cuts->SetMinRadius(3.0);
//cuts->SetMaxRadius(90.0);
- //cuts->SetMinCosinePointingAngle(0.9);
+ cuts->SetMinCosinePointingAngle(0.8);
//cuts->SetRequireOnFlyStatus(kTRUE);
//cuts->SetMaxDcaV0ToVertex(0.5);
//cuts->SetPRange(0.,1.0e10);
}
+//______________________________________________________________________________________
+AliESDv0KineCuts* CreateGammaConvCuts(Int_t mode, Int_t type) {
+ //
+ // cuts for the selection of gamma conversions
+ //
+ AliESDv0KineCuts* cuts = new AliESDv0KineCuts();
+ cuts->SetMode(mode, type);
+
+ //cuts->SetNTPCclusters(60);
+ cuts->SetTPCrefit(kTRUE);
+ //cuts->SetTPCchi2perCls(4.0);
+ //cuts->SetTPCclusterratio(0.6);
+ cuts->SetNoKinks(kTRUE);
+ // gamma cuts
+ cuts->SetGammaCutChi2NDF(10.0);
+ Float_t cosPoint[2] = {0.0, 0.2};
+ //cuts->SetGammaCutCosPoint(cosPoint);
+ Float_t cutDCA[2] = {0.0, 1.25};
+ cuts->SetGammaCutDCA(cutDCA);
+ Float_t vtxR[2] = {3.0, 90.0};
+ cuts->SetGammaCutVertexR(vtxR);
+ Float_t psiPairCut[2]={0.0,0.10};
+ cuts->SetGammaCutPsiPair(psiPairCut);
+ cuts->SetGammaCutInvMass(0.1);
+
+ return cuts;
+}
+
+
//______________________________________________________________________________________
AliDielectronHistos* CreateV0Histograms()
{
esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
//esdTrackCuts->SetRequireITSRefit(kTRUE);
if(cutDefinition==0) esdTrackCuts->SetRequireTPCRefit(kTRUE);
- if(cutDefinition==0) esdTrackCuts->SetPRange(.9,1e30); // for J/psi
+ if(cutDefinition==0) esdTrackCuts->SetPRange(.8,1e30); // for J/psi
if(cutDefinition==1) esdTrackCuts->SetPRange(.1,1e30); // for phi
//if(cutDefinition==0) esdTrackCuts->SetMinNClustersTPC(60);
//if(cutDefinition==0) esdTrackCuts->SetMaxChi2PerClusterTPC(4);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff