-AliRsnPairManager *RsnConfig_PHI(const char *name="PHI")
+TObjArray DefineFunctions()
{
- return CreatePairs(name, 333, AliAODTrack::kKaon, AliAODTrack::kKaon, 0, 10000);
-}
+//
+// Here, all used AliRsnFunction objects should be defined.
+// Then, by keeping in mind the sorting order of each one,
+// they are recovered to be inserted in AliRanPairs
+//
+
+ TObjArray out(0);
+
+ // define axes
+ AliRsnFunctionAxis *axisIM = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass, 1000, 0.0, 2.0);
+ AliRsnFunctionAxis *axisPt = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt, 10, 0.0, 10.0);
+ AliRsnFunctionAxis *axisEta = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta, 10, -1.0, 1.0);
+ AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult, 8, 0.0, 200.0);
-AliRsnPairManager *RsnConfig_KSTAR(const char *name="KSTAR")
+ // function #0:
+ // invariant mass w.r. to kinematics variables
+
+
+AliRsnFunction* DefineFunctionIM()
{
- return CreatePairs(name, 313, AliAODTrack::kPion, AliAODTrack::kKaon, 0, 10000);
-}
+//
+// In general, for all processed pairs in one analysis the same functions are computed.
+// Then, they are defined separately here and added in the same way to all pairs.
+//
+
+ // define all binnings
+ AliRsnFunctionAxis *axisIM = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass, 1000, 0.0, 2.0);
+ AliRsnFunctionAxis *axisP1 = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack1P, 50, 0.0, 5.0);
+ AliRsnFunctionAxis *axisP2 = new AliRsnFunctionAxis(AliRsnFunctionAxis::kTrack2P, 50, 0.0, 5.0);
+ AliRsnFunctionAxis *axisPt = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt, 10, 0.0, 10.0);
+ AliRsnFunctionAxis *axisEta = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta, 10, -1.0, 1.0);
+ AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult, 8, 0.0, 200.0);
+ // function #0:
+ // inv. mass w.r. to momentum and multiplicity
+ AliRsnFunction *fcn0 = new AliRsnFunction;
+ fcn->AddAxis(axisIM);
+ fcn->AddAxis(axisPt);
+ fcn->AddAxis(axisMult);
+ out->AddLast(fcn0);
+
+ // function #1:
+ // inv. mass w.r. to eta and multiplicity
+ AliRsnFunction *fcn1 = new AliRsnFunction;
+ fcn->AddAxis(axisIM);
+ fcn->AddAxis(axisEta);
+ fcn->AddAxis(axisMult);
+ out->AddLast(fcn1);
+
+ // function #2:
+ // total daughter momenta w.r. to inv. mass
+ AliRsnFunction *fcn2 = new AliRsnFunction;
+ fcn->AddAxis(axisP1);
+ fcn->AddAxis(axisP2);
+ fcn->AddAxis(axisIM);
+ out->AddLast(fcn2);
+
+ return out;
+}
-AliRsnPairManager* CreatePairs
+AliRsnPairManager* CreatePairsNoPID
(
- const char *pairMgrName, // name for the pair manager
- Int_t resonancePDG, // PDG code of resonance (for true pairs)
- AliAODTrack::AODTrkPID_t type1, // PID of one member of decay (+)
- AliAODTrack::AODTrkPID_t type2, // PID of other member of decay (-)
- Int_t multMin, // lower edge of multiplicity cut
- Int_t multMax // upper edge of multiplicity cut
+ const char *pairMgrName, // name for the pair manager
+ Int_t resonancePDG, // PDG code of resonance (for true pairs)
+ AliPID::EParticleType type1, // PID of one member of decay (+)
+ AliPID::EParticleType type2, // PID of other member of decay (-)
+ Double_t bbCut = 10000.0 // cut on Bethe-Bloch
)
{
//
//
AliRsnPairManager *pairMgr = new AliRsnPairManager(pairMgrName);
- //cout << "Creating " << pairMgrName << endl;
-
-// return pairMgr;
// === PAIR DEFINITIONS =========================================================================
// array is organized as follows:
// [0] - true pairs
// [1] - signal
- // [2] - mixing
- // [3] - like PP
- // [4] - like MM
- AliRsnPair *noPIDnoCut[2][5] = {0,0,0,0,0,0,0,0,0,0};
- AliRsnPair *noPIDwithCut[2][5] = {0,0,0,0,0,0,0,0,0,0};
- AliRsnPair *realisticPID[2][5] = {0,0,0,0,0,0,0,0,0,0};
- AliRsnPair *perfectPID[2][5] = {0,0,0,0,0,0,0,0,0,0};
+ // [2] - like PP
+ // [3] - like MM
+ AliRsnPair *noPID[2][4] = {0,0,0,0,0,0,0,0};
for (i = 0; i < nArray; i++) {
- noPIDnoCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
- noPIDnoCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
- noPIDnoCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
- noPIDnoCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
- noPIDnoCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
-
- noPIDwithCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
- noPIDwithCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
- noPIDwithCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
- noPIDwithCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
- noPIDwithCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
+ noPID[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+ noPID[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
+ noPID[i][2] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
+ noPID[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
+ }
- realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
- realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
- realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPIDMix, defUnlike[i]);
- realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
- realisticPID[i][4] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
+ // === CUTS =====================================================================================
+
+ // cuts for tracks:
+ // -- Bethe-Bloch & required kaon PID
+ AliRsnCutBetheBloch *cutKaonBB = new AliRsnCutBetheBloch("cutKaon", bbCut, AliPID::kKaon);
+ cutKaonBB->SetCalibConstant(0, 0.76176e-1);
+ cutKaonBB->SetCalibConstant(1, 10.632);
+ cutKaonBB->SetCalibConstant(2, 0.13279e-4);
+ cutKaonBB->SetCalibConstant(3, 1.8631);
+ cutKaonBB->SetCalibConstant(4, 1.9479);
+
+ // cuts on pairs:
+ // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
+ AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
+
+ // cuts on event:
+ // -- none (specified for whole task)
+
+ // cut set definition for all pairs
+ AliRsnCutSet *cutSetParticle = new AliRsnCutSet("trackCuts");
+ cutSetParticle->AddCut(cutKaonBB);
+ cutSetParticle->SetCutScheme("cutKaonBB");
+
+ // cut set definition for true pairs
+ AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
+ cutSetPairTrue->AddCut(cutTruePair);
+ cutSetPairTrue->SetCutScheme("cutTrue");
+
+ // cut manager for all pairs
+ AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
+ cutMgrAll->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
+
+ // cut manager for all pairs
+ AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
+ cutMgrTrue->SetCutSet(AliRsnCut::kParticle, cutSetParticle);
+ cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
+
+ for (i = 0; i < nArray; i++) {
+ noPID[i][0]->SetCutMgr(cutMgrTrue);
+ for (j = 1; j < 4; j++) {
+ noPID[i][j]->SetCutMgr(cutMgrAll);
+ }
+ }
+
+ // === FUNCTIONS ================================================================================
+
+ TObjArray list = DefineFunctions();
+ AliRsnFunction *fcn0 = (AliRsnFunction*)list[0];
+ AliRsnFunction *fcn1 = (AliRsnFunction*)list[1];
+ AliRsnFunction *fcn0 = (AliRsnFunction*)list[0];
+
+ for (i = 0; i < nArray; i++) {
+ for (j = 0; j < 4; j++) {
+ noPID[i][j]->AddFunction(fcn0);
+ noPID[i][j]->AddFunction(fcn1);
+ if (j < 2) noPID[i][j]->AddFunction(fcn2);
+ }
+ }
+
+ // === ADD TO PAIR MANAGER ======================================================================
+
+ for (i = 0; i < nArray; i++) {
+ for (j = 0; j < 4; j++) {
+ pairMgr->AddPair(noPID[i][j]);
+ }
+ }
+ return pairMgr;
+}
+
+AliRsnPairManager* CreatePairsPID
+(
+ const char *pairMgrName, // name for the pair manager
+ Int_t resonancePDG, // PDG code of resonance (for true pairs)
+ AliPID::EParticleType type1, // PID of one member of decay (+)
+ AliPID::EParticleType type2 // PID of other member of decay (-)
+)
+{
+//
+// Creates an AliRsnPairMgr for a specified resonance, which contains:
+// - signal (inv. mass)
+// - event mixing (inv. mass)
+// - like-sign (inv. mass)
+// - true pairs (inv. mass, resolution)
+//
+// For all pairs, a binning in Pt and Eta is provided, and a cut in multiplicity
+// which defines a multiplicity bin where the analysis is computed.
+//
+// Arguments define how the pair manager must be built, and are explained above
+//
+
+ AliRsnPairManager *pairMgr = new AliRsnPairManager(pairMgrName);
+
+ // === PAIR DEFINITIONS =========================================================================
+
+ // if particle #1 and #2 are different, two histograms must be built
+ // for each scheme (signal, true, mixed, like-sign) exchanging both particles and signs
+ Int_t i, j, nArray = 1;
+ if (type1 != type2) nArray = 2;
+
+ AliRsnPairDef *defUnlike[2] = {0, 0};
+ AliRsnPairDef *defLikePP[2] = {0, 0};
+ AliRsnPairDef *defLikeMM[2] = {0, 0};
+
+ defUnlike[0] = new AliRsnPairDef(type1, '+', type2, '-', resonancePDG);
+ defLikePP[0] = new AliRsnPairDef(type1, '+', type2, '+', resonancePDG);
+ defLikeMM[0] = new AliRsnPairDef(type1, '-', type2, '-', resonancePDG);
+
+ defUnlike[1] = new AliRsnPairDef(type2, '+', type1, '-', resonancePDG);
+ defLikePP[1] = new AliRsnPairDef(type2, '+', type1, '+', resonancePDG);
+ defLikeMM[1] = new AliRsnPairDef(type2, '-', type1, '-', resonancePDG);
+
+ // === PAIR ANALYSIS ENGINES ====================================================================
+
+ // define null (dummy) objects and initialize only the ones which are needed,
+ // depending again on particle types;
+ // array is organized as follows:
+ // [0] - true pairs
+ // [1] - signal
+ // [2] - like PP
+ // [3] - like MM
+ AliRsnPair *perfectPID[2][4] = {0,0,0,0,0,0,0,0};
+ AliRsnPair *realisticPID[2][4] = {0,0,0,0,0,0,0,0};
+
+ for (i = 0; i < nArray; i++) {
perfectPID[i][0] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
perfectPID[i][1] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
- perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPIDMix, defUnlike[i]);
- perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
- perfectPID[i][4] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
+ perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
+ perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
+
+ realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
+ realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
+ realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
+ realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
}
// === CUTS =====================================================================================
- /*
// cuts for tracks:
- // - probability to be a kaon (only for kaons)
- AliRsnCutStd *cutAssignedKaon = new AliRsnCut("cutAssignedKaon", "", AliRsnCut::kAssignedPID, AliAODTrack::kKaon);
- AliRsnCutStd *cutProbKaon = new AliRsnCut("cutProbKaon", "", AliRsnCut::kPIDProbForSpecies, (Int_t)AliAODTrack::kKaon);
- cutProbKaon->SetCutValues(AliRsnCut::kPIDProbForSpecies, 0.15, 1.0);
- */
- AliRsnCutSet *cutSetTrack = new AliRsnCutSet("tracks");
- //cutSetTrack->AddCut(cutAssignedKaon);
- //cutSetTrack->AddCut(cutProbKaon);
- //cutSetTrack->SetCutScheme("(!cutAssignedKaon)|(cutAssignedKaon&cutProbKaon)");
+ // -- nothing
// cuts on pairs:
- // - true daughters of the defined resonance (only for true pairs histogram)
- AliRsnCutStd *cutPairTrue = new AliRsnCutStd("cutTrue", "", AliRsnCut::kTruePair, resonancePDG);
+ // -- true daughters of a phi resonance (only for true pairs histogram)cutSetPairTrue->AddCut(cutTrue);
+ AliRsnCutStd *cutTruePair = new AliRsnCutStd("cutTrue", AliRsnCutStd::kTruePair, resonancePDG);
+
+ // cut set definition for true pairs
AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
- cutSetPairTrue->AddCut(cutPairTrue);
+ cutSetPairTrue->AddCut(cutTruePair);
cutSetPairTrue->SetCutScheme("cutTrue");
- // cuts on events:
- // - multiplicity bin
- AliRsnCutStd *cutEventMult = new AliRsnCutStd("cutMult", "", AliRsnCut::kMultiplicity, multMin, multMax);
- AliRsnCutSet *cutSetEvent = new AliRsnCutSet("multiplicity");
- cutSetEvent->AddCut(cutEventMult);
- cutSetEvent->SetCutScheme("cutMult");
+ // cut manager for all pairs
+ AliRsnCutMgr *cutMgrAll = new AliRsnCutMgr("std", "All");
- // define cut manager for NOT true pairs
- AliRsnCutMgr *cutMgr = new AliRsnCutMgr("default", "All pairs");
- cutMgr->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
-
- // define cut manager for true pairs
- AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True pairs");
- cutMgrTrue->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
+ // cut manager for all pairs
+ AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True");
cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
- // define cut manager for NOPID with kaon prob cut
- // define cut manager for NOT true pairs
- AliRsnCutMgr *cutMgrProb = new AliRsnCutMgr("probK", "All pairs with kaon probability cut");
- cutMgrProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
- cutMgrProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
-
- // define cut manager for true pairs
- AliRsnCutMgr *cutMgrTrueProb = new AliRsnCutMgr("true+probK", "True pairs with kaon probability cut");
- cutMgrTrueProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
- cutMgrTrueProb->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
- cutMgrTrueProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
-
- // add cuts to pair analysis
for (i = 0; i < nArray; i++) {
- noPIDnoCut[i][0]->SetCutMgr(cutMgrTrue);
- noPIDwithCut[i][0]->SetCutMgr(cutMgrTrueProb);
- realisticPID[i][0]->SetCutMgr(cutMgrTrue);
perfectPID[i][0]->SetCutMgr(cutMgrTrue);
- for (j = 1; j < 5; j++) {
- noPIDnoCut[i][j]->SetCutMgr(cutMgr);
- noPIDwithCut[i][j]->SetCutMgr(cutMgrProb);
- realisticPID[i][j]->SetCutMgr(cutMgr);
- perfectPID[i][j]->SetCutMgr(cutMgr);
+ realisticPID[i][0]->SetCutMgr(cutMgrTrue);
+ for (j = 1; j < 4; j++) {
+ perfectPID[i][j]->SetCutMgr(cutMgrAll);
+ realisticPID[i][j]->SetCutMgr(cutMgrAll);
}
}
// === FUNCTIONS ================================================================================
- // define histogram templates
- AliRsnFunctionAxis *axisIM = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass, 1000, 0.0, 2.0);
- AliRsnFunctionAxis *axisPt = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt, 10, 0.0, 10.0);
- AliRsnFunctionAxis *axisEta = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta, 20, -1.0, 1.0);
- AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult, 8, 0.0, 200.0);
+ TObjArray list = DefineFunctions();
+ AliRsnFunction *fcn0 = (AliRsnFunction*)list[0];
+ AliRsnFunction *fcn1 = (AliRsnFunction*)list[1];
+ AliRsnFunction *fcn0 = (AliRsnFunction*)list[0];
- // define functions axes
- AliRsnFunction *fcnIM = new AliRsnFunction;
- fcnIM->AddAxis(axisIM);
- fcnIM->AddAxis(axisPt);
- fcnIM->AddAxis(axisEta);
- fcnIM->AddAxis(axisMult);
+ for (i = 0; i < nArray; i++) {
+ for (j = 0; j < 4; j++) {
+ noPID[i][j]->AddFunction(fcn0);
+ noPID[i][j]->AddFunction(fcn1);
+ if (j < 2) noPID[i][j]->AddFunction(fcn2);
+ }
+ }
for (i = 0; i < nArray; i++) {
- for (j = 0; j < 5; j++) {
- noPIDnoCut[i][j]->AddFunction(fcnIM);
- noPIDwithCut[i][j]->AddFunction(fcnIM);
- realisticPID[i][j]->AddFunction(fcnIM);
- perfectPID[i][j]->AddFunction(fcnIM);
+ for (j = 0; j < 4; j++) {
+ perfectPID[i][j]->AddFunction(fcn0);
+ realisticPID[i][j]->AddFunction(fcn0);
+ perfectPID[i][j]->AddFunction(fcn1);
+ realisticPID[i][j]->AddFunction(fcn1);
+ if (j < 2) {
+ perfectPID[i][j]->AddFunction(fcn2);
+ realisticPID[i][j]->AddFunction(fcn2);
+ }
}
}
// === ADD TO PAIR MANAGER ======================================================================
for (i = 0; i < nArray; i++) {
- for (j = 0; j < 5; j++) {
- pairMgr->AddPair(noPIDnoCut[i][j]);
- pairMgr->AddPair(noPIDwithCut[i][j]);
- pairMgr->AddPair(realisticPID[i][j]);
+ for (j = 0; j < 4; j++) {
pairMgr->AddPair(perfectPID[i][j]);
+ pairMgr->AddPair(realisticPID[i][j]);
}
}
return pairMgr;
}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff