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