| 474a07ae |
1 | // |
| 2 | // *** Configuration script for phi->KK analysis with 2010 runs *** |
| 3 | // |
| 4 | // A configuration script for RSN package needs to define the followings: |
| 5 | // |
| 6 | // (1) decay tree of each resonance to be studied, which is needed to select |
| 7 | // true pairs and to assign the right mass to all candidate daughters |
| 8 | // (2) cuts at all levels: single daughters, tracks, events |
| 9 | // (3) output objects: histograms or trees |
| 10 | // |
| 11 | Bool_t ConfigD0 |
| 12 | ( |
| 13 | AliRsnMiniAnalysisTask *task, |
| 14 | Bool_t isPP, |
| 15 | Bool_t isMC, |
| 16 | Float_t nsigmaTPCPi = 3.0, |
| 17 | Float_t nsigmaTPCKa = 3.0, |
| 18 | Float_t nsigmaTOFPi = 2.0, |
| 19 | Float_t nsigmaTOFKa = 2.0, |
| 20 | Int_t aodFilterBit = 5, |
| 21 | Float_t trackDCAcutMax = 7.0, |
| 22 | Float_t trackDCAcutMin = 0.0, |
| 23 | Int_t NTPCcluster = 70, |
| 1cf860e3 |
24 | Double_t minpt = 0.15, |
| 25 | Short_t maxSisters = 2, |
| 26 | Bool_t checkP = kTRUE, |
| 27 | Bool_t minDCAcutFixed = kFALSE, |
| 28 | Bool_t maxDCAcutFixed = kFALSE, |
| 474a07ae |
29 | const char *suffix, |
| 1cf860e3 |
30 | AliRsnCutSet *cutsPairY, |
| 31 | AliRsnCutSet *cutsPair |
| 474a07ae |
32 | ) |
| 33 | { |
| 34 | // manage suffix |
| 35 | if (strlen(suffix) > 0) suffix = Form("_%s", suffix); |
| 36 | |
| 37 | TString s = ""; s+=trackDCAcutMax; s+="*(0.0015+0.0050/pt^1.01)"; |
| 38 | |
| 39 | const char *formula = s; |
| 40 | |
| 41 | TString s2 = ""; s2+=trackDCAcutMin; s2+="*(0.0015+0.0050/pt^1.01)"; |
| 42 | |
| 1cf860e3 |
43 | const char *formulaMin = s2; |
| 474a07ae |
44 | |
| 45 | |
| 46 | // |
| 47 | // -- Define track cuts ------------------------------------------------------------------------- |
| 48 | // |
| 49 | |
| 50 | // integrated pion cut |
| 51 | AliRsnCutDaughterD0 *cutPi = new AliRsnCutDaughterD0("cutPionForD0", AliPID::kPion); |
| 52 | cutPi->SetTPCPionPIDCut(nsigmaTPCPi); |
| 53 | cutPi->SetTOFPionPIDCut(nsigmaTOFPi); |
| 54 | AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality(); |
| 55 | cutQuality->SetCheckOnlyFilterBit(kFALSE); |
| 1cf860e3 |
56 | cutQuality->SetAODTestFilterBit(aodFilterBit); |
| 57 | if(maxDCAcutFixed)cutQuality->SetDCARmax(trackDCAcutMax); |
| 58 | else cutQuality->SetDCARPtFormula(formula); |
| 59 | if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin); |
| 60 | else cutQuality->SetDCARPtFormulaMin(formulaMin); |
| 474a07ae |
61 | cutQuality->SetTPCminNClusters(NTPCcluster); |
| 62 | cutQuality->SetPtRange(minpt,1E20); |
| 63 | cutQuality->SetEtaRange(-0.8, 0.8); |
| 64 | cutQuality->SetDCAZmax(2.0); |
| 65 | cutQuality->SetSPDminNClusters(1); |
| 66 | cutQuality->SetITSminNClusters(0); |
| 67 | cutQuality->SetITSmaxChi2(1E+20); |
| 68 | cutQuality->SetTPCmaxChi2(4.0); |
| 69 | cutQuality->SetRejectKinkDaughters(); |
| 70 | cutQuality->Print(); |
| 71 | |
| 72 | |
| 73 | |
| 74 | // cut set |
| 75 | AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionD0", AliRsnTarget::kDaughter); |
| 76 | cutSetPi->AddCut(cutPi); |
| 77 | cutSetPi->SetCutScheme(cutPi->GetName()); |
| 78 | // add to task |
| 79 | Int_t iCutPi = task->AddTrackCuts(cutSetPi); |
| 80 | |
| 81 | |
| 82 | |
| 83 | // integrated kaon cut |
| 84 | AliRsnCutDaughterD0 *cutK = new AliRsnCutDaughterD0("cutKaonForD0", AliPID::kKaon); |
| 85 | cutK->SetTPCKaonPIDCut(nsigmaTPCKa); |
| 86 | cutK->SetTOFKaonPIDCut(nsigmaTOFKa); |
| 87 | AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutK->CutQuality(); |
| 88 | cutQuality->SetCheckOnlyFilterBit(kFALSE); |
| 1cf860e3 |
89 | cutQuality->SetAODTestFilterBit(aodFilterBit); |
| 90 | if(maxDCAcutFixed)cutQuality->SetDCARmax(trackDCAcutMax); |
| 91 | else cutQuality->SetDCARPtFormula(formula); |
| 92 | if(minDCAcutFixed) cutQuality->SetDCARmin(trackDCAcutMin); |
| 93 | else cutQuality->SetDCARPtFormulaMin(formulaMin); |
| 474a07ae |
94 | cutQuality->SetTPCminNClusters(NTPCcluster); |
| 95 | cutQuality->SetPtRange(minpt,1E20); |
| 96 | cutQuality->SetEtaRange(-0.8, 0.8); |
| 97 | cutQuality->SetDCAZmax(2.0); |
| 98 | cutQuality->SetSPDminNClusters(1); |
| 99 | cutQuality->SetITSminNClusters(0); |
| 100 | cutQuality->SetITSmaxChi2(1E+20); |
| 101 | cutQuality->SetTPCmaxChi2(4.0); |
| 102 | cutQuality->SetRejectKinkDaughters(); |
| 103 | cutQuality->Print(); |
| 104 | |
| 105 | |
| 106 | |
| 107 | // cut set |
| 108 | AliRsnCutSet *cutSetK = new AliRsnCutSet("setKaonD0", AliRsnTarget::kDaughter); |
| 109 | cutSetK->AddCut(cutK); |
| 110 | cutSetK->SetCutScheme(cutK->GetName()); |
| 111 | // add to task |
| 112 | Int_t iCutK = task->AddTrackCuts(cutSetK); |
| 113 | |
| 114 | |
| 115 | // -- Values ------------------------------------------------------------------------------------ |
| 116 | /* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); |
| 117 | /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE); |
| 118 | /* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE); |
| 119 | /* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); |
| 120 | /* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta, kFALSE); |
| 121 | /* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY, kFALSE); |
| 122 | /* dca product */ Int_t dcapID = task->CreateValue(AliRsnMiniValue::kDCAproduct, kFALSE); |
| 123 | /* first daughter pt */ Int_t daug1ptID = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE); |
| 124 | /* second daughter pt */ Int_t daug2ptID = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE); |
| 125 | /* first daughter dca */ Int_t daug1dcaID = task->CreateValue(AliRsnMiniValue::kFirstDaughterDCA, kFALSE); |
| 126 | /* second daughter dca*/ Int_t daug2dcaID = task->CreateValue(AliRsnMiniValue::kSecondDaughterDCA, kFALSE); |
| 1cf860e3 |
127 | /* number of Sisters */ Int_t nsistID = task->CreateValue(AliRsnMiniValue::kNSisters, kFALSE); |
| 474a07ae |
128 | |
| 129 | // |
| 130 | // -- Create all needed outputs ----------------------------------------------------------------- |
| 131 | // |
| 132 | |
| 133 | // use an array for more compact writing, which are different on mixing and charges |
| 134 | // [0] = unlike |
| 135 | // [1] = mixing |
| 136 | // [2] = like ++ |
| 137 | // [3] = like -- |
| 35b36c39 |
138 | Bool_t use [8] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 }; |
| 139 | Bool_t useIM [8] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 }; |
| 140 | TString name [8] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "RotateK1", "RotateK2", "LikePP" , "LikeMM" }; |
| 141 | TString comp [8] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "ROTATE1" , "ROTATE1" , "PAIR" , "PAIR" }; |
| 142 | TString output [8] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" }; |
| 143 | Char_t charge1 [8] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' }; |
| 144 | Char_t charge2 [8] = {'-' , '+' , '-' , '+' , '-' , '+' , '+' , '-' }; |
| 145 | Int_t cutID1 [8] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; |
| 146 | Int_t cutID2 [8] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi }; |
| 147 | Int_t ipdg [8] = { 421 , -421 , 421 , -421 , 421 , -421 , 421 , -421 }; |
| 148 | Double_t mass [8] = { 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 }; |
| 149 | |
| 150 | for (Int_t i = 0; i < 8; i++) { |
| 474a07ae |
151 | if (!use[i]) continue; |
| 152 | |
| 153 | // create output |
| 154 | AliRsnMiniOutput *out = task->CreateOutput(Form("D0_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); |
| 155 | // selection settings |
| 156 | out->SetCutID(0, cutID1[i]); |
| 157 | out->SetCutID(1, cutID2[i]); |
| 158 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 159 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 160 | out->SetCharge(0, charge1[i]); |
| 161 | out->SetCharge(1, charge2[i]); |
| 162 | out->SetMotherPDG(ipdg[i]); |
| 163 | out->SetMotherMass(mass[i]); |
| 164 | // pair cuts |
| 1cf860e3 |
165 | out->SetPairCuts(cutsPair); |
| 474a07ae |
166 | |
| 167 | // axis X: invmass (or resolution) |
| 1cf860e3 |
168 | //if (useIM[i]) |
| 474a07ae |
169 | out->AddAxis(imID, 800, 1.4, 2.2); |
| 1cf860e3 |
170 | //else |
| 171 | // out->AddAxis(resID, 200, -0.02, 0.02); |
| 474a07ae |
172 | // axis Y: transverse momentum |
| 35b36c39 |
173 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 474a07ae |
174 | |
| 175 | // axiz Z: rapidity |
| 8b48b94e |
176 | //out->AddAxis(yID, 100, -1, 1); |
| 474a07ae |
177 | |
| 1cf860e3 |
178 | // more axis: daughter's dca product and more |
| 179 | //out->AddAxis(dcapID, 100, -0.001, 0.001); |
| 8b48b94e |
180 | //out->AddAxis(daug1ptID, 150, 0.0, 15.0); |
| 8b48b94e |
181 | //out->AddAxis(daug2ptID, 150, 0.0, 15.0); |
| 8b48b94e |
182 | //out->AddAxis(daug1dcaID, 200, -1.0, 1.0); |
| 1cf860e3 |
183 | //out->AddAxis(daug2dcaID, 200, -1.0, 1.0); |
| 474a07ae |
184 | |
| 185 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 186 | } |
| 187 | |
| 188 | |
| 474a07ae |
189 | AddMonitorOutput_PionEta(cutSetPi->GetMonitorOutput()); |
| 190 | AddMonitorOutput_PionY(cutSetPi->GetMonitorOutput()); |
| 191 | AddMonitorOutput_PionMinPt(cutSetPi->GetMonitorOutput()); |
| 192 | AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput()); |
| 193 | AddMonitorOutput_PionTPC_PIDCut(cutSetPi->GetMonitorOutput()); |
| 194 | AddMonitorOutput_PionTOF_PIDCut(cutSetPi->GetMonitorOutput()); |
| 195 | AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput()); |
| 196 | |
| 197 | AddMonitorOutput_KaonEta(cutSetK->GetMonitorOutput()); |
| 198 | AddMonitorOutput_KaonY(cutSetK->GetMonitorOutput()); |
| 199 | AddMonitorOutput_KaonMinPt(cutSetK->GetMonitorOutput()); |
| 200 | AddMonitorOutput_KaonDCA(cutSetK->GetMonitorOutput()); |
| 201 | AddMonitorOutput_KaonTPC_PIDCut(cutSetK->GetMonitorOutput()); |
| 202 | AddMonitorOutput_KaonTOF_PIDCut(cutSetK->GetMonitorOutput()); |
| 203 | AddMonitorOutput_KaonNTPC(cutSetK->GetMonitorOutput()); |
| 204 | |
| 1cf860e3 |
205 | if (isMC) { |
| 206 | |
| 207 | // TRUE RECONSTRUCTED PAIRS |
| 208 | |
| 209 | TString mode = "SPARSE"; |
| 210 | |
| 211 | // create output |
| 212 | AliRsnMiniOutput *out = task->CreateOutput("D0_True1", mode.Data(), "TRUE"); |
| 213 | // selection settings |
| 214 | out->SetCutID(0, iCutK); |
| 215 | out->SetCutID(1, iCutPi); |
| 216 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 217 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 218 | out->SetCharge(0, '-'); |
| 219 | out->SetCharge(1, '+'); |
| 220 | out->SetMotherPDG(421); |
| 221 | out->SetMotherMass(1.86486); |
| 222 | // pair cuts |
| 223 | out->SetPairCuts(cutsPair); |
| 224 | out->SetMaxNSisters(maxSisters); |
| 225 | out->SetCheckMomentumConservation(checkP); |
| 226 | // binnings |
| 35b36c39 |
227 | out->AddAxis(imID, 800, 1.4, 2.2); |
| 228 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 1cf860e3 |
229 | //out->AddAxis(yID, 100, -1, 1); |
| 230 | //out->AddAxis(dcapID, 100, -0.001, 0.001); |
| 231 | //out->AddAxis(nsistID, 10, 0, 5); |
| 474a07ae |
232 | |
| 1cf860e3 |
233 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 234 | |
| 235 | // create output |
| 236 | AliRsnMiniOutput *out = task->CreateOutput("D0_True2", mode.Data(), "TRUE"); |
| 237 | // selection settings |
| 238 | out->SetCharge(0, '+'); |
| 239 | out->SetCharge(1, '-'); |
| 240 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 241 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 242 | out->SetCharge(0, '+'); |
| 243 | out->SetCharge(1, '-'); |
| 244 | out->SetMotherPDG(-421); |
| 245 | out->SetMotherMass(1.86486); |
| 246 | // pair cuts |
| 247 | out->SetPairCuts(cutsPair); |
| 248 | out->SetMaxNSisters(maxSisters); |
| 249 | out->SetCheckMomentumConservation(checkP); |
| 250 | // binnings |
| 35b36c39 |
251 | out->AddAxis(imID, 800, 1.4, 2.2); |
| 252 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 1cf860e3 |
253 | //out->AddAxis(yID, 100, -1, 1); |
| 254 | //out->AddAxis(dcapID, 100, -0.001, 0.001); |
| 255 | //out->AddAxis(nsistID, 10, 0, 5); |
| 256 | |
| 257 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 474a07ae |
258 | |
| 1cf860e3 |
259 | |
| 260 | // INVARIANT RESOLUTION |
| 474a07ae |
261 | |
| 262 | TString mode = "SPARSE"; |
| 263 | |
| 264 | // create output |
| 1cf860e3 |
265 | AliRsnMiniOutput *out = task->CreateOutput("D0_Res1", mode.Data(), "TRUE"); |
| 266 | // selection settings |
| 267 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 268 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 269 | out->SetCharge(0, '-'); |
| 270 | out->SetCharge(1, '+'); |
| 271 | out->SetMotherPDG(421); |
| 272 | out->SetMotherMass(1.86486); |
| 273 | // pair cuts |
| 274 | out->SetPairCuts(cutsPair); |
| 275 | out->SetMaxNSisters(maxSisters); |
| 276 | out->SetCheckMomentumConservation(checkP); |
| 277 | // binnings |
| 35b36c39 |
278 | out->AddAxis(resID, 200, -0.02, 0.02); |
| 279 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 1cf860e3 |
280 | //out->AddAxis(yID, 100, -1, 1); |
| 281 | //out->AddAxis(dcapID, 100, -0.001, 0.001); |
| 282 | //out->AddAxis(nsistID, 10, 0, 5); |
| 283 | |
| 284 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 285 | |
| 286 | // create output |
| 287 | AliRsnMiniOutput *out = task->CreateOutput("D0_Res2", mode.Data(), "TRUE"); |
| 288 | // selection settings |
| 289 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 290 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 291 | out->SetCharge(0, '+'); |
| 292 | out->SetCharge(1, '-'); |
| 293 | out->SetMotherPDG(-421); |
| 294 | out->SetMotherMass(1.86486); |
| 295 | // pair cuts |
| 296 | out->SetPairCuts(cutsPair); |
| 297 | out->SetMaxNSisters(maxSisters); |
| 298 | out->SetCheckMomentumConservation(checkP); |
| 299 | // binnings |
| 35b36c39 |
300 | out->AddAxis(resID, 200, -0.02, 0.02); |
| 301 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 1cf860e3 |
302 | //out->AddAxis(yID, 100, -1, 1); |
| 303 | //out->AddAxis(dcapID, 100, -0.001, 0.001); |
| 304 | //out->AddAxis(nsistID, 10, 0, 5); |
| 305 | |
| 306 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 307 | |
| 308 | |
| 309 | // GENERATED MOTHERS |
| 310 | |
| 311 | TString mode = "SPARSE"; |
| 312 | |
| 313 | // create output |
| 314 | AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC1", mode.Data(), "MOTHER"); |
| 474a07ae |
315 | // selection settings |
| 316 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 317 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 318 | out->SetMotherPDG(421); |
| 319 | out->SetMotherMass(1.86486); |
| 320 | // pair cuts |
| 321 | out->SetPairCuts(cutsPairY); |
| 322 | // binnings |
| 35b36c39 |
323 | out->AddAxis(imID, 800, 1.4, 2.2); |
| 324 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 8b48b94e |
325 | //out->AddAxis(yID, 100, -1, 1); |
| 474a07ae |
326 | |
| 327 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 328 | |
| 329 | // create output |
| 1cf860e3 |
330 | AliRsnMiniOutput *out = task->CreateOutput("D0_TrueMC2", mode.Data(), "MOTHER"); |
| 474a07ae |
331 | // selection settings |
| 332 | out->SetDaughter(0, AliRsnDaughter::kKaon); |
| 333 | out->SetDaughter(1, AliRsnDaughter::kPion); |
| 334 | out->SetMotherPDG(-421); |
| 335 | out->SetMotherMass(1.86486); |
| 336 | // pair cuts |
| 337 | out->SetPairCuts(cutsPairY); |
| 338 | // binnings |
| 35b36c39 |
339 | out->AddAxis(imID, 800, 1.4, 2.2); |
| 340 | out->AddAxis(ptID, 150, 0.0, 15.0); |
| 8b48b94e |
341 | //out->AddAxis(yID, 100, -1, 1); |
| 474a07ae |
342 | |
| 343 | if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); |
| 344 | |
| 345 | |
| 346 | } |
| 347 | |
| 474a07ae |
348 | |
| 1cf860e3 |
349 | return kTRUE; |
| 474a07ae |
350 | } |
| 351 | |
| 474a07ae |
352 | |
| 353 | void AddMonitorOutput_PionEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *peta=0) |
| 354 | { |
| 355 | |
| 356 | // PionEta |
| 357 | AliRsnValueDaughter *axisPionEta = new AliRsnValueDaughter("pion_eta", AliRsnValueDaughter::kEta); |
| 358 | axisPionEta->SetBins(-1.0,1.0,0.001); |
| 359 | |
| 360 | // output: 2D histogram |
| 361 | AliRsnListOutput *outMonitorPionEta = new AliRsnListOutput("Pion_Eta", AliRsnListOutput::kHistoDefault); |
| 362 | outMonitorPionEta->AddValue(axisPionEta); |
| 363 | |
| 364 | // add outputs to loop |
| 365 | if (mon) mon->Add(outMonitorPionEta); |
| 366 | if (peta) peta->AddOutput(outMonitorPionEta); |
| 367 | |
| 368 | } |
| 369 | |
| 370 | void AddMonitorOutput_PionY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *py=0) |
| 371 | { |
| 372 | |
| 373 | // PionY |
| 374 | AliRsnValueDaughter *axisPionY = new AliRsnValueDaughter("pion_y", AliRsnValueDaughter::kY); |
| 375 | axisPionY->SetBins(-1.0,1.0,0.001); |
| 376 | |
| 377 | // output: 2D histogram |
| 378 | AliRsnListOutput *outMonitorPionY = new AliRsnListOutput("Pion_Y", AliRsnListOutput::kHistoDefault); |
| 379 | outMonitorPionY->AddValue(axisPionY); |
| 380 | |
| 381 | // add outputs to loop |
| 382 | if (mon) mon->Add(outMonitorPionY); |
| 383 | if (py) py->AddOutput(outMonitorPionY); |
| 384 | |
| 385 | } |
| 386 | |
| 387 | void AddMonitorOutput_PionMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pmpt=0) |
| 388 | { |
| 389 | |
| 390 | // PionMinPt |
| 391 | AliRsnValueDaughter *axisPionMinPt = new AliRsnValueDaughter("pion_minpt", AliRsnValueDaughter::kPt); |
| 392 | axisPionMinPt->SetBins(0.0,1,0.001); |
| 393 | |
| 394 | // output: 2D histogram |
| 395 | AliRsnListOutput *outMonitorPionMinPt = new AliRsnListOutput("Pion_MinPt", AliRsnListOutput::kHistoDefault); |
| 396 | outMonitorPionMinPt->AddValue(axisPionMinPt); |
| 397 | |
| 398 | // add outputs to loop |
| 399 | if (mon) mon->Add(outMonitorPionMinPt); |
| 400 | if (pmpt) pmpt->AddOutput(outMonitorPionMinPt); |
| 401 | |
| 402 | } |
| 403 | |
| 404 | void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0) |
| 405 | { |
| 406 | |
| 407 | // PionDCA |
| 408 | AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY); |
| 409 | axisPionDCA->SetBins(0.0,1,0.001); |
| 410 | |
| 411 | // output: 2D histogram |
| 412 | AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault); |
| 413 | outMonitorPionDCA->AddValue(axisPionDCA); |
| 414 | |
| 415 | // add outputs to loop |
| 416 | if (mon) mon->Add(outMonitorPionDCA); |
| 417 | if (pdca) pdca->AddOutput(outMonitorPionDCA); |
| 418 | |
| 419 | } |
| 420 | |
| 421 | void AddMonitorOutput_PionTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTPCPID=0) |
| 422 | { |
| 423 | |
| 424 | // Pion PID Cut |
| 425 | AliRsnValueDaughter *axisPionTPCPIDCut = new AliRsnValueDaughter("pionTPCPID", AliRsnValueDaughter::kTPCnsigmaPi); |
| 426 | axisPionTPCPIDCut->SetBins(0.0,5,0.01); |
| 427 | |
| 428 | // output: 2D histogram |
| 429 | AliRsnListOutput *outMonitorPionTPCPIDCut = new AliRsnListOutput("Pion_TPC_PID_Cut", AliRsnListOutput::kHistoDefault); |
| 430 | outMonitorPionTPCPIDCut->AddValue(axisPionTPCPIDCut); |
| 431 | |
| 432 | // add outputs to loop |
| 433 | if (mon) mon->Add(outMonitorPionTPCPIDCut); |
| 434 | if (piTPCPID) piTPCPID->AddOutput(outMonitorPionPIDCut); |
| 435 | |
| 436 | } |
| 437 | |
| 438 | void AddMonitorOutput_PionTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTOFPID=0) |
| 439 | { |
| 440 | |
| 441 | // Pion PID Cut |
| 442 | AliRsnValueDaughter *axisPionTOFPIDCut = new AliRsnValueDaughter("pionTOFPID", AliRsnValueDaughter::kTOFnsigmaPi); |
| 443 | axisPionTOFPIDCut->SetBins(0.0,5,0.01); |
| 444 | |
| 445 | // output: 2D histogram |
| 446 | AliRsnListOutput *outMonitorPionTOFPIDCut = new AliRsnListOutput("Pion_TOF_PID_Cut", AliRsnListOutput::kHistoDefault); |
| 447 | outMonitorPionTOFPIDCut->AddValue(axisPionTOFPIDCut); |
| 448 | |
| 449 | // add outputs to loop |
| 450 | if (mon) mon->Add(outMonitorPionTOFPIDCut); |
| 451 | if (piTOFPID) piTOFPID->AddOutput(outMonitorPionTOFPIDCut); |
| 452 | |
| 453 | } |
| 454 | |
| 455 | void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0) |
| 456 | { |
| 457 | |
| 458 | // Pion PID Cut |
| 459 | AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters); |
| 460 | axisPionNTPC->SetBins(0.0,200,1); |
| 461 | |
| 462 | // output: 2D histogram |
| 463 | AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault); |
| 464 | outMonitorPionNTPC->AddValue(axisPionNTPC); |
| 465 | |
| 466 | // add outputs to loop |
| 467 | if (mon) mon->Add(outMonitorPionNTPC); |
| 468 | if (piNTPC) pNTPC->AddOutput(outMonitorPionNTPC); |
| 469 | |
| 470 | } |
| 471 | |
| 472 | void AddMonitorOutput_KaonEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *keta=0) |
| 473 | { |
| 474 | |
| 475 | // KaonEta |
| 476 | AliRsnValueDaughter *axisKaonEta = new AliRsnValueDaughter("kaon_eta", AliRsnValueDaughter::kEta); |
| 477 | axisKaonEta->SetBins(-1.0,1.0,0.001); |
| 478 | |
| 479 | // output: 2D histogram |
| 480 | AliRsnListOutput *outMonitorKaonEta = new AliRsnListOutput("Kaon_Eta", AliRsnListOutput::kHistoDefault); |
| 481 | outMonitorKaonEta->AddValue(axisKaonEta); |
| 482 | |
| 483 | // add outputs to loop |
| 484 | if (mon) mon->Add(outMonitorKaonEta); |
| 485 | if (keta) keta->AddOutput(outMonitorKaonEta); |
| 486 | |
| 487 | } |
| 488 | |
| 489 | void AddMonitorOutput_KaonY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ky=0) |
| 490 | { |
| 491 | |
| 492 | // KaonY |
| 493 | AliRsnValueDaughter *axisKaonY = new AliRsnValueDaughter("kaon_y", AliRsnValueDaughter::kY); |
| 494 | axisKaonY->SetBins(-1.0,1.0,0.001); |
| 495 | |
| 496 | // output: 2D histogram |
| 497 | AliRsnListOutput *outMonitorKaonY = new AliRsnListOutput("Kaon_Y", AliRsnListOutput::kHistoDefault); |
| 498 | outMonitorKaonY->AddValue(axisKaonY); |
| 499 | |
| 500 | // add outputs to loop |
| 501 | if (mon) mon->Add(outMonitorKaonY); |
| 502 | if (ky) ky->AddOutput(outMonitorKaonY); |
| 503 | |
| 504 | } |
| 505 | |
| 506 | void AddMonitorOutput_KaonMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kmpt=0) |
| 507 | { |
| 508 | |
| 509 | // KaonMinPt |
| 510 | AliRsnValueDaughter *axisKaonMinPt = new AliRsnValueDaughter("kaon_minpt", AliRsnValueDaughter::kPt); |
| 511 | axisKaonMinPt->SetBins(0.0,1,0.001); |
| 512 | |
| 513 | // output: 2D histogram |
| 514 | AliRsnListOutput *outMonitorKaonMinPt = new AliRsnListOutput("Kaon_MinPt", AliRsnListOutput::kHistoDefault); |
| 515 | outMonitorKaonMinPt->AddValue(axisKaonMinPt); |
| 516 | |
| 517 | // add outputs to loop |
| 518 | if (mon) mon->Add(outMonitorKaonMinPt); |
| 519 | if (kmpt) kmpt->AddOutput(outMonitorKaonMinPt); |
| 520 | |
| 521 | } |
| 522 | |
| 523 | void AddMonitorOutput_KaonDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kdca=0) |
| 524 | { |
| 525 | |
| 526 | // KaonDCA |
| 527 | AliRsnValueDaughter *axisKaonDCA = new AliRsnValueDaughter("kaon_dca", AliRsnValueDaughter::kDCAXY); |
| 528 | axisKaonDCA->SetBins(0.0,1,0.001); |
| 529 | |
| 530 | // output: 2D histogram |
| 531 | AliRsnListOutput *outMonitorKaonDCA = new AliRsnListOutput("Kaon_DCA", AliRsnListOutput::kHistoDefault); |
| 532 | outMonitorKaonDCA->AddValue(axisKaonDCA); |
| 533 | |
| 534 | // add outputs to loop |
| 535 | if (mon) mon->Add(outMonitorKaonDCA); |
| 536 | if (kdca) kdca->AddOutput(outMonitorKaonDCA); |
| 537 | |
| 538 | } |
| 539 | |
| 540 | void AddMonitorOutput_KaonTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTPCPID=0) |
| 541 | { |
| 542 | |
| 543 | // Kaon TPC PID Cut |
| 544 | AliRsnValueDaughter *axisKaonTPCPIDCut = new AliRsnValueDaughter("kaonTPCPID", AliRsnValueDaughter::kTPCnsigmaK); |
| 545 | axisKaonTPCPIDCut->SetBins(0.0,5,0.01); |
| 546 | |
| 547 | // output: 2D histogram |
| 548 | AliRsnListOutput *outMonitorKaonTPCPIDCut = new AliRsnListOutput("Kaon_TPC_PID_Cut", AliRsnListOutput::kHistoDefault); |
| 549 | outMonitorKaonTPCPIDCut->AddValue(axisKaonTPCPIDCut); |
| 550 | |
| 551 | // add outputs to loop |
| 552 | if (mon) mon->Add(outMonitorKaonTPCPIDCut); |
| 553 | if (kTPCPID) kTPCPID->AddOutput(outMonitorKaonTPCPIDCut); |
| 554 | |
| 555 | } |
| 556 | |
| 557 | void AddMonitorOutput_KaonTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTOFPID=0) |
| 558 | { |
| 559 | |
| 560 | // Kaon TOF PID Cut |
| 561 | AliRsnValueDaughter *axisKaonTOFPIDCut = new AliRsnValueDaughter("kaonTOFPID", AliRsnValueDaughter::kTOFnsigmaK); |
| 562 | axisKaonTOFPIDCut->SetBins(0.0,5,0.01); |
| 563 | |
| 564 | // output: 2D histogram |
| 565 | AliRsnListOutput *outMonitorKaonTOFPIDCut = new AliRsnListOutput("Kaon_TOF_PID_Cut", AliRsnListOutput::kHistoDefault); |
| 566 | outMonitorKaonTOFPIDCut->AddValue(axisKaonTOFPIDCut); |
| 567 | |
| 568 | // add outputs to loop |
| 569 | if (mon) mon->Add(outMonitorKaonTOFPIDCut); |
| 570 | if (kTOFPID) kTOFPID->AddOutput(outMonitorKaonTOFPIDCut); |
| 571 | |
| 572 | } |
| 573 | |
| 574 | void AddMonitorOutput_KaonNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kNTPC=0) |
| 575 | { |
| 576 | |
| 577 | // Kaon PID Cut |
| 578 | AliRsnValueDaughter *axisKaonNTPC = new AliRsnValueDaughter("kaonNTPC", AliRsnValueDaughter::kNTPCclusters); |
| 579 | axisKaonNTPC->SetBins(0.0,200,1); |
| 580 | |
| 581 | // output: 2D histogram |
| 582 | AliRsnListOutput *outMonitorKaonNTPC = new AliRsnListOutput("Kaon_NTPC", AliRsnListOutput::kHistoDefault); |
| 583 | outMonitorKaonNTPC->AddValue(axisKaonNTPC); |
| 584 | |
| 585 | // add outputs to loop |
| 586 | if (mon) mon->Add(outMonitorKaonNTPC); |
| 587 | if (kNTPC) kNTPC->AddOutput(outMonitorKaonNTPC); |
| 588 | |
| 589 | } |
| 590 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame