- Added option to disable/enable request for SPD vertex to AliRsnCutPrimaryVertex
- Added value for number of tracklets
- Improved event statistics plot in mini task to include counters ofr discarded events
- Fixed cut on chi2/dof for AOD tracks
- Updated cuts for D0 analysis + macros
AliRsnCutDaughterD0::AliRsnCutDaughterD0(const char *name, AliPID::EParticleType pid) :
AliRsnCut(name, AliRsnTarget::kDaughter),
fNoPID(kFALSE),
+ //fIsCheckOnMother(kFALSE),
fPID(pid),
fCutQuality(Form("%sQuality", name)),
fPionTPCPIDCut(3.0),
{
//
// Constructor
- // Initialize track quality cuts to 2010 defaults
+ //
//
fCutQuality.SetPtRange(0.15, 1E+20);
fCutQuality.SetEtaRange(-0.8, 0.8);
- fCutQuality.SetDCARPtFormula("0.0105+0.0350/pt^1.1");
+ fCutQuality.SetDCARPtFormula("");
fCutQuality.SetDCARmin(0.0);
fCutQuality.SetDCAZmax(2.0);
- fCutQuality.SetSPDminNClusters(1);
+ fCutQuality.SetSPDminNClusters(0);
fCutQuality.SetITSminNClusters(0);
fCutQuality.SetITSmaxChi2(1E+20);
- fCutQuality.SetTPCminNClusters(70);
- fCutQuality.SetTPCmaxChi2(4.0);
+ fCutQuality.SetTPCminNClusters(0);
+ fCutQuality.SetMinNCrossedRowsTPC(0,kTRUE);
+ fCutQuality.SetMinNCrossedRowsOverFindableClsTPC(0.00,kTRUE);
+ fCutQuality.SetTPCmaxChi2(1E20);
fCutQuality.SetRejectKinkDaughters();
- fCutQuality.SetAODTestFilterBit(5);
+ fCutQuality.SetAODTestFilterBit(-1);
}
//__________________________________________________________________________________________________
// coherence check
if (!TargetOK(obj)) return kFALSE;
+
+ // if this class is used to check the mothers in the acceptance, accept (will be applied only selection on min pt and eta)
+ //if (fIsCheckOnMother) return kTRUE;
// check track
AliVTrack *track = dynamic_cast<AliVTrack *>(fDaughter->GetRef());
// if no PID is required, accept
if (fNoPID) return kTRUE;
+
// check initialization of PID object
AliPIDResponse *pid = fEvent->GetPIDResponse();
if (!pid) {
return kFALSE;
}
- AliDebugClass(2, "Checking TOF Matching...");
- // check if TOF is matched
+ AliDebugClass(2, "Checking TPC and TOF Matching...");
+ // check if TPC and TOF are matched
// and computes all values used in the PID cut
+ Bool_t isTPC = MatchTPC(track);
Bool_t isTOF = MatchTOF(track);
AliDebugClass(2, "...passed");
if(!fPtDepPIDCut){
// applies the cut differently depending on the PID and the momentum
- if (isTOF) {
+ if (isTPC && isTOF) {
if (fPID == AliPID::kPion) {maxTPC = fPionTPCPIDCut; maxTOF = fPionTOFPIDCut;}
if (fPID == AliPID::kKaon) {maxTPC = fKaonTPCPIDCut; maxTOF = fKaonTOFPIDCut;}
return (nsTPC <= maxTPC && nsTOF <= maxTOF);
- } else {
+ } else if (isTPC){
if (fPID == AliPID::kPion) maxTPC = fPionTPCPIDCut;
if (fPID == AliPID::kKaon) maxTPC = fKaonTPCPIDCut;
return (nsTPC <= maxTPC);
}
+ else return kTRUE;
} else {
// applies the cut differently depending on the PID and the momentum
- if (isTOF) {
+ if (isTPC && isTOF) {
// TPC: 5sigma cut for all
if (nsTPC > 5.0) return kFALSE;
// TOF: 3sigma below 1.5 GeV, 2sigma above
if (p < 1.5) maxTOF = 3.0; else maxTOF = 2.0;
return (nsTOF <= maxTOF);
- } else {
+ } else if(isTPC){
// TPC:
// all below 350 MeV: 5sigma
// all between 350 and 500 MeV: 3sigma
}
return (nsTPC <= maxTPC);
}
+ else return kTRUE;
}
AliDebugClass(2, "...passed");
//
#include "AliVTrack.h"
+#include "AliPID.h"
+#include "AliPIDResponse.h"
#include "AliRsnCut.h"
#include "AliRsnCutTrackQuality.h"
virtual ~AliRsnCutDaughterD0() { }
void SetNoPID(Bool_t yn = kTRUE) {fNoPID = yn;}
+ //void SetIsCheckOnMother(Bool_t yn = kTRUE) {fIsCheckOnMother = yn;}
void SetPtDependentPIDCut(Bool_t yn = kTRUE) {fPtDepPIDCut = yn;}
void SetPID(AliPID::EParticleType type) {fPID = type;}
AliRsnCutTrackQuality *CutQuality() {return &fCutQuality;}
Bool_t MatchTOF(const AliVTrack *vtrack);
+ Bool_t MatchTPC(const AliVTrack *vtrack);
virtual Bool_t IsSelected(TObject *obj);
private:
Bool_t fNoPID; // flag to switch off PID check
+ //Bool_t fIsCheckOnMother; // flag to switch off tracks check
AliPID::EParticleType fPID; // PID for track
AliRsnCutTrackQuality fCutQuality; // track quality cut
Double_t fKaonTOFPIDCut; // TOF nsigmas for kaons
Bool_t fPtDepPIDCut; // flag for setting a pt dependent or independent PID cut
- ClassDef(AliRsnCutDaughterD0, 2) // cut definitions for D0
+ ClassDef(AliRsnCutDaughterD0, 3) // cut definitions for D0
};
//__________________________________________________________________________________________________
AliWarning("NULL argument: impossible to check status");
return kFALSE;
}
+ AliPIDResponse *fPidResponse = fEvent->GetPIDResponse();
+ if (!fPidResponse) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ AliPIDResponse::EDetPidStatus status = fPidResponse->CheckPIDStatus(AliPIDResponse::kTOF,vtrack);
+ if (status != AliPIDResponse::kDetPidOk) return kFALSE;
+ Float_t probMis = fPidResponse->GetTOFMismatchProbability(vtrack);
+ if (probMis > 0.01) return kFALSE;
+ if ((vtrack->GetStatus()&AliESDtrack::kTOFpid )==0 && vtrack->GetStatus()&AliESDtrack::kITSrefit ) return kFALSE;
+ return kTRUE;
+
- if (!(vtrack->GetStatus() & AliESDtrack::kTOFout)) return kFALSE;
- if (!(vtrack->GetStatus() & AliESDtrack::kTIME )) return kFALSE;
+ //if (!(vtrack->GetStatus() & AliESDtrack::kTOFout)) return kFALSE;
+ //if (!(vtrack->GetStatus() & AliESDtrack::kTIME )) return kFALSE;
return kTRUE;
}
+//___________________________________________________________________________________________________
+inline Bool_t AliRsnCutDaughterD0::MatchTPC(const AliVTrack *vtrack)
+{
+ // Check if the track is good for TPC PID
+
+
+ if (!vtrack) {
+ AliWarning("NULL argument: impossible to check status");
+ return kFALSE;
+ }
+ AliPIDResponse *fPidResponse = fEvent->GetPIDResponse();
+ if (!fPidResponse) {
+ AliFatal("NULL PID response");
+ return kFALSE;
+ }
+
+ AliPIDResponse::EDetPidStatus status = fPidResponse->CheckPIDStatus(AliPIDResponse::kTPC,vtrack);
+ if (status != AliPIDResponse::kDetPidOk) return kFALSE;
+ UInt_t nclsTPCPID = vtrack->GetTPCsignalN();
+ if(nclsTPCPID<0) return kFALSE;
+ return kTRUE;
+}
+
#endif
//_________________________________________________________________________________________________
AliRsnCutPrimaryVertex::AliRsnCutPrimaryVertex
-(const char *name, Double_t maxVz, Int_t nContributors, Bool_t acceptTPC) :
+(const char *name, Double_t maxVz, Int_t nContributors, Bool_t acceptTPC, Bool_t acceptSPD) :
AliRsnCut(name, AliRsnCut::kEvent, 0, nContributors - 1, -maxVz, maxVz + 1E-6),
fAcceptTPC(acceptTPC),
+ fAcceptSPD(acceptSPD),
fCheckPileUp(kFALSE)
{
//
fCutValueI = ncTrk;
fCutValueD = vzTrk;
} else if (vSPD && ncSPD > 0) {
+ if (!fAcceptSPD)
+ return kFALSE;
+ else {
fCutValueI = ncSPD;
fCutValueD = vzSPD;
+ }
} else if (vTPC && ncTPC > 0) {
if (!fAcceptTPC)
return kFALSE;
// we first check if the SPD primary vertex is there
// if it is not, then the only available is the TPC
// stand-alone primary vertex, which is rejected
- AliAODVertex *aodv = aod->GetPrimaryVertexSPD();
- if (!aodv) {
- AliDebugClass(1, "Not found SPD vertex --> TPC only available, skipped");
- return kFALSE;
- }
- // now check primary vertex
- aodv = (AliAODVertex *)aod->GetPrimaryVertex();
- if (CheckVertex(aodv)) {
- AliDebugClass(1, "Vertex TRK is OK");
- fCutValueD = aodv->GetZ();
- fCutValueI = aodv->GetNDaughters(); //aodv->GetNContributors();
- }
- else {
- aodv = aod->GetPrimaryVertexSPD();
- if (CheckVertex(aodv)) {
- AliDebugClass(1, "Vertex TRK is BAD, but vertex SPD is OK");
- fCutValueD = aodv->GetZ();
- fCutValueI = aodv->GetNDaughters(); //aodv->GetNContributors();
- } else {
- AliDebugClass(1, "Vertex TRK is BAD, and vertex SPD is BAD");
- return kFALSE;
- }
- }
- } else
- return kFALSE;
+
+ if(fAcceptSPD){
+ AliAODVertex *aodv = aod->GetPrimaryVertexSPD();
+ if (!aodv) {
+ AliDebugClass(1, "Not found SPD vertex --> TPC only available, skipped");
+ return kFALSE;
+ }
+ // now check primary vertex
+ aodv = (AliAODVertex *)aod->GetPrimaryVertex();
+ if (CheckVertex(aodv)) {
+ AliDebugClass(1, "Vertex TRK is OK");
+ fCutValueD = aodv->GetZ();
+ fCutValueI = aodv->GetNDaughters(); //aodv->GetNContributors();
+ }
+ else {
+ aodv = aod->GetPrimaryVertexSPD();
+ if (CheckVertex(aodv)) {
+ AliDebugClass(1, "Vertex TRK is BAD, but vertex SPD is OK");
+ fCutValueD = aodv->GetZ();
+ fCutValueI = aodv->GetNDaughters(); //aodv->GetNContributors();
+ } else {
+ AliDebugClass(1, "Vertex TRK is BAD, and vertex SPD is BAD");
+ return kFALSE;
+ }
+
+ }
+ }
+ else{
+ const AliVVertex *vertex = aod->GetPrimaryVertex();
+ if(!vertex) return kFALSE;
+ else{
+ TString title=vertex->GetTitle();
+ if(title.Contains("Z") ) return kFALSE;
+ else if(title.Contains("3D") ) return kFALSE;
+ fCutValueI = vertex->GetNContributors();
+ fCutValueD = TMath::Abs(vertex->GetZ());
+ }
+ }
+
+ } else
+ return kFALSE;
// output
Bool_t result = ((!OkRangeI()) && OkRangeD());
AliInfo(Form("Cut name : %s", GetName()));
AliInfo(Form("Accepting TPC primary vertex : %s", (fAcceptTPC ? "YES" : "NO")));
+ AliInfo(Form("Accepting SPD primary vertex : %s", (fAcceptSPD ? "YES" : "NO")));
AliInfo(Form("Contributors range (outside) : %d - %d", fMinI, fMaxI));
AliInfo(Form("Z-vertex range (inside) : %f - %f", fMinD, fMaxD));
}
class AliRsnCutPrimaryVertex : public AliRsnCut {
public:
- AliRsnCutPrimaryVertex(const char *name = "cutPrimVert", Double_t maxVz = 10.0, Int_t minContributors = 1, Bool_t acceptTPC = kFALSE);
+ AliRsnCutPrimaryVertex(const char *name = "cutPrimVert", Double_t maxVz = 10.0, Int_t minContributors = 1, Bool_t acceptTPC = kFALSE, Bool_t acceptSPD = kTRUE);
virtual ~AliRsnCutPrimaryVertex() {;};
void SetCheckPileUp(Bool_t doit = kTRUE) {fCheckPileUp = doit;}
Bool_t CheckVertex(AliVVertex *vert);
Bool_t fAcceptTPC; // if kTRUE, the TPC primary vertexes are accepted
+ Bool_t fAcceptSPD; // if kTRUE, the SPD primary vertexes are accepted
Bool_t fCheckPileUp; // check and reject pileupped events (pp)
- ClassDef(AliRsnCutPrimaryVertex, 1)
+ ClassDef(AliRsnCutPrimaryVertex, 2)
};
#endif
fTPCminNClusters(0),
fTPCmaxChi2(1E20),
fCutMaxChi2TPCConstrainedVsGlobal(1E20),
+ fTrackMaxChi2(1E20),
fIsUseCrossedRowsCut(kFALSE),
fTPCminNCrossedRows(0),
fTPCminCrossedRowsOverFindableCls(0),
fTPCminNClusters(copy.fTPCminNClusters),
fTPCmaxChi2(copy.fTPCmaxChi2),
fCutMaxChi2TPCConstrainedVsGlobal(copy.fCutMaxChi2TPCConstrainedVsGlobal),
+ fTrackMaxChi2(copy.fTrackMaxChi2),
fIsUseCrossedRowsCut(copy.fIsUseCrossedRowsCut),
fTPCminNCrossedRows(copy.fTPCminNCrossedRows),
fTPCminCrossedRowsOverFindableCls(copy.fTPCminCrossedRowsOverFindableCls),
fTPCminNClusters = copy.fTPCminNClusters;
fTPCmaxChi2 = copy.fTPCmaxChi2;
fCutMaxChi2TPCConstrainedVsGlobal = copy.fCutMaxChi2TPCConstrainedVsGlobal;
+ fTrackMaxChi2 = copy.fTrackMaxChi2;
fIsUseCrossedRowsCut=copy.fIsUseCrossedRowsCut;
fTPCminNCrossedRows = copy.fTPCminNCrossedRows;
fTPCminCrossedRowsOverFindableCls = copy.fTPCminCrossedRowsOverFindableCls;
fTPCmaxChi2 = 1E20;
fAODTestFilterBit = -1;
fCutMaxChi2TPCConstrainedVsGlobal = 1E20;
+ fTrackMaxChi2 = 1E20;
fIsUseCrossedRowsCut = 0;
fTPCminNCrossedRows = 0;
fTPCminCrossedRowsOverFindableCls = 0;
return kFALSE;
}
- //check chi square
- if (track->Chi2perNDF() > fTPCmaxChi2) {
- AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
- return kFALSE;
- }
- if (track->Chi2perNDF() > fITSmaxChi2) {
+ //check track chi square
+ if (track->Chi2perNDF() > fTrackMaxChi2) {
AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
return kFALSE;
}
void SetTPCminNClusters(Int_t value) {fTPCminNClusters = value;}
void SetTPCmaxChi2(Double_t value) {fTPCmaxChi2 = value;}
void SetMaxChi2TPCConstrainedGlobal(Float_t max) {fCutMaxChi2TPCConstrainedVsGlobal = max; }
+ void SetTrackMaxChi2(Double_t value) {fTrackMaxChi2 = value;}
void SetMinNCrossedRowsTPC(Double_t min, Bool_t useTPCCrossedRows) {fTPCminNCrossedRows=min; fIsUseCrossedRowsCut=useTPCCrossedRows;}
void SetMinNCrossedRowsOverFindableClsTPC(Double_t min, Bool_t useTPCCrossedRows) {fTPCminCrossedRowsOverFindableCls=min; fIsUseCrossedRowsCut=useTPCCrossedRows;}
void SetMinLengthActiveVolumeTPC(Double_t min, Bool_t on = kFALSE) {fCutMinLengthActiveVolumeTPC=min; fIsUseLengthActiveVolumeTPCCut=on;}
Double_t fTPCmaxChi2; // maximum chi2 / number of clusters in TPC
Float_t fCutMaxChi2TPCConstrainedVsGlobal; // max chi2 TPC track constrained with vtx vs. global track
+ Double_t fTrackMaxChi2; // maximum track chi2/NDF
+
Bool_t fIsUseCrossedRowsCut; //enable cut on minimum number of TPC crossed rows
Float_t fTPCminNCrossedRows; // minimum number of TPC crossed rows
Float_t fTPCminCrossedRowsOverFindableCls; // minimum number of crossed rows/findable clusters
Bool_t fCheckOnlyFilterBit; // check only the filter bit
AliESDtrackCuts *fESDtrackCuts; // pointer to AliESDtrackCuts object
- ClassDef(AliRsnCutTrackQuality, 4)
+ ClassDef(AliRsnCutTrackQuality, 5)
};
#endif
fValues("AliRsnMiniValue", 0),
fHEventStat(0x0),
fHAEventsVsMulti(0x0),
+ fHAEventsVsTracklets(0x0),
fHAEventVz(0x0),
fHAEventMultiCent(0x0),
fHAEventPlane(0x0),
fValues("AliRsnMiniValue", 0),
fHEventStat(0x0),
fHAEventsVsMulti(0x0),
+ fHAEventsVsTracklets(0x0),
fHAEventVz(0x0),
fHAEventMultiCent(0x0),
fHAEventPlane(0x0),
fValues(copy.fValues),
fHEventStat(0x0),
fHAEventsVsMulti(0x0),
+ fHAEventsVsTracklets(0x0),
fHAEventVz(0x0),
fHAEventMultiCent(0x0),
fHAEventPlane(0x0),
fValues = copy.fValues;
fHEventStat = copy.fHEventStat;
fHAEventsVsMulti = copy.fHAEventsVsMulti;
+ fHAEventsVsTracklets = copy.fHAEventsVsTracklets;
fHAEventVz = copy.fHAEventVz;
fHAEventMultiCent = copy.fHAEventMultiCent;
fHAEventPlane = copy.fHAEventPlane;
fOutput->SetOwner();
// initialize event statistics counter
- fHEventStat = new TH1F("hEventStat", "Event statistics", 4, 0.0, 4.0);
+ fHEventStat = new TH1F("hEventStat", "Event statistics", 8, 0.0, 8.0);
fHEventStat->GetXaxis()->SetBinLabel(1, "CINT1B");
fHEventStat->GetXaxis()->SetBinLabel(2, "V0AND");
fHEventStat->GetXaxis()->SetBinLabel(3, "Candle");
fHEventStat->GetXaxis()->SetBinLabel(4, "Accepted");
+ fHEventStat->GetXaxis()->SetBinLabel(5, "Not Accepted - Total");
+ fHEventStat->GetXaxis()->SetBinLabel(6, "Not Accepted - No Track Vertex");
+ fHEventStat->GetXaxis()->SetBinLabel(7, "Not Accepted - Not Enough Contributors");
+ fHEventStat->GetXaxis()->SetBinLabel(8, "Not Accepted - No Vertex inside |z| < 10 cm");
+
fOutput->Add(fHEventStat);
if (fUseCentrality)
else
fHAEventsVsMulti = new TH1F("hAEventsVsMulti", "Accepted events vs Multiplicity",1000, 0, 1000.0);
fOutput->Add(fHAEventsVsMulti);
+
+ fHAEventsVsTracklets = new TH1F("hAEventsVsTracklets", "Accepted events vs Tracklet Number",1000, 0, 1000.0);
+ fOutput->Add(fHAEventsVsTracklets);
if(fHAEventVz) fOutput->Add(fHAEventVz);
if(fHAEventMultiCent) fOutput->Add(fHAEventMultiCent);
if (isSelected) {
fHEventStat->Fill(3.1);
Double_t multi = ComputeCentrality((output == 'E'));
+ Double_t tracklets = ComputeTracklets();
fHAEventsVsMulti->Fill(multi);
+ fHAEventsVsTracklets->Fill(tracklets);
if(fHAEventVz) fHAEventVz->Fill(multi,fInputEvent->GetPrimaryVertex()->GetZ());
if(fHAEventMultiCent) fHAEventMultiCent->Fill(multi,ComputeMultiplicity(output == 'E',fHAEventMultiCent->GetYaxis()->GetTitle()));
if(fHAEventPlane) fHAEventPlane->Fill(multi,ComputeAngle());
return output;
} else {
+ fHEventStat->Fill(4.1);
+ const AliVVertex *vertex = fInputEvent->GetPrimaryVertex();
+ if(!vertex) fHEventStat->Fill(5.1);
+ else{
+ TString title=vertex->GetTitle();
+ if( (title.Contains("Z")) || (title.Contains("3D")) ) fHEventStat->Fill(5.1);
+ if(vertex->GetNContributors()<1.) fHEventStat->Fill(6.1);
+ if(TMath::Abs(vertex->GetZ())>10.) fHEventStat->Fill(7.1);
+ }
return 0;
}
}
fMiniEvent->Vz() = fInputEvent->GetPrimaryVertex()->GetZ();
fMiniEvent->Angle() = ComputeAngle();
fMiniEvent->Mult() = ComputeCentrality((evType == 'E'));
+ fMiniEvent->Tracklets() = ComputeTracklets();
AliDebugClass(2, Form("Event %d: type = %c -- vz = %f -- mult = %f -- angle = %f", fEvNum, evType, fMiniEvent->Vz(), fMiniEvent->Mult(), fMiniEvent->Angle()));
// loop on daughters and assign track-related values
}
}
+//__________________________________________________________________________________________________
+Double_t AliRsnMiniAnalysisTask::ComputeTracklets()
+{
+//
+// Get number of tracklets
+//
+
+ Double_t count = 100;
+
+ if (fInputEvent->InheritsFrom(AliESDEvent::Class())){
+ AliESDEvent *esdEvent = (AliESDEvent *)fInputEvent;
+ const AliMultiplicity *spdmult = esdEvent->GetMultiplicity();
+ count = 1.0*spdmult->GetNumberOfTracklets();
+ }
+ else if (fInputEvent->InheritsFrom(AliAODEvent::Class())) {
+ AliAODEvent *aodEvent = (AliAODEvent *)fInputEvent;
+ AliAODTracklets *spdmult = aodEvent->GetTracklets();
+ count = 1.0*spdmult->GetNumberOfTracklets();
+ }
+
+ return count;
+}
+
//__________________________________________________________________________________________________
void AliRsnMiniAnalysisTask::FillTrueMotherESD(AliRsnMiniEvent *miniEvent)
{
Double_t ComputeAngle();
Double_t ComputeCentrality(Bool_t isESD);
Double_t ComputeMultiplicity(Bool_t isESD,TString type);
+ Double_t ComputeTracklets();
Double_t ApplyCentralityPatchAOD049();
Double_t ApplyCentralityPatchPbPb2011();
void FillTrueMotherESD(AliRsnMiniEvent *event);
TClonesArray fValues; // list of values to be computed
TH1F *fHEventStat; // histogram of event statistics
TH1F *fHAEventsVsMulti; // histogram of event statistics
+ TH1F *fHAEventsVsTracklets; // histogram of event statistics
TH2F *fHAEventVz; // histogram of vertex-z vs. multiplicity/centrality
TH2F *fHAEventMultiCent;// histogram of multiplicity vs. centrality
TH2F *fHAEventPlane; // histogram of event plane vs. multiplicity/centrality
Bool_t fKeepDfromBOnly; // flag to keep only the charm particles that comes from beauty decays (specific for D meson analysis)
Bool_t fRejectIfNoQuark; // flag to remove events not generated with PYTHIA
- ClassDef(AliRsnMiniAnalysisTask, 9); // AliRsnMiniAnalysisTask
+ ClassDef(AliRsnMiniAnalysisTask, 10); // AliRsnMiniAnalysisTask
};
class AliRsnMiniEvent : public TObject {
public:
- AliRsnMiniEvent() : fID(-1), fVz(0.0), fMult(0.0), fAngle(0.0), fLeading(-1), fParticles("AliRsnMiniParticle", 0) {}
+ AliRsnMiniEvent() : fID(-1), fVz(0.0), fMult(0.0), fTracklets(0.0), fAngle(0.0), fLeading(-1), fParticles("AliRsnMiniParticle", 0) {}
~AliRsnMiniEvent() {fParticles.Delete();}
Int_t &ID() {return fID;}
Float_t &Vz() {return fVz;}
Float_t &Mult() {return fMult;}
+ Float_t &Tracklets() {return fTracklets;}
Float_t &Angle() {return fAngle;}
TClonesArray &Particles() {return fParticles;}
Bool_t IsEmpty() {return fParticles.IsEmpty();}
Int_t fID; // ID number
Float_t fVz; // z-position of vertex
Float_t fMult; // multiplicity or centrality
+ Float_t fTracklets; // tracklets
Float_t fAngle; // angle of reaction plane to main reference frame
Int_t fLeading; // index of leading particle
TClonesArray fParticles; // list of selected particles
- ClassDef(AliRsnMiniEvent,2)
+ ClassDef(AliRsnMiniEvent,4)
};
#endif
switch (type) {
case kVz: return "EventVz";
case kMult: return "EventMult";
+ case kTracklets: return "EventTracklets";
case kPlaneAngle: return "EventPlane";
case kLeadingPt: return "EventLeadingPt";
case kPt: return "Pt";
return event->Vz();
case kMult:
return event->Mult();
+ case kTracklets:
+ return event->Tracklets();
case kPlaneAngle:
return event->Angle();
case kLeadingPt:
enum EType {
kVz, // event Z position of primary vertex
kMult, // event multiplicity or centrality (depends on task settings)
+ kTracklets, // event tracklets
kPlaneAngle, // event reaction plane angle
kLeadingPt, // event leading particle momentum
kEventCuts, // -- limit of event cuts ----------------------------------------------------
Float_t trackDCAcutMin = 0.0,
Float_t trackDCAZcutMax = 2.0,
Int_t NTPCcluster = 70,
+ Double_t NTPCcrratio = 0.8,
Int_t minSPDclt = 0,
Double_t minpt = 0.15,
TString triggerMask = AliVEvent::kMB,
- Short_t maxSisters = 2,
- Bool_t checkP = kTRUE,
Bool_t minDCAcutFixed = kFALSE,
Bool_t maxDCAcutFixed = kFALSE,
Bool_t ptdepPIDcut = kFALSE,
Bool_t doCalculationInMC = kTRUE,
UShort_t originDselection = 0,
Int_t nmix = 5,
- Double_t minYlab = -0.5,
- Double_t maxYlab = 0.5,
+ Double_t minYlab = -0.5,
+ Double_t maxYlab = 0.5,
Float_t mineta = -0.8,
Float_t maxeta = 0.8,
Float_t min_inv_mass = 0.6,
// retrieve analysis manager
//
Float_t cutV = 10.0;
+ Short_t maxSisters = 2;
+ Bool_t checkP = kTRUE;
Bool_t checkFeedDown = kTRUE;
Bool_t checkQuark = kTRUE;
Int_t aodN = 0;
}
// create the task and configure
- TString taskName = Form("D0%s%s_%.1f_%d_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.1f_%.5f_%.2f_%d_%s", (isPP? "pp" : ispPb? "pPB": "PbPb"), (isMC ? "MC" : "Data"), cutV, NTPCcluster, minSPDclt, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, trackDCAcutMax, trackDCAcutMin, trackDCAZcutMax, dcaProduct, minpt, originDselection, eventType.Data());
+ TString taskName = Form("D0%s%s_%.1f_%d_%.2f_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.1f_%.5f_%.2f_%d_%s", (isPP? "pp" : ispPb? "pPB": "PbPb"), (isMC ? "MC" : "Data"), cutV, NTPCcluster, NTPCcrratio, minSPDclt, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, trackDCAcutMax, trackDCAcutMin, trackDCAZcutMax, dcaProduct, minpt, originDselection, eventType.Data());
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
if (!isMC && !isPP){
Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no"));
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
- AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", cutV, 0, kFALSE);
+ AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", cutV, 1, kFALSE, kFALSE);
if(checkpileup == kTRUE){
if(SPDpileup == kTRUE)cutVertex->SetCheckPileUp(kTRUE);
AliRsnCutEventUtils *eventUtils = new AliRsnCutEventUtils("cutEventUtils", kFALSE, kFALSE);
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
+ eventCuts->ShowCuts();
+ eventCuts->PrintSetInfo();
// set cuts in task
task->SetEventCuts(eventCuts);
outMult->AddAxis(multID, 100, 0.0, 100.0);
//tracklets
- //Int_t trackletID = task->CreateValue(AliRsnMiniValue::kTracklets, kFALSE);
- //AliRsnMiniOutput *outTracklets = task->CreateOutput("eventTracklets", "HIST", "EVENT");
- //outTracklets->AddAxis(trackletID, 400, 0.0, 400.0);
+ Int_t trackletID = task->CreateValue(AliRsnMiniValue::kTracklets, kFALSE);
+ AliRsnMiniOutput *outTracklets = task->CreateOutput("eventTracklets", "HIST", "EVENT");
+ outTracklets->AddAxis(trackletID, 400, 0.0, 400.0);
//event plane (only for PbPb)
Printf("========================== MC analysis - PID cuts used");
} else
Printf("========================== DATA analysis - PID cuts used");
- if (!ConfigD0(task, isPP, isMC, monitor, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, aodFilterBit, trackDCAcutMax, trackDCAcutMin, trackDCAZcutMax, NTPCcluster, minSPDclt, minpt, maxSisters, checkP, minDCAcutFixed, maxDCAcutFixed, ptdepPIDcut, checkFeedDown, checkQuark, doCalculationInMC, originDselection, mineta, maxeta, min_inv_mass, max_inv_mass, bins, "", cutsPairY, cutsPair)) return 0x0;
+ if (!ConfigD0(task, isPP, isMC, monitor, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, aodFilterBit, trackDCAcutMax, trackDCAcutMin, trackDCAZcutMax, NTPCcluster, NTPCcrratio, minSPDclt, minpt, maxSisters, checkP, minDCAcutFixed, maxDCAcutFixed, ptdepPIDcut, checkFeedDown, checkQuark, doCalculationInMC, originDselection, mineta, maxeta, min_inv_mass, max_inv_mass, bins, "", cutsPairY, cutsPair)) return 0x0;
//
// -- CONTAINERS --------------------------------------------------------------------------------
TString outputFileName = AliAnalysisManager::GetCommonFileName();
Printf("AddAnalysisTaskD0 - Set OutputFileName : \n %s\n", outputFileName.Data() );
- AliAnalysisDataContainer *output = mgr->CreateContainer(Form("%s_%.1f_%d_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.1f_%.5f_%.2f_%d_%s",outNameSuffix.Data(),cutV,NTPCcluster,minSPDclt,nsigmaTPCPi,nsigmaTPCKa,nsigmaTOFPi,nsigmaTOFKa,trackDCAcutMax,trackDCAcutMin,trackDCAZcutMax,dcaProduct,minpt,originDselection,eventType.Data()),
+ AliAnalysisDataContainer *output = mgr->CreateContainer(Form("%s_%.1f_%d_%.2f_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.1f_%.5f_%.2f_%d_%s",outNameSuffix.Data(),cutV,NTPCcluster,NTPCcrratio,minSPDclt,nsigmaTPCPi,nsigmaTPCKa,nsigmaTOFPi,nsigmaTOFKa,trackDCAcutMax,trackDCAcutMin,trackDCAZcutMax,dcaProduct,minpt,originDselection,eventType.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
-/
-// *** Configuration script for phi->KK analysis with 2010 runs ***
+//
+// *** Configuration script for D0 analysis ***
//
// A configuration script for RSN package needs to define the followings:
//
Float_t trackDCAcutMin = 0.0,
Float_t trackDCAZcutMax = 2.0,
Int_t NTPCcluster = 70,
+ Double_t NTPCcrratio = 0.8,
Int_t minSPDclt = 0,
Double_t minpt = 0.15,
Short_t maxSisters = 2,
// integrated pion cut
AliRsnCutDaughterD0 *cutPi = new AliRsnCutDaughterD0("cutPionForD0", AliPID::kPion);
+ //cutPi->SetNoPID(kTRUE);
cutPi->SetTPCPionPIDCut(nsigmaTPCPi);
cutPi->SetTOFPionPIDCut(nsigmaTOFPi);
cutPi->SetPtDependentPIDCut(ptdepPIDcut);
if(maxDCAcutFixed)cutQuality->SetDCARmax(trackDCAcutMax);
else cutQuality->SetDCARPtFormula(formula);
if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin);
- else cutQuality->SetDCARPtFormulaMin(formulaMin);
- cutQuality->SetTPCminNClusters(NTPCcluster);
+ else cutQuality->SetDCARPtFormulaMin(formulaMin);
+ cutQuality->SetTPCminNClusters(NTPCcluster);
+ //if(!isPP)cutQuality->SetTPCminNClusters(NTPCcluster);
+ //if(isPP)cutQuality->SetMinNCrossedRowsTPC(NTPCcluster,kTRUE);
+ //if(isPP)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(NTPCcrratio,kTRUE);
cutQuality->SetPtRange(minpt,1E20);
cutQuality->SetEtaRange(mineta, maxeta);
cutQuality->SetDCAZmax(trackDCAZcutMax);
cutQuality->SetSPDminNClusters(minSPDclt);
cutQuality->SetITSminNClusters(0);
- cutQuality->SetITSmaxChi2(36);
- cutQuality->SetTPCmaxChi2(4.0);
+ cutQuality->SetITSmaxChi2(1E20);
+ cutQuality->SetTPCmaxChi2(1E20);
cutQuality->SetRejectKinkDaughters();
cutQuality->Print();
// integrated kaon cut
AliRsnCutDaughterD0 *cutK = new AliRsnCutDaughterD0("cutKaonForD0", AliPID::kKaon);
+ //cutK->SetNoPID(kTRUE);
cutK->SetTPCKaonPIDCut(nsigmaTPCKa);
cutK->SetTOFKaonPIDCut(nsigmaTOFKa);
cutK->SetPtDependentPIDCut(ptdepPIDcut);
if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin);
else cutQuality->SetDCARPtFormulaMin(formulaMin);
cutQuality->SetTPCminNClusters(NTPCcluster);
+ //if(!isPP)cutQuality->SetTPCminNClusters(NTPCcluster);
+ //if(isPP)cutQuality->SetMinNCrossedRowsTPC(NTPCcluster,kTRUE);
+ //if(isPP)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(NTPCcrratio,kTRUE);
cutQuality->SetPtRange(minpt,1E20);
cutQuality->SetEtaRange(mineta, maxeta);
cutQuality->SetDCAZmax(trackDCAZcutMax);
cutQuality->SetSPDminNClusters(minSPDclt);
cutQuality->SetITSminNClusters(0);
- cutQuality->SetITSmaxChi2(36);
- cutQuality->SetTPCmaxChi2(4.0);
+ cutQuality->SetITSmaxChi2(1E20);
+ cutQuality->SetTPCmaxChi2(1E20);
cutQuality->SetRejectKinkDaughters();
cutQuality->Print();
// add to task
Int_t iCutK = task->AddTrackCuts(cutSetK);
+
+
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ // Cut set for mothers -- To be used only for the efficiency evaluation when using the charm enriched sample
+ /*
+ AliRsnCutDaughterD0 *cutPi_mother = new AliRsnCutDaughterD0("cutPionForD0_MC", AliPID::kPion);
+ cutPi_mother->SetIsCheckOnMother(kTRUE);
+ cutPi_mother->SetNoPID(kTRUE);
+ cutPi_mother->SetTPCPionPIDCut(1E20);
+ cutPi_mother->SetTOFPionPIDCut(1E20);
+ cutPi_mother->SetPtDependentPIDCut(kFALSE);
+ AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi_mother->CutQuality();
+ cutQuality->SetCheckOnlyFilterBit(kFALSE);
+ cutQuality->SetAODTestFilterBit(-1);
+ if(maxDCAcutFixed)cutQuality->SetDCARmax(1E20);
+ else cutQuality->SetDCARPtFormula("");
+ if(minDCAcutFixed) cutQuality->SetDCARmin(0);
+ else cutQuality->SetDCARPtFormulaMin("");
+ if(!isPP)cutQuality->SetTPCminNClusters(0);
+ if(isPP)cutQuality->SetMinNCrossedRowsTPC(0,kTRUE);
+ if(isPP)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(0,kTRUE);
+ cutQuality->SetPtRange(0,1E20);
+ cutQuality->SetEtaRange(-1E20, 1E20);
+ cutQuality->SetDCAZmax(1E20);
+ cutQuality->SetSPDminNClusters(0);
+ cutQuality->SetITSminNClusters(0);
+ cutQuality->SetITSmaxChi2(1E20);
+ cutQuality->SetTPCmaxChi2(1E20);
+ cutQuality->SetRejectKinkDaughters();
+ cutQuality->Print();
+
+
+ // cut set
+ AliRsnCutSet *cutSetPi_mother = new AliRsnCutSet("setPionD0_mother", AliRsnTarget::kDaughter);
+ cutSetPi_mother->AddCut(cutPi_mother);
+ cutSetPi_mother->SetCutScheme(cutPi_mother->GetName());
+ // add to task
+ Int_t iCutPi_mother = task->AddTrackCuts(cutSetPi_mother);
+
+
+ AliRsnCutDaughterD0 *cutK_mother = new AliRsnCutDaughterD0("cutKaonForD0_MC", AliPID::kKaon);
+ cutK_mother->SetIsCheckOnMother(kTRUE);
+ cutK_mother->SetNoPID(kTRUE);
+ cutK_mother->SetTPCKaonPIDCut(1E20);
+ cutK_mother->SetTOFKaonPIDCut(1E20);
+ cutK_mother->SetPtDependentPIDCut(kFALSE);
+ AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutK_mother->CutQuality();
+ cutQuality->SetCheckOnlyFilterBit(kFALSE);
+ cutQuality->SetAODTestFilterBit(-1);
+ if(maxDCAcutFixed)cutQuality->SetDCARmax(1E20);
+ else cutQuality->SetDCARPtFormula("");
+ if(minDCAcutFixed) cutQuality->SetDCARmin(0);
+ else cutQuality->SetDCARPtFormulaMin("");
+ if(!isPP)cutQuality->SetTPCminNClusters(0);
+ if(isPP)cutQuality->SetMinNCrossedRowsTPC(0,kTRUE);
+ if(isPP)cutQuality->SetMinNCrossedRowsOverFindableClsTPC(0,kTRUE);
+ cutQuality->SetPtRange(0,1E20);
+ cutQuality->SetEtaRange(-1E20, 1E20);
+ cutQuality->SetDCAZmax(1E20);
+ cutQuality->SetSPDminNClusters(0);
+ cutQuality->SetITSminNClusters(0);
+ cutQuality->SetITSmaxChi2(1E20);
+ cutQuality->SetTPCmaxChi2(1E20);
+ cutQuality->SetRejectKinkDaughters();
+ cutQuality->Print();
+
+
+ // cut set
+ AliRsnCutSet *cutSetK_mother = new AliRsnCutSet("setKaonD0_mother", AliRsnTarget::kDaughter);
+ cutSetK_mother->AddCut(cutK_mother);
+ cutSetK_mother->SetCutScheme(cutK_mother->GetName());
+ // add to task
+ Int_t iCutK_mother = task->AddTrackCuts(cutSetK_mother);
+ */
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
// -- Values ------------------------------------------------------------------------------------
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
// create output
AliRsnMiniOutput *out = task->CreateOutput("D0_True2", mode.Data(), "TRUE");
// selection settings
- out->SetCharge(0, '+');
- out->SetCharge(1, '-');
+ out->SetCutID(0, iCutK);
+ out->SetCutID(1, iCutPi);
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetCharge(0, '+');
+ out->SetCharge(1, '-');
out->SetMotherPDG(-421);
out->SetMotherMass(1.86486);
// pair cuts
else out->AddAxis(centID, 400, 0.0, 400.0);
- }
+ // GENERATED MOTHERS IN THE ACCEPTANCE
+ /*
+ TString mode = "SPARSE";
+
+ // create output
+ AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC1_Acc", mode.Data(), "TRUE");
+ // selection settings
+ out->SetCutID(0, iCutK_mother);
+ out->SetCutID(1, iCutPi_mother);
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetCharge(0, '-');
+ out->SetCharge(1, '+');
+ out->SetMotherPDG(421);
+ out->SetMotherMass(1.86486);
+ // pair cuts
+ out->SetPairCuts(cutsPairY);
+ out->SetMaxNSisters(maxSisters);
+ out->SetCheckMomentumConservation(checkP);
+ out->SetCheckFeedDown(checkFeedDown);
+ out->SetRejectCandidateIfNotFromQuark(checkQuark);
+ out->SetDselection(originDselection);
+ // binnings
+ out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
+ out->AddAxis(ptID, 200, 0.0, 20.0);
+ //out->AddAxis(yID, 100, -1, 1);
+ if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
+ else out->AddAxis(centID, 400, 0.0, 400.0);
+
+ // create output
+ AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC2_Acc", mode.Data(), "TRUE");
+ // selection settings
+ out->SetCutID(0, iCutK_mother);
+ out->SetCutID(1, iCutPi_mother);
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetCharge(0, '+');
+ out->SetCharge(1, '-');
+ out->SetMotherPDG(-421);
+ out->SetMotherMass(1.86486);
+ // pair cuts
+ out->SetPairCuts(cutsPairY);
+ out->SetMaxNSisters(maxSisters);
+ out->SetCheckMomentumConservation(checkP);
+ out->SetCheckFeedDown(checkFeedDown);
+ out->SetRejectCandidateIfNotFromQuark(checkQuark);
+ out->SetDselection(originDselection);
+ // binnings
+ out->AddAxis(imID, bins, min_inv_mass, max_inv_mass);
+ out->AddAxis(ptID, 200, 0.0, 20.0);
+ //out->AddAxis(yID, 100, -1, 1);
+
+ if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
+ else out->AddAxis(centID, 400, 0.0, 400.0);
+
+
+ }
+ */
return kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff