Restored call to CreateDigitizer (F.Prino)
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / macros / RsnConfig.C
1 AliRsnPairManager *RsnConfig_PHI(const char *name="PHI")
2 {
3   return   CreatePairs(name, 333, AliAODTrack::kKaon, AliAODTrack::kKaon, 0, 10000);
4 }
5
6 AliRsnPairManager *RsnConfig_KSTAR(const char *name="KSTAR")
7 {
8   return CreatePairs(name, 313, AliAODTrack::kPion, AliAODTrack::kKaon, 0, 10000);
9 }
10
11
12 AliRsnPairManager* CreatePairs
13 (
14   const char       *pairMgrName,    // name for the pair manager
15   Int_t             resonancePDG,   // PDG code of resonance (for true pairs)
16   AliAODTrack::AODTrkPID_t type1,          // PID of one member of decay (+)
17   AliAODTrack::AODTrkPID_t  type2,          // PID of other member of decay (-)
18   Int_t             multMin,        // lower edge of multiplicity cut
19   Int_t             multMax         // upper edge of multiplicity cut
20 )
21 {
22 //
23 // Creates an AliRsnPairMgr for a specified resonance, which contains:
24 // - signal (inv. mass)
25 // - event mixing (inv. mass)
26 // - like-sign (inv. mass)
27 // - true pairs (inv. mass, resolution)
28 //
29 // For all pairs, a binning in Pt and Eta is provided, and a cut in multiplicity
30 // which defines a multiplicity bin where the analysis is computed.
31 //
32 // Arguments define how the pair manager must be built, and are explained above
33 //
34
35   AliRsnPairManager  *pairMgr  = new AliRsnPairManager(pairMgrName);
36   //cout << "Creating " << pairMgrName << endl;
37
38 //   return pairMgr;
39
40   // === PAIR DEFINITIONS =========================================================================
41
42   // if particle #1 and #2 are different, two histograms must be built
43   // for each scheme (signal, true, mixed, like-sign) exchanging both particles and signs
44   Int_t i, j, nArray = 1;
45   if (type1 != type2) nArray = 2;
46
47   AliRsnPairDef *defUnlike[2] = {0, 0};
48   AliRsnPairDef *defLikePP[2] = {0, 0};
49   AliRsnPairDef *defLikeMM[2] = {0, 0};
50
51   defUnlike[0] = new AliRsnPairDef(type1, '+', type2, '-', resonancePDG);
52   defLikePP[0] = new AliRsnPairDef(type1, '+', type2, '+', resonancePDG);
53   defLikeMM[0] = new AliRsnPairDef(type1, '-', type2, '-', resonancePDG);
54
55   defUnlike[1] = new AliRsnPairDef(type2, '+', type1, '-', resonancePDG);
56   defLikePP[1] = new AliRsnPairDef(type2, '+', type1, '+', resonancePDG);
57   defLikeMM[1] = new AliRsnPairDef(type2, '-', type1, '-', resonancePDG);
58
59   // === PAIR ANALYSIS ENGINES ====================================================================
60
61   // define null (dummy) objects and initialize only the ones which are needed,
62   // depending again on particle types;
63   // array is organized as follows:
64   // [0] - true pairs
65   // [1] - signal
66   // [2] - mixing
67   // [3] - like PP
68   // [4] - like MM
69   AliRsnPair *noPIDnoCut[2][5]   = {0,0,0,0,0,0,0,0,0,0};
70   AliRsnPair *noPIDwithCut[2][5] = {0,0,0,0,0,0,0,0,0,0};
71   AliRsnPair *realisticPID[2][5] = {0,0,0,0,0,0,0,0,0,0};
72   AliRsnPair *perfectPID[2][5]   = {0,0,0,0,0,0,0,0,0,0};
73
74   for (i = 0; i < nArray; i++) {
75     noPIDnoCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
76     noPIDnoCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
77     noPIDnoCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
78     noPIDnoCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
79     noPIDnoCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
80
81     noPIDwithCut[i][0] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
82     noPIDwithCut[i][1] = new AliRsnPair(AliRsnPair::kNoPID, defUnlike[i]);
83     noPIDwithCut[i][2] = new AliRsnPair(AliRsnPair::kNoPIDMix, defUnlike[i]);
84     noPIDwithCut[i][3] = new AliRsnPair(AliRsnPair::kNoPID, defLikePP[i]);
85     noPIDwithCut[i][4] = new AliRsnPair(AliRsnPair::kNoPID, defLikeMM[i]);
86
87     realisticPID[i][0] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
88     realisticPID[i][1] = new AliRsnPair(AliRsnPair::kRealisticPID, defUnlike[i]);
89     realisticPID[i][2] = new AliRsnPair(AliRsnPair::kRealisticPIDMix, defUnlike[i]);
90     realisticPID[i][3] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikePP[i]);
91     realisticPID[i][4] = new AliRsnPair(AliRsnPair::kRealisticPID, defLikeMM[i]);
92
93     perfectPID[i][0] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
94     perfectPID[i][1] = new AliRsnPair(AliRsnPair::kPerfectPID, defUnlike[i]);
95     perfectPID[i][2] = new AliRsnPair(AliRsnPair::kPerfectPIDMix, defUnlike[i]);
96     perfectPID[i][3] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikePP[i]);
97     perfectPID[i][4] = new AliRsnPair(AliRsnPair::kPerfectPID, defLikeMM[i]);
98   }
99
100   // === CUTS =====================================================================================
101
102   /*
103   // cuts for tracks:
104   // - probability to be a kaon (only for kaons)
105   AliRsnCutStd *cutAssignedKaon = new AliRsnCut("cutAssignedKaon", "", AliRsnCut::kAssignedPID, AliAODTrack::kKaon);
106   AliRsnCutStd *cutProbKaon = new AliRsnCut("cutProbKaon", "", AliRsnCut::kPIDProbForSpecies, (Int_t)AliAODTrack::kKaon);
107   cutProbKaon->SetCutValues(AliRsnCut::kPIDProbForSpecies, 0.15, 1.0);
108   */
109   AliRsnCutSet *cutSetTrack = new AliRsnCutSet("tracks");
110   //cutSetTrack->AddCut(cutAssignedKaon);
111   //cutSetTrack->AddCut(cutProbKaon);
112   //cutSetTrack->SetCutScheme("(!cutAssignedKaon)|(cutAssignedKaon&cutProbKaon)");
113
114   // cuts on pairs:
115   // - true daughters of the defined resonance (only for true pairs histogram)
116   AliRsnCutStd *cutPairTrue    = new AliRsnCutStd("cutTrue", "", AliRsnCut::kTruePair, resonancePDG);
117   AliRsnCutSet *cutSetPairTrue = new AliRsnCutSet("truePairs");
118   cutSetPairTrue->AddCut(cutPairTrue);
119   cutSetPairTrue->SetCutScheme("cutTrue");
120
121   // cuts on events:
122   // - multiplicity bin
123   AliRsnCutStd *cutEventMult = new AliRsnCutStd("cutMult", "", AliRsnCut::kMultiplicity, multMin, multMax);
124   AliRsnCutSet *cutSetEvent  = new AliRsnCutSet("multiplicity");
125   cutSetEvent->AddCut(cutEventMult);
126   cutSetEvent->SetCutScheme("cutMult");
127
128   // define cut manager for NOT true pairs
129   AliRsnCutMgr *cutMgr = new AliRsnCutMgr("default", "All pairs");
130   cutMgr->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
131
132   // define cut manager for true pairs
133   AliRsnCutMgr *cutMgrTrue = new AliRsnCutMgr("true", "True pairs");
134   cutMgrTrue->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
135   cutMgrTrue->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
136
137   // define cut manager for NOPID with kaon prob cut
138   // define cut manager for NOT true pairs
139   AliRsnCutMgr *cutMgrProb = new AliRsnCutMgr("probK", "All pairs with kaon probability cut");
140   cutMgrProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
141   cutMgrProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
142
143   // define cut manager for true pairs
144   AliRsnCutMgr *cutMgrTrueProb = new AliRsnCutMgr("true+probK", "True pairs with kaon probability cut");
145   cutMgrTrueProb->SetCutSet(AliRsnCut::kEvent, cutSetEvent);
146   cutMgrTrueProb->SetCutSet(AliRsnCut::kPair, cutSetPairTrue);
147   cutMgrTrueProb->SetCutSet(AliRsnCut::kParticle, cutSetTrack);
148
149   // add cuts to pair analysis
150   for (i = 0; i < nArray; i++) {
151     noPIDnoCut[i][0]->SetCutMgr(cutMgrTrue);
152     noPIDwithCut[i][0]->SetCutMgr(cutMgrTrueProb);
153     realisticPID[i][0]->SetCutMgr(cutMgrTrue);
154     perfectPID[i][0]->SetCutMgr(cutMgrTrue);
155     for (j = 1; j < 5; j++) {
156       noPIDnoCut[i][j]->SetCutMgr(cutMgr);
157       noPIDwithCut[i][j]->SetCutMgr(cutMgrProb);
158       realisticPID[i][j]->SetCutMgr(cutMgr);
159       perfectPID[i][j]->SetCutMgr(cutMgr);
160     }
161   }
162
163   // === FUNCTIONS ================================================================================
164
165   // define histogram templates
166   AliRsnFunctionAxis *axisIM   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairInvMass,    1000,  0.0,   2.0);
167   AliRsnFunctionAxis *axisPt   = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairPt,           10,  0.0,  10.0);
168   AliRsnFunctionAxis *axisEta  = new AliRsnFunctionAxis(AliRsnFunctionAxis::kPairEta,          20, -1.0,   1.0);
169   AliRsnFunctionAxis *axisMult = new AliRsnFunctionAxis(AliRsnFunctionAxis::kEventMult,         8,  0.0, 200.0);
170
171   // define functions axes
172   AliRsnFunction *fcnIM = new AliRsnFunction;
173   fcnIM->AddAxis(axisIM);
174   fcnIM->AddAxis(axisPt);
175   fcnIM->AddAxis(axisEta);
176   fcnIM->AddAxis(axisMult);
177
178   for (i = 0; i < nArray; i++) {
179     for (j = 0; j < 5; j++) {
180       noPIDnoCut[i][j]->AddFunction(fcnIM);
181       noPIDwithCut[i][j]->AddFunction(fcnIM);
182       realisticPID[i][j]->AddFunction(fcnIM);
183       perfectPID[i][j]->AddFunction(fcnIM);
184     }
185   }
186
187   // === ADD TO PAIR MANAGER ======================================================================
188
189   for (i = 0; i < nArray; i++) {
190     for (j = 0; j < 5; j++) {
191       pairMgr->AddPair(noPIDnoCut[i][j]);
192       pairMgr->AddPair(noPIDwithCut[i][j]);
193       pairMgr->AddPair(realisticPID[i][j]);
194       pairMgr->AddPair(perfectPID[i][j]);
195     }
196   }
197
198   return pairMgr;
199 }