]>
Commit | Line | Data |
---|---|---|
a9f238cf | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-2011, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | //----------------------------------------------------------------------- | |
17 | // Class for HF corrections as a function of many variables and steps | |
18 | // For D* and other cascades | |
19 | // | |
20 | // Author : A.Grelli a.grelli@uu.nl UTECHT | |
21 | //----------------------------------------------------------------------- | |
22 | ||
23 | #include "AliAODRecoDecayHF2Prong.h" | |
24 | #include "AliAODMCParticle.h" | |
25 | #include "AliAODEvent.h" | |
26 | #include "TClonesArray.h" | |
27 | #include "AliCFVertexingHF.h" | |
28 | #include "AliESDtrack.h" | |
29 | #include "TDatabasePDG.h" | |
30 | #include "AliAODRecoCascadeHF.h" | |
31 | #include "AliCFVertexingHFCascade.h" | |
32 | #include "AliCFContainer.h" | |
33 | ||
34 | ClassImp(AliCFVertexingHFCascade) | |
35 | ||
36 | ||
37 | //_________________________________________ | |
38 | AliCFVertexingHFCascade::AliCFVertexingHFCascade(TClonesArray *mcArray, UShort_t originDselection): | |
39 | AliCFVertexingHF(mcArray, originDselection) | |
40 | { | |
41 | // standard constructor | |
42 | ||
43 | SetNProngs(3); | |
2bf2e62b | 44 | fPtAccCut=new Float_t[fProngs]; |
45 | fEtaAccCut=new Float_t[fProngs]; | |
46 | // element 0 in the cut arrays corresponds to the soft pion!!!!!!!! Careful when setting the values... | |
47 | fPtAccCut[0]=0.; | |
48 | fEtaAccCut[0]=0.; | |
49 | for(Int_t iP=1; iP<fProngs; iP++){ | |
50 | fPtAccCut[iP]=0.1; | |
51 | fEtaAccCut[iP]=0.9; | |
52 | } | |
53 | ||
a9f238cf | 54 | } |
55 | ||
56 | ||
57 | //_____________________________________ | |
58 | AliCFVertexingHFCascade& AliCFVertexingHFCascade::operator=(const AliCFVertexingHFCascade& c) | |
59 | { | |
60 | // operator = | |
61 | ||
62 | if (this != &c) { | |
63 | ||
64 | AliCFVertexingHF::operator=(c); | |
65 | ||
66 | } | |
67 | return *this; | |
68 | } | |
69 | ||
70 | //__________________________________________ | |
71 | Bool_t AliCFVertexingHFCascade::SetRecoCandidateParam(AliAODRecoDecayHF *recoCand) | |
72 | { | |
73 | // set the AliAODRecoDecay candidate | |
74 | ||
75 | Bool_t bSignAssoc = kFALSE; | |
76 | ||
77 | fRecoCandidate = recoCand; | |
78 | AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)recoCand; | |
79 | ||
80 | if (!fRecoCandidate) { | |
81 | AliError("fRecoCandidate not found, problem in assignement\n"); | |
82 | return bSignAssoc; | |
83 | } | |
84 | ||
85 | if ( fRecoCandidate->GetPrimaryVtx()) AliDebug(3,"fReco Candidate has a pointer to PrimVtx\n"); | |
86 | //if (recoCand->GetPrimaryVtx()) printf("Reco Cand has a pointer to PrimVtx\n"); | |
87 | ||
88 | //Int_t pdgCand = 413; | |
89 | ||
90 | Int_t pdgDgDStartoD0pi[2]={421,211}; | |
91 | Int_t pdgDgD0toKpi[2]={321,211}; | |
92 | ||
93 | Int_t nentries = fmcArray->GetEntriesFast(); | |
94 | ||
95 | AliDebug(3,Form("nentries = %d\n", nentries)); | |
96 | ||
97 | Int_t mcLabel = dstarD0pi->MatchToMC(413,421,pdgDgDStartoD0pi,pdgDgD0toKpi,fmcArray); | |
98 | ||
fbec9fa9 | 99 | if (mcLabel == -1) return bSignAssoc; |
100 | ||
1f780958 | 101 | if (fRecoCandidate->NumberOfFakeDaughters()>0){ |
102 | fFake = 0; // fake candidate | |
103 | if (fFakeSelection==1) return bSignAssoc; | |
104 | } | |
105 | if (fRecoCandidate->NumberOfFakeDaughters()==0){ | |
106 | fFake = 2; // non-fake candidate | |
107 | if (fFakeSelection==2) return bSignAssoc; | |
108 | } | |
fbec9fa9 | 109 | |
a9f238cf | 110 | SetMCLabel(mcLabel); |
111 | fmcPartCandidate = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fmcLabel)); | |
112 | ||
113 | if (!fmcPartCandidate){ | |
114 | AliDebug(3,"No part candidate"); | |
115 | return bSignAssoc; | |
116 | } | |
117 | ||
118 | bSignAssoc = kTRUE; | |
119 | return bSignAssoc; | |
120 | } | |
121 | ||
122 | //______________________________________________ | |
123 | Bool_t AliCFVertexingHFCascade::GetGeneratedValuesFromMCParticle(Double_t* vectorMC) | |
124 | { | |
125 | // | |
126 | // collecting all the necessary info (pt, y, cosThetaStar, ptPi, ptKa, cT) from MC particle | |
127 | // | |
128 | ||
129 | Bool_t bGenValues = kFALSE; | |
130 | ||
131 | ||
132 | Int_t daughter0ds = fmcPartCandidate->GetDaughter(0); | |
133 | Int_t daughter1ds = fmcPartCandidate->GetDaughter(1); | |
134 | ||
135 | //the D0 | |
136 | AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0ds)); | |
137 | AliAODMCParticle* mcPartDaughterPis = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1ds)); | |
138 | ||
a828d135 | 139 | if(!mcPartDaughterD0 || !mcPartDaughterPis) return kFALSE; |
140 | ||
a9f238cf | 141 | Double_t vtx1[3] = {0,0,0}; // primary vertex |
142 | Double_t vtx2daughter0[3] = {0,0,0}; // secondary vertex from daughter 0 | |
143 | Double_t vtx2daughter1[3] = {0,0,0}; // secondary vertex from daughter 1 | |
144 | fmcPartCandidate->XvYvZv(vtx1); // cm | |
145 | ||
146 | //D0 daughters | |
147 | Int_t daughter0 = mcPartDaughterD0->GetDaughter(0); | |
148 | Int_t daughter1 = mcPartDaughterD0->GetDaughter(1); | |
149 | ||
150 | AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); //D0 | |
151 | AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); //pis | |
152 | ||
a828d135 | 153 | if(!mcPartDaughter0 || !mcPartDaughter1) return kFALSE; |
154 | ||
a9f238cf | 155 | // getting vertex from daughters |
156 | mcPartDaughter0->XvYvZv(vtx2daughter0); // cm | |
157 | mcPartDaughter1->XvYvZv(vtx2daughter1); //cm | |
158 | if (TMath::Abs(vtx2daughter0[0] - vtx2daughter1[0])>1E-5 || TMath::Abs(vtx2daughter0[1]- vtx2daughter1[1])>1E-5 || TMath::Abs(vtx2daughter0[2] - vtx2daughter1[2])>1E-5) { | |
159 | AliError("Daughters have different secondary vertex, skipping the track"); | |
160 | return bGenValues; | |
161 | } | |
162 | ||
163 | Int_t nprongs = 2; | |
164 | Short_t charge = 0; | |
165 | // always instantiate the AliAODRecoDecay with the positive daughter first, the negative second | |
166 | AliAODMCParticle* positiveDaugh = mcPartDaughter0; | |
167 | AliAODMCParticle* negativeDaugh = mcPartDaughter1; | |
168 | if (mcPartDaughter0->GetPdgCode()<0 && mcPartDaughter1->GetPdgCode()>0){ | |
169 | // inverting in case the positive daughter is the second one | |
170 | positiveDaugh = mcPartDaughter1; | |
171 | negativeDaugh = mcPartDaughter0; | |
172 | } | |
173 | // getting the momentum from the daughters | |
174 | Double_t px[2] = {positiveDaugh->Px(), negativeDaugh->Px()}; | |
175 | Double_t py[2] = {positiveDaugh->Py(), negativeDaugh->Py()}; | |
176 | Double_t pz[2] = {positiveDaugh->Pz(), negativeDaugh->Pz()}; | |
177 | ||
178 | Double_t d0[2] = {0.,0.}; | |
179 | ||
180 | AliAODRecoDecayHF* decay = new AliAODRecoDecayHF(vtx1,vtx2daughter0,nprongs,charge,px,py,pz,d0); | |
181 | ||
182 | Double_t cosThetaStar = 0.; | |
183 | Double_t cosThetaStarD0 = 0.; | |
184 | Double_t cosThetaStarD0bar = 0.; | |
185 | cosThetaStarD0 = decay->CosThetaStar(1,421,211,321); | |
186 | cosThetaStarD0bar = decay->CosThetaStar(0,421,321,211); | |
187 | if (mcPartDaughterD0->GetPdgCode() == 421){ // D0 | |
188 | AliDebug(3, Form("D0, with pdgprong0 = %d, pdgprong1 = %d",mcPartDaughter0->GetPdgCode(),mcPartDaughter1->GetPdgCode())); | |
189 | cosThetaStar = cosThetaStarD0; | |
190 | } | |
191 | else if (mcPartDaughterD0->GetPdgCode() == -421){ // D0bar{ | |
192 | AliDebug(3, Form("D0bar, with pdgprong0 = %d, pdgprong1 = %d",mcPartDaughter0->GetPdgCode(),mcPartDaughter1->GetPdgCode())); | |
193 | cosThetaStar = cosThetaStarD0bar; | |
194 | } | |
195 | else{ | |
196 | AliWarning("There are problems!! particle was expected to be either a D0 or a D0bar, check..."); | |
197 | return vectorMC; | |
198 | } | |
199 | if (cosThetaStar < -1 || cosThetaStar > 1) { | |
200 | AliWarning("Invalid value for cosine Theta star, returning"); | |
201 | return bGenValues; | |
202 | } | |
203 | ||
204 | Double_t vectorD0[2] ={0.,0.}; | |
205 | ||
206 | // evaluate the correct cascade | |
207 | if (!EvaluateIfD0toKpi(mcPartDaughterD0,vectorD0)) { | |
208 | AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!"); | |
209 | return bGenValues; | |
210 | } | |
211 | ||
212 | //ct | |
213 | Double_t cT = decay->Ct(421); | |
214 | // get the pT of the daughters | |
215 | Double_t pTD0 = 0.; | |
216 | Double_t pTpi = 0.; | |
217 | ||
218 | if (TMath::Abs(fmcPartCandidate->GetPdgCode()) == 413) { | |
219 | pTD0 = mcPartDaughterD0->Pt(); | |
220 | pTpi = mcPartDaughterPis->Pt(); | |
221 | } | |
222 | ||
223 | ||
224 | vectorMC[0] = fmcPartCandidate->Pt(); | |
225 | vectorMC[1] = fmcPartCandidate->Y() ; | |
226 | vectorMC[2] = cosThetaStar ; | |
227 | vectorMC[3] = vectorD0[0]; | |
228 | vectorMC[4] = vectorD0[1]; | |
229 | vectorMC[5] = cT*1.E4 ; // in micron | |
230 | vectorMC[6] = 0.; // dummy value, meaningless in MC | |
231 | vectorMC[7] = 0.; // dummy value, meaningless in MC, in micron | |
232 | vectorMC[8] = 0.; // dummy value, meaningless in MC, in micron | |
233 | vectorMC[9] = -100000.; // dummy value, meaningless in MC, in micron^2 | |
234 | vectorMC[10] = 1.01; // dummy value, meaningless in MC | |
235 | vectorMC[11] = fmcPartCandidate->Phi(); | |
236 | vectorMC[12] = fzMCVertex; // z of reconstructed of primary vertex | |
b7af2639 | 237 | vectorMC[13] = fCentValue; // reconstructed centrality |
1f780958 | 238 | vectorMC[14] = 1.; // always filling with 1 at MC level |
a9f238cf | 239 | |
240 | delete decay; | |
241 | bGenValues = kTRUE; | |
242 | return bGenValues; | |
243 | } | |
244 | //____________________________________________ | |
245 | Bool_t AliCFVertexingHFCascade::GetRecoValuesFromCandidate(Double_t *vectorReco) const | |
246 | { | |
247 | // read the variables for the container | |
248 | ||
249 | Bool_t bFillRecoValues=kFALSE; | |
250 | ||
251 | //Get the D* and the D0 from D* | |
252 | AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)fRecoCandidate; | |
253 | AliAODRecoDecayHF2Prong* d0toKpi = (AliAODRecoDecayHF2Prong*)dstarD0pi->Get2Prong(); | |
254 | ||
255 | ||
256 | if (dstarD0pi->GetPrimaryVtx())printf("dstarD0pi has primary vtx\n"); | |
257 | if (fRecoCandidate->GetPrimaryVtx())printf("fRecoCandidateDstar has primary vtx\n"); | |
258 | ||
259 | Double_t pt = dstarD0pi->Pt(); | |
260 | Double_t rapidity = dstarD0pi->YDstar(); | |
261 | Double_t invMass=0.; | |
262 | Double_t cosThetaStar = 9999.; | |
263 | Double_t pTpi = 0.; | |
264 | Double_t pTK = 0.; | |
265 | Double_t dca = d0toKpi->GetDCA(); | |
266 | Double_t d0pi = 0.; | |
267 | Double_t d0K = 0.; | |
268 | Double_t d0xd0 = d0toKpi->Prodd0d0(); | |
269 | Double_t cosPointingAngle = d0toKpi->CosPointingAngle(); | |
270 | Double_t phi = dstarD0pi->Phi(); | |
271 | ||
272 | Int_t pdgCode = fmcPartCandidate->GetPdgCode(); | |
273 | ||
274 | if (pdgCode > 0){ | |
275 | cosThetaStar = d0toKpi->CosThetaStarD0(); | |
276 | pTpi = d0toKpi->PtProng(0); | |
277 | pTK = d0toKpi->PtProng(1); | |
278 | d0pi = d0toKpi->Getd0Prong(0); | |
279 | d0K = d0toKpi->Getd0Prong(1); | |
280 | invMass=d0toKpi->InvMassD0(); | |
281 | } | |
282 | else { | |
283 | cosThetaStar = d0toKpi->CosThetaStarD0bar(); | |
284 | pTpi = d0toKpi->PtProng(1); | |
285 | pTK = d0toKpi->PtProng(0); | |
286 | d0pi = d0toKpi->Getd0Prong(1); | |
287 | d0K = d0toKpi->Getd0Prong(0); | |
288 | invMass= d0toKpi->InvMassD0bar(); | |
289 | } | |
290 | ||
291 | Double_t cT = d0toKpi->CtD0(); | |
292 | ||
293 | vectorReco[0] = pt; | |
294 | vectorReco[1] = rapidity; | |
295 | vectorReco[2] = cosThetaStar; | |
296 | vectorReco[3] = pTpi; | |
297 | vectorReco[4] = pTK; | |
298 | vectorReco[5] = cT*1.E4; // in micron | |
299 | vectorReco[6] = dca*1.E4; // in micron | |
300 | vectorReco[7] = d0pi*1.E4; // in micron | |
301 | vectorReco[8] = d0K*1.E4; // in micron | |
302 | vectorReco[9] = d0xd0*1.E8; // in micron^2 | |
303 | vectorReco[10] = cosPointingAngle; // in micron | |
304 | vectorReco[11] = phi; | |
305 | vectorReco[12] = fzPrimVertex; // z of reconstructed of primary vertex | |
b7af2639 | 306 | vectorReco[13] = fCentValue; |
1f780958 | 307 | vectorReco[14] = fFake; // whether the reconstructed candidate was a fake (fFake = 0) or not (fFake = 2) |
a9f238cf | 308 | |
309 | bFillRecoValues = kTRUE; | |
310 | ||
311 | return bFillRecoValues; | |
312 | } | |
313 | ||
314 | ||
315 | //_____________________________________________________________ | |
316 | Bool_t AliCFVertexingHFCascade::CheckMCChannelDecay() const | |
317 | { | |
318 | // check the required decay channel | |
319 | ||
320 | Bool_t checkCD = kFALSE; | |
321 | ||
322 | ||
323 | Int_t daughter0 = fmcPartCandidate->GetDaughter(0); | |
324 | Int_t daughter1 = fmcPartCandidate->GetDaughter(1); | |
325 | AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); | |
326 | AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); | |
327 | ||
328 | if (!mcPartDaughter0 || !mcPartDaughter1) { | |
329 | AliDebug (2,"Problems in the MC Daughters\n"); | |
330 | return checkCD; | |
331 | } | |
332 | ||
333 | if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==421 && | |
334 | TMath::Abs(mcPartDaughter1->GetPdgCode())==211) && | |
335 | !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211 && | |
336 | TMath::Abs(mcPartDaughter1->GetPdgCode())==421)) { | |
337 | AliDebug(2, "The D0 MC doesn't come from a Kpi decay, skipping!!"); | |
338 | return checkCD; | |
339 | } | |
340 | ||
341 | Double_t vectorD0[2] ={0.,0.}; | |
342 | ||
343 | // D* is a cascade ...evaluate the correct cascade | |
344 | if (!EvaluateIfD0toKpi(mcPartDaughter0,vectorD0)) { | |
345 | AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!"); | |
346 | return checkCD; | |
347 | } | |
348 | ||
349 | checkCD = kTRUE; | |
350 | return checkCD; | |
351 | ||
352 | } | |
353 | ||
354 | //__________________________________________ | |
355 | Bool_t AliCFVertexingHFCascade::EvaluateIfD0toKpi(AliAODMCParticle* neutralDaugh, Double_t* vectorD0)const | |
356 | { | |
357 | // | |
358 | // chack wether D0 is decaing into kpi | |
359 | // | |
360 | ||
361 | Bool_t isHadronic = kFALSE; | |
362 | ||
363 | Int_t daughterD00 = neutralDaugh->GetDaughter(0); | |
364 | Int_t daughterD01 = neutralDaugh->GetDaughter(1); | |
365 | ||
366 | AliDebug(2, Form("daughter0 = %d and daughter1 = %d",daughterD00,daughterD01)); | |
367 | if (daughterD00 == 0 || daughterD01 == 0) { | |
368 | AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!"); | |
369 | return isHadronic; | |
370 | } | |
371 | ||
372 | if (TMath::Abs(daughterD01 - daughterD00) != 1) { // should be everytime true - see PDGdatabooklet | |
373 | AliDebug(2, "The D0 MC doesn't come from a 2-prong decay, skipping!!"); | |
374 | return isHadronic; | |
375 | } | |
376 | ||
377 | AliAODMCParticle* mcPartDaughterD00 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD00)); | |
378 | AliAODMCParticle* mcPartDaughterD01 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD01)); | |
379 | if (!mcPartDaughterD00 || !mcPartDaughterD01) { | |
380 | AliWarning("D0 MC analysis: At least one Daughter Particle not found in tree, skipping"); | |
381 | return isHadronic; | |
382 | } | |
383 | ||
384 | if (!(TMath::Abs(mcPartDaughterD00->GetPdgCode())==321 && | |
385 | TMath::Abs(mcPartDaughterD01->GetPdgCode())==211) && | |
386 | !(TMath::Abs(mcPartDaughterD00->GetPdgCode())==211 && | |
387 | TMath::Abs(mcPartDaughterD01->GetPdgCode())==321)) { | |
388 | AliDebug(2, "The D0 MC doesn't come from a Kpi decay, skipping!!"); | |
389 | return isHadronic; | |
390 | } | |
391 | ||
392 | Double_t pTD0pi = 0; | |
393 | Double_t pTD0K = 0; | |
394 | ||
395 | ||
396 | if (TMath::Abs(mcPartDaughterD00->GetPdgCode()) == 211) { | |
397 | pTD0pi = mcPartDaughterD00->Pt(); | |
398 | pTD0K = mcPartDaughterD01->Pt(); | |
399 | } | |
400 | else { | |
401 | pTD0pi = mcPartDaughterD01->Pt(); | |
402 | pTD0K = mcPartDaughterD00->Pt(); | |
403 | } | |
404 | ||
405 | isHadronic = kTRUE; | |
406 | ||
407 | vectorD0[0] = pTD0pi; | |
408 | vectorD0[1] = pTD0K; | |
409 | ||
410 | return isHadronic; | |
411 | ||
412 | } | |
413 | ||
2bf2e62b | 414 | //___________________________________________________________ |
415 | ||
416 | void AliCFVertexingHFCascade::SetPtAccCut(Float_t* ptAccCut) | |
417 | { | |
418 | // | |
419 | // setting the pt cut to be used in the Acceptance steps (MC+Reco) | |
420 | // | |
421 | ||
422 | AliInfo("The 3rd element of the pt cut array will correspond to the cut applied to the soft pion - please check that it is correct"); | |
423 | if (fProngs>0){ | |
424 | for (Int_t iP=0; iP<fProngs; iP++){ | |
425 | fPtAccCut[iP]=ptAccCut[iP]; | |
426 | } | |
427 | } | |
428 | return; | |
429 | } | |
430 | ||
431 | ||
432 | ||
433 | //___________________________________________________________ | |
434 | ||
435 | void AliCFVertexingHFCascade::SetEtaAccCut(Float_t* etaAccCut) | |
436 | { | |
437 | // | |
438 | // setting the eta cut to be used in the Acceptance steps (MC+Reco) | |
439 | // | |
440 | ||
441 | AliInfo("The 3rd element of the eta cut array will correspond to the cut applied to the soft pion - please check that it is correct"); | |
442 | if (fProngs>0){ | |
443 | for (Int_t iP=0; iP<fProngs; iP++){ | |
444 | fEtaAccCut[iP]=etaAccCut[iP]; | |
445 | } | |
446 | } | |
447 | return; | |
448 | } | |
449 | //___________________________________________________________ | |
450 | ||
451 | void AliCFVertexingHFCascade::SetAccCut(Float_t* ptAccCut, Float_t* etaAccCut) | |
452 | { | |
453 | // | |
454 | // setting the pt and eta cut to be used in the Acceptance steps (MC+Reco) | |
455 | // | |
456 | ||
457 | AliInfo("The 3rd element of the pt and cut array will correspond to the cut applied to the soft pion - please check that they are correct"); | |
458 | if (fProngs>0){ | |
459 | for (Int_t iP=0; iP<fProngs; iP++){ | |
460 | fPtAccCut[iP]=ptAccCut[iP]; | |
461 | fEtaAccCut[iP]=etaAccCut[iP]; | |
462 | } | |
463 | } | |
464 | return; | |
465 | } | |
466 | ||
467 | //___________________________________________________________ | |
468 | ||
469 | void AliCFVertexingHFCascade::SetAccCut() | |
470 | { | |
471 | // | |
472 | // setting the pt and eta cut to be used in the Acceptance steps (MC+Reco) | |
473 | // | |
367e9aa3 | 474 | |
475 | AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[2])); // should be the soft pion... | |
476 | if(!mcPartDaughter) return; | |
477 | Int_t mother = mcPartDaughter->GetMother(); | |
478 | AliAODMCParticle* mcMother = dynamic_cast<AliAODMCParticle*>(fmcArray->At(mother)); | |
479 | if(!mcMother) return; | |
480 | ||
481 | if (TMath::Abs(mcPartDaughter->GetPdgCode())!= 211 || TMath::Abs(mcMother->GetPdgCode())!=413){ | |
482 | AliFatal("Apparently the soft pion is not in the third position, causing a crash!!"); | |
483 | } | |
484 | if (fProngs>0){ | |
485 | for (Int_t iP=0; iP<fProngs-1; iP++){ | |
486 | fPtAccCut[iP]=0.1; | |
487 | fEtaAccCut[iP]=0.9; | |
488 | } | |
489 | fPtAccCut[2]=0.06; // soft pion | |
490 | fEtaAccCut[2]=0.9; // soft pion | |
491 | } | |
492 | return; | |
2bf2e62b | 493 | } |
a9f238cf | 494 | |
367e9aa3 | 495 | //_____________________________________________________________ |
496 | Double_t AliCFVertexingHFCascade::GetEtaProng(Int_t iProng) const | |
497 | { | |
498 | // | |
499 | // getting eta of the prong - overload the mother class method | |
500 | // | |
a9f238cf | 501 | |
367e9aa3 | 502 | if (fRecoCandidate){ |
503 | ||
504 | AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)fRecoCandidate; | |
505 | ||
506 | Double_t etaProng =-9999; | |
507 | if(iProng==0) etaProng =dstarD0pi->Get2Prong()->EtaProng(0); | |
508 | if(iProng==1) etaProng =dstarD0pi->Get2Prong()->EtaProng(1); | |
509 | if(iProng==2) etaProng =dstarD0pi->EtaProng(1); | |
510 | ||
511 | return etaProng; | |
512 | ||
513 | } | |
514 | return 999999; | |
515 | } | |
516 | //_____________________________________________________________ | |
517 | Double_t AliCFVertexingHFCascade::GetPtProng(Int_t iProng) const | |
518 | { | |
519 | // | |
520 | // getting pt of the prong | |
521 | // | |
522 | ||
523 | if (fRecoCandidate){ | |
524 | ||
525 | AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)fRecoCandidate; | |
526 | Double_t ptProng= -9999; | |
527 | if(iProng==0) ptProng =dstarD0pi->Get2Prong()->PtProng(0); | |
528 | if(iProng==1) ptProng =dstarD0pi->Get2Prong()->PtProng(1); | |
529 | if(iProng==2) ptProng =dstarD0pi->PtProng(1); | |
530 | ||
531 | // Double_t ptProng = fRecoCandidate->PtProng(iProng); | |
532 | return ptProng; | |
533 | ||
534 | } | |
535 | return 999999; | |
536 | ||
537 | } |