fMixEvent(kFALSE),
fPidResponse(0x0),
fUseKaonPIDfor3Prong(kFALSE),
+fUsePIDforLc(0),
+fUsePIDforLc2V0(0),
+fUseKaonPIDforDs(kFALSE),
+fUseTPCPID(kFALSE),
+fUseTOFPID(kFALSE),
+fUseTPCPIDOnlyIfNoTOF(kFALSE),
+fMaxMomForTPCPid(1.),
+fnSigmaTPCPionLow(5.),
+fnSigmaTPCPionHi(5.),
+fnSigmaTOFPionLow(5.),
+fnSigmaTOFPionHi(5.),
+fnSigmaTPCKaonLow(5.),
+fnSigmaTPCKaonHi(5.),
fnSigmaTOFKaonLow(5.),
fnSigmaTOFKaonHi(5.),
+fnSigmaTPCProtonLow(5.),
+fnSigmaTPCProtonHi(5.),
+fnSigmaTOFProtonLow(5.),
+fnSigmaTOFProtonHi(5.),
fMaxCentPercentileForTightCuts(-9999),
fTrackFilter(0x0),
fTrackFilter2prongCentral(0x0),
fListOfCuts(0x0),
fFindVertexForDstar(kTRUE),
fFindVertexForCascades(kTRUE),
+fV0TypeForCascadeVertex(0),
fMassCutBeforeVertexing(kFALSE),
fMassCalc2(0),
fMassCalc3(0),
fMixEvent(source.fMixEvent),
fPidResponse(source.fPidResponse),
fUseKaonPIDfor3Prong(source.fUseKaonPIDfor3Prong),
+fUsePIDforLc(source.fUsePIDforLc),
+fUsePIDforLc2V0(source.fUsePIDforLc2V0),
+fUseKaonPIDforDs(source.fUseKaonPIDforDs),
+fUseTPCPID(source.fUseTPCPID),
+fUseTOFPID(source.fUseTOFPID),
+fUseTPCPIDOnlyIfNoTOF(source.fUseTPCPIDOnlyIfNoTOF),
+fMaxMomForTPCPid(source.fMaxMomForTPCPid),
+fnSigmaTPCPionLow(source.fnSigmaTPCPionLow),
+fnSigmaTPCPionHi(source.fnSigmaTPCPionHi),
+fnSigmaTOFPionLow(source.fnSigmaTOFPionLow),
+fnSigmaTOFPionHi(source.fnSigmaTOFPionHi),
+fnSigmaTPCKaonLow(source.fnSigmaTPCKaonLow),
+fnSigmaTPCKaonHi(source.fnSigmaTPCKaonHi),
fnSigmaTOFKaonLow(source.fnSigmaTOFKaonLow),
fnSigmaTOFKaonHi(source.fnSigmaTOFKaonHi),
+fnSigmaTPCProtonLow(source.fnSigmaTPCProtonLow),
+fnSigmaTPCProtonHi(source.fnSigmaTPCProtonHi),
+fnSigmaTOFProtonLow(source.fnSigmaTOFProtonLow),
+fnSigmaTOFProtonHi(source.fnSigmaTOFProtonHi),
fMaxCentPercentileForTightCuts(source.fMaxCentPercentileForTightCuts),
fTrackFilter(source.fTrackFilter),
fTrackFilter2prongCentral(source.fTrackFilter2prongCentral),
fListOfCuts(source.fListOfCuts),
fFindVertexForDstar(source.fFindVertexForDstar),
fFindVertexForCascades(source.fFindVertexForCascades),
+fV0TypeForCascadeVertex(source.fV0TypeForCascadeVertex),
fMassCutBeforeVertexing(source.fMassCutBeforeVertexing),
fMassCalc2(source.fMassCalc2),
fMassCalc3(source.fMassCalc3),
fMixEvent = source.fMixEvent;
fPidResponse = source.fPidResponse;
fUseKaonPIDfor3Prong = source.fUseKaonPIDfor3Prong;
+ fUsePIDforLc = source.fUsePIDforLc;
+ fUsePIDforLc2V0 = source.fUsePIDforLc2V0;
+ fUseKaonPIDforDs = source.fUseKaonPIDforDs;
+ fUseTPCPID = source.fUseTPCPID;
+ fUseTOFPID = source.fUseTOFPID;
+ fUseTPCPIDOnlyIfNoTOF = source.fUseTPCPIDOnlyIfNoTOF;
+ fMaxMomForTPCPid = source.fMaxMomForTPCPid;
+ fnSigmaTPCPionLow = source.fnSigmaTPCPionLow;
+ fnSigmaTPCPionHi = source.fnSigmaTPCPionHi;
+ fnSigmaTOFPionLow = source.fnSigmaTOFPionLow;
+ fnSigmaTOFPionHi = source.fnSigmaTOFPionHi;
+ fnSigmaTPCKaonLow = source.fnSigmaTPCKaonLow;
+ fnSigmaTPCKaonHi = source.fnSigmaTPCKaonHi;
+ fnSigmaTOFKaonLow = source.fnSigmaTOFKaonLow;
+ fnSigmaTOFKaonHi = source.fnSigmaTOFKaonHi;
+ fnSigmaTPCProtonLow = source.fnSigmaTPCProtonLow;
+ fnSigmaTPCProtonHi = source.fnSigmaTPCProtonHi;
+ fnSigmaTOFProtonLow = source.fnSigmaTOFProtonLow;
+ fnSigmaTOFProtonHi = source.fnSigmaTOFProtonHi;
fnSigmaTOFKaonLow = source.fnSigmaTOFKaonLow;
fnSigmaTOFKaonHi = source.fnSigmaTOFKaonHi;
fMaxCentPercentileForTightCuts = source.fMaxCentPercentileForTightCuts;
fListOfCuts = source.fListOfCuts;
fFindVertexForDstar = source.fFindVertexForDstar;
fFindVertexForCascades = source.fFindVertexForCascades;
+ fV0TypeForCascadeVertex = source.fV0TypeForCascadeVertex;
fMassCutBeforeVertexing = source.fMassCutBeforeVertexing;
fMassCalc2 = source.fMassCalc2;
fMassCalc3 = source.fMassCalc3;
list->Add(cutsDStartoKpipi);
}
+ //___ Check consitstency of cuts between vertexer and analysis tasks
+ Bool_t bCutsOk = CheckCutsConsistency();
+ if (bCutsOk == kFALSE) {AliFatal("AliAnalysisVertexingHF::FillListOfCuts vertexing and the analysis task cuts are not consistent!");}
+
// keep a pointer to the list
fListOfCuts = list;
// and retrieves primary vertex
TObjArray seleTrksArray(trkEntries);
TObjArray tracksAtVertex(trkEntries);
- UChar_t *seleFlags = new UChar_t[trkEntries]; // bit 0: displaced, bit 1: softpi, bit 2: 3 prong
+ UChar_t *seleFlags = new UChar_t[trkEntries]; // bit 0: displaced, bit 1: softpi, bit 2: 3 prong, bits 3-4-5: for PID
Int_t nSeleTrks=0;
Int_t *evtNumber = new Int_t[trkEntries];
SelectTracksAndCopyVertex(event,trkEntries,seleTrksArray,tracksAtVertex,nSeleTrks,seleFlags,evtNumber);
//AliDebug(1,Form(" loop on v0s for track number %d and v0 number %d",iTrkP1,iv0));
+ if ( fUsePIDforLc2V0 && !TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) ) continue; //clm
+
// Get the V0
if(fInputAOD) {
v0 = ((AliAODEvent*)event)->GetV0(iv0);
if ( (!v0 || !v0->IsA()->InheritsFrom("AliAODv0") ) &&
(!esdV0 || !esdV0->IsA()->InheritsFrom("AliESDv0") ) ) continue;
+ if ( v0 && ((v0->GetOnFlyStatus() == kTRUE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOfflineV0s) ||
+ (v0->GetOnFlyStatus() == kFALSE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) continue;
+
+ if ( esdV0 && ((esdV0->GetOnFlyStatus() == kTRUE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOfflineV0s) ||
+ ( esdV0->GetOnFlyStatus() == kFALSE && fV0TypeForCascadeVertex == AliRDHFCuts::kOnlyOnTheFlyV0s)) ) continue;
// Get the tracks that form the V0
// ( parameters at primary vertex )
dcaV0 = v0->DcaV0Daughters();
// Define the V0 (neutral) track
- AliNeutralTrackParam *trackV0;
+ AliNeutralTrackParam *trackV0=NULL;
if(fInputAOD) {
const AliVTrack *trackVV0 = dynamic_cast<const AliVTrack*>(v0);
- if(trackVV0) trackV0 = new AliNeutralTrackParam(trackVV0);
+ if(trackVV0) trackV0 = new AliNeutralTrackParam(trackVV0);
} else {
Double_t xyz[3], pxpypz[3];
esdV0->XvYvZv(xyz);
Double_t cv[21]; for(int i=0; i<21; i++) cv[i]=0;
trackV0 = new AliNeutralTrackParam(xyz,pxpypz,cv,0);
}
+
+
// Fill in the object array to create the cascade
twoTrackArrayCasc->AddAt(postrack1,0);
twoTrackArrayCasc->AddAt(trackV0,1);
//printf("---> %d %d %d %d %d\n",vertexp1n1->GetNDaughters(),iTrkP1,iTrkN1,postrack1->Charge(),negtrack1->Charge());
// create a track from the D0
AliNeutralTrackParam *trackD0 = new AliNeutralTrackParam(io2Prong);
-
+
// LOOP ON TRACKS THAT PASSED THE SOFT PION CUTS
for(iTrkSoftPi=0; iTrkSoftPi<nSeleTrks; iTrkSoftPi++) {
}
if(fUseKaonPIDfor3Prong){
- Double_t nsigmatofK= fPidResponse->NumberOfSigmasTOF(negtrack1,AliPID::kKaon);
- if(nsigmatofK>-990. && (nsigmatofK<-fnSigmaTOFKaonLow || nsigmatofK>fnSigmaTOFKaonHi)) continue;
+ if(!TESTBIT(seleFlags[iTrkN1],kBitKaonCompat)) continue;
+ }
+ Bool_t okForLcTopKpi=kTRUE;
+ Int_t pidLcStatus=3; // 3= OK as pKpi and Kpipi
+ if(fUsePIDforLc>0){
+ if(!TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) &&
+ !TESTBIT(seleFlags[iTrkP2],kBitProtonCompat) ){
+ okForLcTopKpi=kFALSE;
+ pidLcStatus=0;
+ }
+ if(okForLcTopKpi && fUsePIDforLc>1){
+ okForLcTopKpi=kFALSE;
+ pidLcStatus=0;
+ if(TESTBIT(seleFlags[iTrkP1],kBitProtonCompat) &&
+ TESTBIT(seleFlags[iTrkP2],kBitPionCompat) ){
+ okForLcTopKpi=kTRUE;
+ pidLcStatus+=1; // 1= OK as pKpi
+ }
+ if(TESTBIT(seleFlags[iTrkP2],kBitProtonCompat) &&
+ TESTBIT(seleFlags[iTrkP1],kBitPionCompat) ){
+ okForLcTopKpi=kTRUE;
+ pidLcStatus+=2; // 2= OK as piKp
+ }
+ }
+ }
+ Bool_t okForDsToKKpi=kTRUE;
+ if(fUseKaonPIDforDs){
+ if(!TESTBIT(seleFlags[iTrkP1],kBitKaonCompat) &&
+ !TESTBIT(seleFlags[iTrkP2],kBitKaonCompat) ) okForDsToKKpi=kFALSE;
}
// back to primary vertex
// postrack1->PropagateToDCA(fV1,fBzkG,kVeryBig);
Double_t pyDau[3]={mompos1[1],momneg1[1],mompos2[1]};
Double_t pzDau[3]={mompos1[2],momneg1[2],mompos2[2]};
// massCutOK = SelectInvMassAndPt3prong(threeTrackArray);
- massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau);
+ massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau,pidLcStatus);
}
}
if(f3Prong && massCutOK) {
AliAODVertex* secVert3PrAOD = ReconstructSecondaryVertex(threeTrackArray,dispersion);
- io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp2n1,dcap1n1,dcap2n1,dcap1p2,ok3Prong);
+ io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp2n1,dcap1n1,dcap2n1,dcap1p2,okForLcTopKpi,okForDsToKKpi,ok3Prong);
if(ok3Prong) {
AliAODVertex *v3Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*secVert3PrAOD);
if(!isLikeSign3Prong) {
}
if(fUseKaonPIDfor3Prong){
- Double_t nsigmatofK= fPidResponse->NumberOfSigmasTOF(postrack1,AliPID::kKaon);
- if(nsigmatofK>-990. && (nsigmatofK<-fnSigmaTOFKaonLow || nsigmatofK>fnSigmaTOFKaonHi)) continue;
+ if(!TESTBIT(seleFlags[iTrkP1],kBitKaonCompat)) continue;
+ }
+ Bool_t okForLcTopKpi=kTRUE;
+ Int_t pidLcStatus=3; // 3= OK as pKpi and Kpipi
+ if(fUsePIDforLc>0){
+ if(!TESTBIT(seleFlags[iTrkN1],kBitProtonCompat) &&
+ !TESTBIT(seleFlags[iTrkN2],kBitProtonCompat) ){
+ okForLcTopKpi=kFALSE;
+ pidLcStatus=0;
+ }
+ if(okForLcTopKpi && fUsePIDforLc>1){
+ okForLcTopKpi=kFALSE;
+ pidLcStatus=0;
+ if(TESTBIT(seleFlags[iTrkN1],kBitProtonCompat) &&
+ TESTBIT(seleFlags[iTrkN2],kBitPionCompat) ){
+ okForLcTopKpi=kTRUE;
+ pidLcStatus+=1; // 1= OK as pKpi
+ }
+ if(TESTBIT(seleFlags[iTrkN2],kBitProtonCompat) &&
+ TESTBIT(seleFlags[iTrkN1],kBitPionCompat) ){
+ okForLcTopKpi=kTRUE;
+ pidLcStatus+=2; // 2= OK as piKp
+ }
+ }
+ }
+ Bool_t okForDsToKKpi=kTRUE;
+ if(fUseKaonPIDforDs){
+ if(!TESTBIT(seleFlags[iTrkN1],kBitKaonCompat) &&
+ !TESTBIT(seleFlags[iTrkN2],kBitKaonCompat) ) okForDsToKKpi=kFALSE;
}
// back to primary vertex
Double_t pyDau[3]={momneg1[1],mompos1[1],momneg2[1]};
Double_t pzDau[3]={momneg1[2],mompos1[2],momneg2[2]};
// massCutOK = SelectInvMassAndPt3prong(threeTrackArray);
- massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau);
+ massCutOK = SelectInvMassAndPt3prong(pxDau,pyDau,pzDau,pidLcStatus);
}
if(!massCutOK) {
threeTrackArray->Clear();
if(f3Prong) {
AliAODVertex* secVert3PrAOD = ReconstructSecondaryVertex(threeTrackArray,dispersion);
- io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp1n2,dcap1n1,dcap1n2,dcan1n2,ok3Prong);
+ io3Prong = Make3Prong(threeTrackArray,event,secVert3PrAOD,dispersion,vertexp1n1,vertexp1n2,dcap1n1,dcap1n2,dcan1n2,okForLcTopKpi,okForDsToKKpi,ok3Prong);
if(ok3Prong) {
AliAODVertex *v3Prong = new(verticesHFRef[iVerticesHF++])AliAODVertex(*secVert3PrAOD);
if(!isLikeSign3Prong) {
id = (Int_t)track->GetID();
//printf("---> %d\n",id);
if(id<0) continue; // this track is a AliAODRecoDecay
- aodTrack = (AliAODTrack*)event->GetTrack(fAODMap[id]);
+ aodTrack = dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[id]));
+ if(!aodTrack) AliFatal("Not a standard AOD");
v->AddDaughter(aodTrack);
}
memset(fAODMap,0,sizeof(Int_t)*fAODMapSize);
for(Int_t i=0; i<aod->GetNumberOfTracks(); i++) {
- track = aod->GetTrack(i);
+ track = dynamic_cast<AliAODTrack*>(aod->GetTrack(i));
+ if(!track) AliFatal("Not a standard AOD");
// skip pure ITS SA tracks
if(track->GetStatus()&AliESDtrack::kITSpureSA) continue;
if(cascade) continue;
for(id=0; id<nDgs; id++) {
if (ids[id]>-1 && ids[id] < fAODMapSize) {
- track = aod->GetTrack(fAODMap[ids[id]]);
+ track = dynamic_cast<AliAODTrack*>(aod->GetTrack(fAODMap[ids[id]]));
+ if(!track) AliFatal("Not a standard AOD");
vertex->AddDaughter(track);
}
}
if(fInputAOD){
Int_t idSoftPi=(Int_t)trackPi->GetID();
if (idSoftPi > -1 && idSoftPi < fAODMapSize) {
- AliAODTrack* trackPiAOD=(AliAODTrack*)event->GetTrack(fAODMap[idSoftPi]);
+ AliAODTrack* trackPiAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idSoftPi]));
+ if(!trackPiAOD) AliFatal("Not a standard AOD");
tmpCascade->GetSecondaryVtx()->AddDaughter(trackPiAOD);
}
}else{
if(fInputAOD){
Int_t idBachelor=(Int_t)trackBachelor->GetID();
if (idBachelor > -1 && idBachelor < fAODMapSize) {
- AliAODTrack* trackBachelorAOD=(AliAODTrack*)event->GetTrack(fAODMap[idBachelor]);
+ AliAODTrack* trackBachelorAOD=dynamic_cast<AliAODTrack*>(event->GetTrack(fAODMap[idBachelor]));
+ if(!trackBachelorAOD) AliFatal("Not a standard AOD");
tmpCascade->GetSecondaryVtx()->AddDaughter(trackBachelorAOD);
}
}else{
AliAODVertex *secVert,Double_t dispersion,
const AliAODVertex *vertexp1n1,const AliAODVertex *vertexp2n1,
Double_t dcap1n1,Double_t dcap2n1,Double_t dcap1p2,
- Bool_t &ok3Prong)
+ Bool_t useForLc, Bool_t useForDs, Bool_t &ok3Prong)
{
// Make 3Prong candidates and check if they pass Dplus or Ds or Lambdac
// reconstruction cuts
ok3Prong = kTRUE;
the3Prong->SetSelectionBit(AliRDHFCuts::kDplusCuts);
}
- if(fOKInvMassDs && fCutsDstoKKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
- ok3Prong = kTRUE;
- the3Prong->SetSelectionBit(AliRDHFCuts::kDsCuts);
+ if(useForDs && fOKInvMassDs){
+ if(fCutsDstoKKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
+ ok3Prong = kTRUE;
+ the3Prong->SetSelectionBit(AliRDHFCuts::kDsCuts);
+ }
+ }
+ if(useForLc && fOKInvMassLc){
+ if(fCutsLctopKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
+ ok3Prong = kTRUE;
+ the3Prong->SetSelectionBit(AliRDHFCuts::kLcCuts);
+ }
}
- if(fOKInvMassLc && fCutsLctopKpi->IsSelected(the3Prong,AliRDHFCuts::kCandidate,(AliAODEvent*)event)) {
- ok3Prong = kTRUE;
- the3Prong->SetSelectionBit(AliRDHFCuts::kLcCuts);
- }
}
//if(fDebug) printf("ok3Prong: %d\n",(Int_t)ok3Prong);
rmId[i]=9999;
}
}
- Float_t diamondxy[2]={event->GetDiamondX(),event->GetDiamondY()};
+ Float_t diamondxy[2]={static_cast<Float_t>(event->GetDiamondX()),static_cast<Float_t>(event->GetDiamondY())};
vertexESD = vertexer->RemoveTracksFromVertex(fV1,&rmArray,rmId,diamondxy);
delete [] rmId; rmId=NULL;
rmArray.Delete();
return vertexAOD;
}
- Double_t vertRadius2=vertexESD->GetXv()*vertexESD->GetXv()+vertexESD->GetYv()*vertexESD->GetYv();
+ Double_t vertRadius2=vertexESD->GetX()*vertexESD->GetX()+vertexESD->GetY()*vertexESD->GetY();
if(vertRadius2>8.){
// vertex outside beam pipe, reject candidate to avoid propagation through material
delete vertexESD; vertexESD=NULL;
//-----------------------------------------------------------------------------
Bool_t AliAnalysisVertexingHF::SelectInvMassAndPt3prong(Double_t *px,
Double_t *py,
- Double_t *pz){
+ Double_t *pz,
+ Int_t pidLcStatus){
// Check invariant mass cut and pt candidate cut
//AliCodeTimerAuto("",0);
mrange=fCutsLctopKpi->GetMassCut();
lolim=fMassLambdaC-mrange;
hilim=fMassLambdaC+mrange;
- pdg3[0]=2212; pdg3[1]=321; pdg3[2]=211;
- minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
- if(minv2>lolim*lolim && minv2<hilim*hilim ){
- retval=kTRUE;
- fOKInvMassLc=kTRUE;
+ if(pidLcStatus&1){
+ pdg3[0]=2212; pdg3[1]=321; pdg3[2]=211;
+ minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
+ if(minv2>lolim*lolim && minv2<hilim*hilim ){
+ retval=kTRUE;
+ fOKInvMassLc=kTRUE;
+ }
}
- pdg3[0]=211; pdg3[1]=321; pdg3[2]=2212;
- minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
- if(minv2>lolim*lolim && minv2<hilim*hilim ){
- retval=kTRUE;
- fOKInvMassLc=kTRUE;
+ if(pidLcStatus&2){
+ pdg3[0]=211; pdg3[1]=321; pdg3[2]=2212;
+ minv2 = fMassCalc3->InvMass2(nprongs,pdg3);
+ if(minv2>lolim*lolim && minv2<hilim*hilim ){
+ retval=kTRUE;
+ fOKInvMassLc=kTRUE;
+ }
}
return retval;
Int_t nprongs=2;
Double_t minv2,mrange;
Double_t lolim,hilim;
- Double_t minPt=0;
+ // Double_t minPt=0;
Bool_t retval=kFALSE;
fMassCalc2->SetPxPyPzProngs(nprongs,px,py,pz);
- minPt=fCutsLctoV0->GetMinPtCandidate();
+ // minPt=fCutsLctoV0->GetMinPtCandidate();
fOKInvMassLctoV0=kFALSE;
mrange=fCutsLctoV0->GetMassCut();
lolim=fMassLambdaC-mrange;
if(okDisplaced) SETBIT(seleFlags[nSeleTrks],kBitDispl);
if(okFor3Prong) SETBIT(seleFlags[nSeleTrks],kBit3Prong);
if(okSoftPi) SETBIT(seleFlags[nSeleTrks],kBitSoftPi);
+
+ // Check the PID
+ SETBIT(seleFlags[nSeleTrks],kBitPionCompat);
+ SETBIT(seleFlags[nSeleTrks],kBitKaonCompat);
+ SETBIT(seleFlags[nSeleTrks],kBitProtonCompat);
+ Bool_t useTPC=kTRUE;
+ if(fUseTOFPID){
+ Double_t nsigmatofPi= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kPion);
+ if(nsigmatofPi>-990. && (nsigmatofPi<-fnSigmaTOFPionLow || nsigmatofPi>fnSigmaTOFPionHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitPionCompat);
+ }
+ Double_t nsigmatofK= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kKaon);
+ if(nsigmatofK>-990. && (nsigmatofK<-fnSigmaTOFKaonLow || nsigmatofK>fnSigmaTOFKaonHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitKaonCompat);
+ }
+ Double_t nsigmatofP= fPidResponse->NumberOfSigmasTOF(esdt,AliPID::kProton);
+ if(nsigmatofP>-990. && (nsigmatofP<-fnSigmaTOFProtonLow || nsigmatofP>fnSigmaTOFProtonHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitProtonCompat);
+ }
+ if(fUseTPCPIDOnlyIfNoTOF && nsigmatofPi>-990.) useTPC=kFALSE;
+ }
+ if(useTPC && fUseTPCPID && esdt->P()<fMaxMomForTPCPid){
+ Double_t nsigmatpcPi= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kPion);
+ if(nsigmatpcPi>-990. && (nsigmatpcPi<-fnSigmaTPCPionLow || nsigmatpcPi>fnSigmaTPCPionHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitPionCompat);
+ }
+ Double_t nsigmatpcK= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kKaon);
+ if(nsigmatpcK>-990. && (nsigmatpcK<-fnSigmaTPCKaonLow || nsigmatpcK>fnSigmaTPCKaonHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitKaonCompat);
+ }
+ Double_t nsigmatpcP= fPidResponse->NumberOfSigmasTPC(esdt,AliPID::kProton);
+ if(nsigmatpcP>-990. && (nsigmatpcP<-fnSigmaTPCProtonLow || nsigmatpcP>fnSigmaTPCProtonHi)){
+ CLRBIT(seleFlags[nSeleTrks],kBitProtonCompat);
+ }
+ }
nSeleTrks++;
} else {
if(fInputAOD) delete esdt;
fMassDstar=TDatabasePDG::Instance()->GetParticle(413)->Mass();
fMassJpsi=TDatabasePDG::Instance()->GetParticle(443)->Mass();
}
+//-----------------------------------------------------------------------------
+Bool_t AliAnalysisVertexingHF::CheckCutsConsistency(){
+ //
+ // Check the Vertexer and the analysts task consitstecny
+ //
+
+
+ //___ Check if the V0 type from AliRDHFCutsLctoV0 is the same as the one set in the ConfigVertexingHF.C for AliAnalysisVertexingHF
+
+
+ if ( fCutsLctoV0 && fV0TypeForCascadeVertex != fCutsLctoV0->GetV0Type())
+ {
+ printf("ERROR: V0 type doesn not match in AliAnalysisVertexingHF (%d) required in AliRDHFCutsLctoV0 (%d)\n",fV0TypeForCascadeVertex,fCutsLctoV0->GetV0Type());
+ return kFALSE;
+ }
+ return kTRUE;
+}
+//-----------------------------------------------------------------------------
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff