]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/vertexingHF/AliCFVertexingHFLctoV0bachelor.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix for coverity defects
[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliCFVertexingHFLctoV0bachelor.cxx
CommitLineData
5cd139bc 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/* $Id$ */
17
18//-----------------------------------------------------------------------
19// Class for HF corrections as a function of many variables and steps
20// For Lc->V0+bachelor
21//
22// - Based on AliCFVertexingHFCascade -
23//
24// Contact : A.De Caro - decaro@sa.infn.it
25// Centro 'E.Fermi' - Rome (Italy)
26// INFN and University of Salerno (Italy)
27//
28//-----------------------------------------------------------------------
29
5cd139bc 30#include "TDatabasePDG.h"
a578b2da 31#include "TClonesArray.h"
5cd139bc 32#include "AliAODv0.h"
a578b2da 33#include "AliAODMCParticle.h"
34#include "AliAODRecoDecayHF.h"
35#include "AliAODRecoCascadeHF.h"
5cd139bc 36#include "AliCFTaskVertexingHF.h"
a578b2da 37#include "AliCFContainer.h"
38#include "AliCFVertexingHF.h"
39#include "AliCFVertexingHFLctoV0bachelor.h"
5cd139bc 40
41#include <Riostream.h>
42
43using std::cout;
44using std::endl;
45
46ClassImp(AliCFVertexingHFLctoV0bachelor)
47
48//_________________________________________
49AliCFVertexingHFLctoV0bachelor::AliCFVertexingHFLctoV0bachelor():
50fGenLcOption(0)
51{
52 // standard constructor
53}
54
55//_____________________________________
56AliCFVertexingHFLctoV0bachelor::AliCFVertexingHFLctoV0bachelor(TClonesArray *mcArray, UShort_t originDselection, Int_t lcDecay):
57AliCFVertexingHF(mcArray, originDselection),
58 fGenLcOption(lcDecay)
59{
60 // standard constructor
61
62 SetNProngs(3);
63 fPtAccCut=new Float_t[fProngs];
64 fEtaAccCut=new Float_t[fProngs];
65 for(Int_t iP=0; iP<fProngs; iP++){
66 fPtAccCut[iP]=0.1;
67 fEtaAccCut[iP]=0.9;
68 }
69
70}
71
72
73//_____________________________________
74AliCFVertexingHFLctoV0bachelor& AliCFVertexingHFLctoV0bachelor::operator=(const AliCFVertexingHFLctoV0bachelor& c)
75{
76 // operator =
77
78 if (this != &c) {
79 AliCFVertexingHF::operator=(c);
80 }
81
82 return *this;
83
84}
85
86//__________________________________________
87Bool_t AliCFVertexingHFLctoV0bachelor::SetRecoCandidateParam(AliAODRecoDecayHF *recoCand)
88{
89 // set the AliAODRecoDecay candidate
90
91 Bool_t bSignAssoc = kFALSE;
92
93 fRecoCandidate = recoCand;
94 if (!fRecoCandidate) {
95 AliError("fRecoCandidate not found, problem in assignement\n");
96 return bSignAssoc;
97 }
98
a578b2da 99 if (fRecoCandidate->GetPrimaryVtx()) AliDebug(4,"fReco Candidate has a pointer to PrimVtx\n");
5cd139bc 100
ff12b981 101 AliAODRecoCascadeHF* lcV0bachelor = dynamic_cast<AliAODRecoCascadeHF*>(fRecoCandidate);
102 if (!lcV0bachelor) {
103 AliDebug(2,"cascade doesn't exist, skipped!");
104 return bSignAssoc;
105 }
106
107 if (!lcV0bachelor->GetSecondaryVtx()) {
108 AliDebug(2,"No secondary vertex for cascade");
109 return bSignAssoc;
110 }
111
112 if (lcV0bachelor->GetNDaughters()!=2) {
113 AliDebug(2,Form("No 2 daughters for current cascade (nDaughters=%d)",lcV0bachelor->GetNDaughters()));
114 return bSignAssoc;
115 }
116
117 AliVTrack *cascTrk0 = dynamic_cast<AliVTrack*>(lcV0bachelor->GetDaughter(0));
118 AliVTrack *cascTrk1 = dynamic_cast<AliVTrack*>(lcV0bachelor->GetDaughter(1));
119 if (!cascTrk0 || !cascTrk1) {
120 AliDebug(2,"At least one of V0daughters doesn't exist");
121 return bSignAssoc;
122 }
123
124 AliAODv0 * v0part = dynamic_cast<AliAODv0*>(lcV0bachelor->Getv0());
125 AliAODTrack * bachPart = dynamic_cast<AliAODTrack*>(lcV0bachelor->GetBachelor());
126 if (!v0part || !bachPart) {
127 AliDebug(2,"No V0 or no bachelor for current cascade");
128 return bSignAssoc;
129 }
130
131 if (bachPart->GetID()<0) {
132 AliDebug(2,Form("Bachelor has negative ID %d",bachPart->GetID()));
133 return bSignAssoc;
134 }
135
136 if (!v0part->GetSecondaryVtx()) {
137 AliDebug(2,"No secondary vertex for V0 by cascade");
138 return bSignAssoc;
139 }
140
141 if (v0part->GetNDaughters()!=2) {
142 AliDebug(2,Form("No 2 daughters for V0 of current cascade (onTheFly=%d, nDaughters=%d)",v0part->GetOnFlyStatus(),v0part->GetNDaughters()));
143 return bSignAssoc;
144 }
145
146 AliVTrack *trk0 = dynamic_cast<AliVTrack*>(v0part->GetDaughter(0));
147 AliVTrack *trk1 = dynamic_cast<AliVTrack*>(v0part->GetDaughter(1));
148 if (!trk0 || !trk1) {
149 AliDebug(2,"At least one of V0daughters doesn't exist");
150 return bSignAssoc;
151 }
152
126b0255 153 //if (trk0->GetLabel()<0 || trk1->GetLabel()<0) {
154 //AliDebug(2,Form("At least one of V0daughters has label negative (%d %d)",trk0->GetLabel(),trk1->GetLabel()));
155 //return bSignAssoc;
156 //}
ff12b981 157
158 if (trk0->GetID()<0 || trk1->GetID()<0) {
159 AliDebug(2,Form("At least one of V0 daughters has negative ID %d %d",trk0->GetID(),trk1->GetID()));
a578b2da 160 return bSignAssoc;
161 }
5cd139bc 162
5cd139bc 163 Int_t pdgCand = 4122;
164 Int_t mcLabel = -1;
165 Int_t mcLabelK0S = -1;
166 Int_t mcLabelLambda = -1;
167
168 // Lc->K0S+p and cc
a578b2da 169 Int_t pdgDgLctoV0bachelor[2]={2212,310}; // first bachelor, second V0
5cd139bc 170 Int_t pdgDgV0toDaughters[2]={211,211};
a578b2da 171 mcLabelK0S = lcV0bachelor->MatchToMC(pdgCand,pdgDgLctoV0bachelor[1],pdgDgLctoV0bachelor,pdgDgV0toDaughters,fmcArray,kTRUE);
172
5cd139bc 173 // Lc->Lambda+pi and cc
a578b2da 174 pdgDgLctoV0bachelor[0]=211, pdgDgLctoV0bachelor[1]=3122; // first bachelor, second V0
5cd139bc 175 pdgDgV0toDaughters[0]=2212, pdgDgV0toDaughters[1]=211;
a578b2da 176 mcLabelLambda = lcV0bachelor->MatchToMC(pdgCand,pdgDgLctoV0bachelor[1],pdgDgLctoV0bachelor,pdgDgV0toDaughters,fmcArray,kTRUE);
5cd139bc 177
178 if (mcLabelK0S!=-1 && mcLabelLambda!=-1)
a578b2da 179 AliDebug(2,"Strange: current Lc->V0+bachelor candidate has two MC different labels!");
5cd139bc 180
ff12b981 181 if (fGenLcOption==kCountK0Sp) {
5cd139bc 182 if (mcLabelK0S!=-1) mcLabel=mcLabelK0S;
183 if (mcLabelLambda!=-1) {
184 mcLabel=-1;
185 fFake = 0; // fake candidate
186 if (fFakeSelection==1) return bSignAssoc;
187 }
188 }
189 else if (fGenLcOption==kCountLambdapi) {
190 if (mcLabelLambda!=-1) mcLabel=mcLabelLambda;
191 if (mcLabelK0S!=-1) {
192 mcLabel=-1;
193 fFake = 0; // fake candidate
194 if (fFakeSelection==1) return bSignAssoc;
195 }
196 }
197
a578b2da 198 if (mcLabel==-1) {
199 AliDebug(4,"No mcLabel found for current candidate");
200 return bSignAssoc;
201 }
126b0255 202 AliDebug(1,Form("Found mcLabel (%d) for current candidate (onTheFly=%1d)",mcLabel,v0part->GetOnFlyStatus()));
5cd139bc 203
204 if (fRecoCandidate->NumberOfFakeDaughters()>0){
205 fFake = 0; // fake candidate
206 if (fFakeSelection==1) return bSignAssoc;
207 }
208 if (fRecoCandidate->NumberOfFakeDaughters()==0){
209 fFake = 2; // non-fake candidate
210 if (fFakeSelection==2) return bSignAssoc;
211 }
212
a578b2da 213 SetMCLabel(mcLabel); // fmcLabel=mcLabel
5cd139bc 214 fmcPartCandidate = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fmcLabel));
5cd139bc 215 if (!fmcPartCandidate){
a578b2da 216 AliDebug(3,"No MC object for current candidate");
5cd139bc 217 return bSignAssoc;
218 }
219
220 bSignAssoc = kTRUE;
221 return bSignAssoc;
a578b2da 222
5cd139bc 223}
224
225//______________________________________________
226Bool_t AliCFVertexingHFLctoV0bachelor::GetGeneratedValuesFromMCParticle(Double_t* vectorMC)
227{
228 //
229 // collecting all the necessary info (pt, y, invMassV0, cosPAwrtPVxV0, onTheFlyStatusV0) from MC particle
230 // (additional infos: pTbachelor, pTV0pos, pTV0neg, phi, dcaV0, cTV0, cT, cosPA)
231 //
232
233 Bool_t bGenValues = kFALSE;
234
a578b2da 235 if (fmcPartCandidate->GetNDaughters()!=2) {
236 AliDebug(2,"Lc MC particle doesn't decay in 2 daughters");
237 return bGenValues;
238 }
5cd139bc 239
240 Int_t daughter0lc = fmcPartCandidate->GetDaughter(0);
241 Int_t daughter1lc = fmcPartCandidate->GetDaughter(1);
ff12b981 242 if (daughter0lc<=0 || daughter1lc<=0) {
a578b2da 243 AliDebug(2,"Lc daughters are not in MC array");
5cd139bc 244 return bGenValues;
245 }
246
a578b2da 247 AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0lc));
248 AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1lc));
249 if (!mcPartDaughter0 || !mcPartDaughter1) {
250 AliDebug(2,"Problems in the MC Daughters\n");
5cd139bc 251 return bGenValues;
252 }
5cd139bc 253
a578b2da 254 if ( fGenLcOption==kCountLambdapi &&
255 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
256 TMath::Abs(mcPartDaughter1->GetPdgCode())==211) &&
257 !(TMath::Abs(mcPartDaughter1->GetPdgCode())==3122 &&
258 TMath::Abs(mcPartDaughter0->GetPdgCode())==211) ) return bGenValues;
259 if ( fGenLcOption==kCountK0Sp &&
260 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==2212 &&
261 TMath::Abs(mcPartDaughter1->GetPdgCode())==311) &&
262 !(TMath::Abs(mcPartDaughter1->GetPdgCode())==2212 &&
263 TMath::Abs(mcPartDaughter0->GetPdgCode())==311) ) return bGenValues;
264
265 if ( (TMath::Abs(mcPartDaughter0->GetPdgCode())==311 &&
266 TMath::Abs(mcPartDaughter1->GetPdgCode())==2212) ||
267 (TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
268 TMath::Abs(mcPartDaughter1->GetPdgCode())==211) )
269 bGenValues = FillVectorFromMCarray(mcPartDaughter1,mcPartDaughter0,vectorMC);
270 else if ( (TMath::Abs(mcPartDaughter1->GetPdgCode())==311 &&
271 TMath::Abs(mcPartDaughter0->GetPdgCode())==2212) ||
272 (TMath::Abs(mcPartDaughter1->GetPdgCode())==3122 &&
273 TMath::Abs(mcPartDaughter0->GetPdgCode())==211) )
274 bGenValues = FillVectorFromMCarray(mcPartDaughter0,mcPartDaughter1,vectorMC);
275
276 if (!bGenValues)
277 AliDebug(2,"There is something wrong in filling MC vector");
5cd139bc 278
5cd139bc 279 return bGenValues;
280
281}
a578b2da 282
5cd139bc 283//____________________________________________
284Bool_t AliCFVertexingHFLctoV0bachelor::GetRecoValuesFromCandidate(Double_t *vectorReco) const
285{
286 // read the variables for the container
287
288 Bool_t bFillRecoValues = kFALSE;
289
290 //Get the Lc and the V0 from Lc
ff12b981 291 AliAODRecoCascadeHF* lcV0bachelor = dynamic_cast<AliAODRecoCascadeHF*>(fRecoCandidate);
5cd139bc 292
ff12b981 293 if (!lcV0bachelor) {
294 AliDebug(2,"Current cascade doesn't exist, skipped");
295 return bFillRecoValues;
296 }
297
298 if (!lcV0bachelor->GetSecondaryVtx()) {
299 AliDebug(2,"No secondary vertex for cascade");
300 return bFillRecoValues;
301 }
302
303 if (lcV0bachelor->GetNDaughters()!=2) {
304 AliDebug(2,Form("No 2 daughters for current cascade (nDaughters=%d)",lcV0bachelor->GetNDaughters()));
305 return bFillRecoValues;
306 }
307
308 AliAODTrack* bachelor = dynamic_cast<AliAODTrack*>(lcV0bachelor->GetBachelor());
309 AliAODv0* v0toDaughters = dynamic_cast<AliAODv0*>(lcV0bachelor->Getv0());
310 if (!bachelor || !v0toDaughters) {
a578b2da 311 AliDebug(2,"No V0 or bachelor in this reco candidate, skipping!");
312 return bFillRecoValues;
313 }
314
ff12b981 315 if (!v0toDaughters->GetSecondaryVtx()) {
316 AliDebug(2,"No secondary vertex for V0 by cascade");
317 return bFillRecoValues;
318 }
319
320 if (v0toDaughters->GetNDaughters()!=2) {
321 AliDebug(2,Form("current V0 has not 2 daughters (onTheFly=%d, nDaughters=%d)",v0toDaughters->GetOnFlyStatus(),v0toDaughters->GetNDaughters()));
322 return bFillRecoValues;
323 }
324
5cd139bc 325 Bool_t onTheFlyStatus = v0toDaughters->GetOnFlyStatus();
ff12b981 326 AliAODTrack* v0positiveTrack;
327 AliAODTrack* v0negativeTrack;
328 if (onTheFlyStatus) {
329 v0positiveTrack = dynamic_cast<AliAODTrack*>(lcV0bachelor->Getv0NegativeTrack());
330 v0negativeTrack = dynamic_cast<AliAODTrack*>(lcV0bachelor->Getv0PositiveTrack());
331 } else {
332 v0positiveTrack = dynamic_cast<AliAODTrack*>(lcV0bachelor->Getv0PositiveTrack());
333 v0negativeTrack = dynamic_cast<AliAODTrack*>(lcV0bachelor->Getv0NegativeTrack());
334 }
335
a578b2da 336 if (!v0positiveTrack || !v0negativeTrack) {
337 AliDebug(2,"No V0daughters in this reco candidate, skipping!");
338 return bFillRecoValues;
339 }
5cd139bc 340
341 Double_t pt = lcV0bachelor->Pt();
342 Double_t rapidity = lcV0bachelor->Y(4122);
a578b2da 343
344 Double_t cosPAwrtPrimVtxV0 = lcV0bachelor->CosV0PointingAngle();
5cd139bc 345
53c91ed7 346 //Double_t pTbachelor = bachelor->Pt();
347 Double_t pbachelor = bachelor->P();
348 //Double_t pTV0pos = v0positiveTrack->Pt();
349 //Double_t pTV0neg = v0negativeTrack->Pt();
5cd139bc 350 Double_t phi = lcV0bachelor->Phi();
351 Double_t dcaV0 = v0toDaughters->GetDCA();
53c91ed7 352 //Double_t cTLc = lcV0bachelor->Ct(4122); // wrt PrimVtx
5cd139bc 353 //Double_t dcaLc = lcV0bachelor->GetDCA();
354 Double_t cosPointingAngleLc = lcV0bachelor->CosPointingAngle();
355
53c91ed7 356 /*
a578b2da 357 Double_t cTV0 = 0.;
358 AliAODVertex *vtx0 = (AliAODVertex*)lcV0bachelor->GetPrimaryVtx();
359 if (!vtx0) {
360 AliDebug(2,"Candidate has not primary vtx");
361 } else {
362 Double_t primVtxPos[3] = {0.,0.,0.}; vtx0->GetXYZ(primVtxPos);
363 if (fGenLcOption==kCountK0Sp) {
364 cTV0 = v0toDaughters->Ct(310,primVtxPos);
365 } else if (fGenLcOption==kCountLambdapi) {
366 cTV0 = v0toDaughters->Ct(3122,primVtxPos);
367 }
5cd139bc 368 }
53c91ed7 369 */
5cd139bc 370
a578b2da 371 Double_t invMassV0 = 0.;
5cd139bc 372 if (fGenLcOption==kCountLambdapi) {
a578b2da 373
374 Short_t bachelorCharge = bachelor->Charge();
5cd139bc 375 if (bachelorCharge==1) {
376 invMassV0 = v0toDaughters->MassLambda();
377 } else if (bachelorCharge==-1) {
378 invMassV0 = v0toDaughters->MassAntiLambda();
379 }
380
381 } else if (fGenLcOption==kCountK0Sp) {
a578b2da 382
5cd139bc 383 invMassV0 = v0toDaughters->MassK0Short();
a578b2da 384
5cd139bc 385 }
386
a578b2da 387 vectorReco[0] = pt;
388 vectorReco[1] = rapidity;
389 vectorReco[2] = phi;
53c91ed7 390 vectorReco[3] = onTheFlyStatus;
391 vectorReco[4] = fzPrimVertex;
a578b2da 392 vectorReco[5] = fCentValue;
393 vectorReco[6] = fFake; // whether the reconstructed candidate was a fake (fFake = 0) or not (fFake = 2)
394 vectorReco[7] = fMultiplicity;
5cd139bc 395
a578b2da 396 if (fConfiguration==AliCFTaskVertexingHF::kSnail) {
53c91ed7 397 //vectorReco[8] = pTbachelor;
398 vectorReco[8] = pbachelor;
399 vectorReco[9] = v0toDaughters->Pt();
400 if (fGenLcOption==kCountLambdapi) {
401 vectorReco[10] = v0toDaughters->Y(3122);
402 } else if (fGenLcOption==kCountK0Sp) {
403 vectorReco[10] = v0toDaughters->Y(310);
404 }
405 vectorReco[11] = v0toDaughters->Phi();
406 vectorReco[12] = invMassV0;
407 vectorReco[13] = dcaV0;
408 vectorReco[14] = cosPAwrtPrimVtxV0;
5cd139bc 409 vectorReco[15] = cosPointingAngleLc;
53c91ed7 410 //vectorReco[16] = cTV0*1.E4; // in micron
411 //vectorReco[17] = cTLc*1.E4; // in micron
5cd139bc 412 }
413
414 bFillRecoValues = kTRUE;
415
416 return bFillRecoValues;
417}
418
419//_____________________________________________________________
420Bool_t AliCFVertexingHFLctoV0bachelor::CheckMCChannelDecay() const
421{
422 // check the required decay channel
423
424 Bool_t checkCD = kFALSE;
425
a578b2da 426 if (fmcPartCandidate->GetNDaughters()!=2) {
427 AliDebug(2, Form("The MC particle doesn't decay in 2 particles, skipping!!"));
428 return checkCD;
429 }
5cd139bc 430
431 Int_t daughter0 = fmcPartCandidate->GetDaughter(0);
432 Int_t daughter1 = fmcPartCandidate->GetDaughter(1);
ff12b981 433 if (daughter0<=0 || daughter1<=0){
a578b2da 434 AliDebug(2, Form("The MC particle doesn't have correct daughters, skipping!!"));
435 return checkCD;
436 }
5cd139bc 437 AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0));
438 AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1));
5cd139bc 439 if (!mcPartDaughter0 || !mcPartDaughter1) {
a578b2da 440 AliDebug(2,"Problems in the MC Daughters\n");
5cd139bc 441 return checkCD;
442 }
443
444 // Lc -> Lambda + pion AND cc
445 if (fGenLcOption==kCountLambdapi) {
446
447 if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
448 TMath::Abs(mcPartDaughter1->GetPdgCode())==211) &&
a578b2da 449 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211 &&
5cd139bc 450 TMath::Abs(mcPartDaughter1->GetPdgCode())==3122)) {
451 AliDebug(2, "The Lc MC doesn't decay in Lambda+pion (or cc), skipping!!");
452 return checkCD;
5cd139bc 453 }
454
a578b2da 455 if (TMath::Abs(mcPartDaughter0->GetPdgCode())==3122) {
456 mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
457 mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
458 }
9e4f1968 459 if (!mcPartDaughter0 || !mcPartDaughter1) {
460 AliDebug(2,"Problems in the MC Daughters\n");
461 return checkCD;
462 }
a578b2da 463
464 if (mcPartDaughter1->GetNDaughters()!=2) {
465 AliDebug(2, "The Lambda MC particle doesn't decay in 2 particles, skipping!!");
466 return checkCD;
467 }
468
469 Int_t daughter1D0 = mcPartDaughter1->GetDaughter(0);
470 Int_t daughter1D1 = mcPartDaughter1->GetDaughter(1);
ff12b981 471 if (daughter1D0<=0 || daughter1D1<=0) {
a578b2da 472 AliDebug(2, Form("The Lambda MC particle doesn't have correct daughters, skipping!!"));
473 return checkCD;
474 }
5cd139bc 475
a578b2da 476 AliAODMCParticle* mcPartDaughter1D0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D0));
477 AliAODMCParticle* mcPartDaughter1D1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D1));
478 if(!mcPartDaughter1D0 || !mcPartDaughter1D1) {
479 AliError("The Lambda daughter particle not found in MC array");
480 return checkCD;
481 }
482
483 if (!(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==211 &&
484 TMath::Abs(mcPartDaughter1D1->GetPdgCode())==2212) &&
485 !(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==2212 &&
486 TMath::Abs(mcPartDaughter1D1->GetPdgCode())==211)) {
487 AliDebug(2, "The Lambda MC doesn't decay in pi+proton (or cc), skipping!!");
488 return checkCD;
489 }
490
491 } else if (fGenLcOption==kCountK0Sp) { // Lc -> K0bar + proton AND cc
492
493 if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==311 &&
5cd139bc 494 TMath::Abs(mcPartDaughter1->GetPdgCode())==2212) &&
a578b2da 495 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==2212 &&
5cd139bc 496 TMath::Abs(mcPartDaughter1->GetPdgCode())==311)) {
497 AliDebug(2, "The Lc MC doesn't decay in K0+proton (or cc), skipping!!");
498 return checkCD;
499 }
500
501 if (TMath::Abs(mcPartDaughter0->GetPdgCode())==311) {
a578b2da 502 mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
503 mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
5cd139bc 504 }
e1603c28 505 if (!mcPartDaughter0 || !mcPartDaughter1) {
506 AliDebug(2,"Problems in the MC Daughters after swapping V0 and bachelor\n");
507 return checkCD;
508 }
5cd139bc 509
53c91ed7 510 if (mcPartDaughter1->GetNDaughters()!=1) {
511 AliDebug(2, "The K0/K0bar MC particle doesn't decay in 1 particles, skipping!!");
512 return checkCD;
513 }
514
a578b2da 515 Int_t daughter = mcPartDaughter1->GetDaughter(0);
ff12b981 516 if (daughter<=0) {
a578b2da 517 AliDebug(2, Form("The K0/K0bar MC particle doesn't have correct daughter, skipping!!"));
518 return checkCD;
5cd139bc 519 }
520
a578b2da 521 AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter));
522 if(!mcPartDaughter){
523 AliError("The K0/K0bar daughter particle not found in MC array");
524 return checkCD;
5cd139bc 525 }
5cd139bc 526
a578b2da 527 if (!(TMath::Abs(mcPartDaughter->GetPdgCode())==310)) {
528 AliDebug(2, "The K0/K0bar MC doesn't go in K0S, skipping!!");
529 return checkCD;
5cd139bc 530 }
5cd139bc 531
a578b2da 532 if (mcPartDaughter->GetNDaughters()!=2) {
533 AliDebug(2, "The K0S MC doesn't decay in 2 particles, skipping!!");
534 return checkCD;
5cd139bc 535 }
5cd139bc 536
a578b2da 537 Int_t daughterD0 = mcPartDaughter->GetDaughter(0);
538 Int_t daughterD1 = mcPartDaughter->GetDaughter(1);
ff12b981 539 if (daughterD0<=0 || daughterD1<=0) {
a578b2da 540 AliDebug(2, Form("The K0S MC particle doesn't have correct daughters, skipping!!"));
541 return checkCD;
542 }
5cd139bc 543
a578b2da 544 AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
545 AliAODMCParticle* mcPartDaughterD1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
546 if (!mcPartDaughterD0 || !mcPartDaughterD1) {
547 AliError("Daughter particle not found in MC array");
548 return checkCD;
5cd139bc 549 }
5cd139bc 550
a578b2da 551 if (! ( TMath::Abs(mcPartDaughterD0->GetPdgCode())==211 &&
552 TMath::Abs(mcPartDaughterD1->GetPdgCode())==211 ) ) {
553 AliDebug(2, "The K0S MC doesn't decay in pi+ pi-, skipping!!");
554 return checkCD;
555 }
5cd139bc 556
a578b2da 557 }
558
559 checkCD = kTRUE;
560 return checkCD;
561
562}
5cd139bc 563
564//_____________________________________________________________
565Double_t AliCFVertexingHFLctoV0bachelor::GetEtaProng(Int_t iProng) const
566{
567 //
568 // getting eta of the prong - overload the mother class method
569 //
570
a578b2da 571 Double_t etaProng =-9999;
5cd139bc 572
a578b2da 573 if (!fRecoCandidate) {
574 AliDebug(2,"No reco candidate selected");
575 return etaProng;
576 }
5cd139bc 577
a578b2da 578 AliAODRecoCascadeHF* lcV0bachelor = (AliAODRecoCascadeHF*)fRecoCandidate;
579 AliAODTrack* bachelor = (AliAODTrack*)lcV0bachelor->GetBachelor();
580 AliAODTrack* v0Pos = (AliAODTrack*)lcV0bachelor->Getv0PositiveTrack();
581 AliAODTrack* v0Neg = (AliAODTrack*)lcV0bachelor->Getv0NegativeTrack();
582 if (!(lcV0bachelor->Getv0()) || !bachelor || !v0Pos || !v0Neg) {
583 AliDebug(2,"No V0 for this reco candidate selected");
5cd139bc 584 return etaProng;
5cd139bc 585 }
a578b2da 586
587 if (iProng==0) etaProng = bachelor->Eta();
588 else if (iProng==1) etaProng = v0Pos->Eta();
589 else if (iProng==2) etaProng = v0Neg->Eta();
590
591 AliDebug(4,Form("Eta value for prong number %1d = %f",iProng,etaProng));
592
593 return etaProng;
594
5cd139bc 595}
596
597//_____________________________________________________________
598
599Double_t AliCFVertexingHFLctoV0bachelor::GetPtProng(Int_t iProng) const
600{
601 //
602 // getting pt of the prong
603 //
604
605 Double_t ptProng=-9999.;
606
a578b2da 607 if (!fRecoCandidate) {
608 AliDebug(2,"No reco candidate selected");
609 return ptProng;
610 }
5cd139bc 611
612 AliAODRecoCascadeHF* lcV0bachelor = (AliAODRecoCascadeHF*)fRecoCandidate;
a578b2da 613 AliAODTrack* bachelor = (AliAODTrack*)lcV0bachelor->GetBachelor();
614 AliAODTrack* v0Pos = (AliAODTrack*)lcV0bachelor->Getv0PositiveTrack();
615 AliAODTrack* v0Neg = (AliAODTrack*)lcV0bachelor->Getv0NegativeTrack();
616 if (!(lcV0bachelor->Getv0()) || !bachelor || !v0Pos || !v0Neg) {
617 AliDebug(2,"No V0 for this reco candidate selected");
618 return ptProng;
619 }
5cd139bc 620
a578b2da 621 if (iProng==0) ptProng = bachelor->Pt();
622 else if (iProng==1) ptProng = v0Pos->Pt();
623 else if (iProng==2) ptProng = v0Neg->Pt();
5cd139bc 624
a578b2da 625 AliDebug(4,Form("Pt value for prong number %1d = %f",iProng,ptProng));
626
5cd139bc 627 return ptProng;
628
629}
630
631//_____________________________________________________________
632
633Double_t AliCFVertexingHFLctoV0bachelor::Ctau(AliAODMCParticle *mcPartCandidate)
634{
635
636 Double_t cTau = 999999.;
637
a578b2da 638 Int_t daughterD0 = mcPartCandidate->GetDaughter(0);
639 Int_t daughterD1 = mcPartCandidate->GetDaughter(1);
ff12b981 640 if (daughterD0<=0 || daughterD1<=0) {
a578b2da 641 AliDebug(2, Form("The Lc MC particle doesn't have correct daughters, skipping!!"));
642 return cTau;
643 }
5cd139bc 644
ff12b981 645 AliAODMCParticle *mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
646 AliAODMCParticle *mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
a578b2da 647 if (!mcPartDaughter0 || !mcPartDaughter1) {
648 AliDebug(2,"The candidate daughter particles not found in MC array");
649 return cTau;
650 }
651
652 Double_t vtx1[3] = {0,0,0}; // primary vertex
653 Bool_t hasProdVertex = mcPartCandidate->XvYvZv(vtx1); // cm
654
5cd139bc 655 Double_t vtx1daughter[3] = {0,0,0}; // secondary vertex
a578b2da 656 Bool_t v0Vertex = mcPartDaughter0->XvYvZv(vtx1daughter); //cm
657 Double_t vtx2daughter[3] = {0,0,0}; // secondary vertex
658 Bool_t bachVertex = hasProdVertex && mcPartDaughter1->XvYvZv(vtx2daughter); //cm
5cd139bc 659
a578b2da 660 if (!hasProdVertex || !v0Vertex || !bachVertex) {
661 AliDebug(2,"At least one of Prim.vtx, V0vtx, BachelorVtx doesn't exist!");
662 return cTau;
663 }
664
665 if (TMath::Abs(vtx1daughter[0]-vtx2daughter[0])>1E-5 ||
666 TMath::Abs(vtx1daughter[1]-vtx2daughter[1])>1E-5 ||
667 TMath::Abs(vtx1daughter[2]-vtx2daughter[2])>1E-5) {
668 AliDebug(2,"Bachelor and V0 haven't common vtx!");
669 return cTau;
670 }
5cd139bc 671
672 Double_t decayLength = 0.;
673 for (Int_t ii=0; ii<3; ii++) decayLength += (vtx1daughter[ii]-vtx1[ii])*(vtx1daughter[ii]-vtx1[ii]);
674 decayLength = TMath::Sqrt(decayLength);
675
676 cTau = decayLength * mcPartCandidate->M()/mcPartCandidate->P();
a578b2da 677
5cd139bc 678 AliDebug(2,Form(" cTau(4122)=%f",cTau));
a578b2da 679
5cd139bc 680 return cTau;
681
682}
a578b2da 683
684//------------
685Bool_t AliCFVertexingHFLctoV0bachelor::SetLabelArray()
686{
687 //
688 // setting the label arrays
689 //
690
691 Bool_t checkCD = kFALSE;
692
693 if (fmcPartCandidate->GetNDaughters()!=2) {
ff12b981 694 AliDebug(2, Form("The MC particle have %d daughters (not 2), skipping!!",fmcPartCandidate->GetNDaughters()));
695 fmcPartCandidate->Print();
a578b2da 696 return checkCD;
697 }
698
699 Int_t daughter0 = fmcPartCandidate->GetDaughter(0);
700 Int_t daughter1 = fmcPartCandidate->GetDaughter(1);
ff12b981 701 if (daughter0<=0 || daughter1<=0){
a578b2da 702 AliDebug(2, Form("The MC particle doesn't have correct daughters, skipping!!"));
703 return checkCD;
704 }
705
706 AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0));
707 AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1));
708 if (!mcPartDaughter0 || !mcPartDaughter1) {
709 AliDebug(2,"Problems in the MC Daughters\n");
710 return checkCD;
711 }
712
713
714 fLabelArray = new Int_t[fProngs];
715
716 if (fGenLcOption==kCountLambdapi) { // Lc -> Lambda + pion OR cc
717
718 if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
719 TMath::Abs(mcPartDaughter1->GetPdgCode())==211) &&
720 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211 &&
721 TMath::Abs(mcPartDaughter1->GetPdgCode())==3122)) {
722 AliDebug(2, "The Lc MC doesn't decay in Lambda+pion (or cc), skipping!!");
723 delete [] fLabelArray;
724 fLabelArray = 0x0;
725 return checkCD;
726 }
727
728 // it is Lc -> Lambda + pion OR cc
729 if (TMath::Abs(mcPartDaughter0->GetPdgCode())==3122) {
730 mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
731 mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
732 Int_t daughterTemp = daughter0;
733 daughter0 = daughter1; // the bachelor label
734 daughter1 = daughterTemp; // the V0 label
735 }
736
737 if (mcPartDaughter1->GetNDaughters()!=2) {
738 AliDebug(2, "The Lambda MC particle doesn't decay in 2 particles, skipping!!");
739 delete [] fLabelArray;
740 fLabelArray = 0x0;
741 return checkCD;
742 }
743
744 Int_t daughter1D0 = mcPartDaughter1->GetDaughter(0);
745 Int_t daughter1D1 = mcPartDaughter1->GetDaughter(1);
ff12b981 746 if (daughter1D0<=0 || daughter1D1<=0) {
a578b2da 747 AliDebug(2, Form("The Lambda MC particle doesn't have correct daughters, skipping!!"));
748 delete [] fLabelArray;
749 fLabelArray = 0x0;
750 return checkCD;
751 }
752
753 AliAODMCParticle* mcPartDaughter1D0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D0));
754 AliAODMCParticle* mcPartDaughter1D1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D1));
755 if (!mcPartDaughter1D0 || !mcPartDaughter1D1) {
756 AliError("The Lambda daughter particles not found in MC array");
757 delete [] fLabelArray;
758 fLabelArray = 0x0;
759 return checkCD;
760 }
761
762 if (!(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==211 &&
763 TMath::Abs(mcPartDaughter1D1->GetPdgCode())==2212) &&
764 !(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==2212 &&
765 TMath::Abs(mcPartDaughter1D1->GetPdgCode())==211)) {
766 AliDebug(2, "The Lambda MC doesn't decay in pi+proton (or cc), skipping!!");
767 delete [] fLabelArray;
768 fLabelArray = 0x0;
769 return checkCD;
770 }
771
772 // Lambda -> p+pi OR cc
773
774 fLabelArray[0] = daughter0;//mcPartDaughter0->GetLabel(); // bachelor
775
776 if (fmcPartCandidate->Charge()>0) {
777
778 if (mcPartDaughter1D0->GetPdgCode()==2212) {
779 fLabelArray[1] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // proton
780 fLabelArray[2] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // pion
781 } else if (mcPartDaughter1D1->GetPdgCode()==2212) {
782 fLabelArray[1] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // proton
783 fLabelArray[2] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // pion
784 }
785
786 } else if (fmcPartCandidate->Charge()<0) {
787
788 if (mcPartDaughter1D0->GetPdgCode()==211) {
789 fLabelArray[1] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // pion
790 fLabelArray[2] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // proton
791 } else if (mcPartDaughter1D1->GetPdgCode()==211) {
792 fLabelArray[1] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // pion
793 fLabelArray[2] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // proton
794 }
795
796 }
797
798 } else if (fGenLcOption==kCountK0Sp) { // Lc -> K0bar + proton OR cc
799
800 if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==311 &&
801 TMath::Abs(mcPartDaughter1->GetPdgCode())==2212) &&
802 !(TMath::Abs(mcPartDaughter0->GetPdgCode())==2212 &&
803 TMath::Abs(mcPartDaughter1->GetPdgCode())==311)) {
804 AliDebug(2, "The Lc MC doesn't decay in K0bar+proton (or cc), skipping!!");
805 delete [] fLabelArray;
806 fLabelArray = 0x0;
807 return checkCD;
808 }
809
810 if (TMath::Abs(mcPartDaughter0->GetPdgCode())==311) {
811 mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
812 mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
813 Int_t daughterTemp = daughter0;
814 daughter0 = daughter1; // the bachelor label
815 daughter1 = daughterTemp; // the V0 label
816 }
817
ff12b981 818 if (mcPartDaughter1->GetNDaughters()!=1) {
819 AliDebug(2, "The K0/K0bar MC particle doesn't decay in 1 particles, skipping!!");
820 delete [] fLabelArray;
821 fLabelArray = 0x0;
822 return checkCD;
823 }
824
a578b2da 825 Int_t daughter = mcPartDaughter1->GetDaughter(0);
ff12b981 826 if (daughter<=0) {
a578b2da 827 AliDebug(2, Form("The K0/K0bar MC particle doesn't have correct daughter, skipping!!"));
828 delete [] fLabelArray;
829 fLabelArray = 0x0;
830 return checkCD;
831 }
832
833 AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter));
834 if (!mcPartDaughter) {
835 AliError("The K0/K0bar daughter particle not found in MC array");
836 delete [] fLabelArray;
837 fLabelArray = 0x0;
838 return checkCD;
839 }
840
841 if (!(TMath::Abs(mcPartDaughter->GetPdgCode())==310)) {
842 AliDebug(2, "The K0/K0bar MC doesn't go in K0S, skipping!!");
843 delete [] fLabelArray;
844 fLabelArray = 0x0;
845 return checkCD;
846 }
847
848 if (mcPartDaughter->GetNDaughters()!=2) {
849 AliDebug(2, "The K0S MC doesn't decay in 2 particles, skipping!!");
850 delete [] fLabelArray;
851 fLabelArray = 0x0;
852 return checkCD;
853 }
854
855 Int_t daughterD0 = mcPartDaughter->GetDaughter(0);
856 Int_t daughterD1 = mcPartDaughter->GetDaughter(1);
ff12b981 857 if (daughterD0<=0 || daughterD1<=0) {
a578b2da 858 AliDebug(2, Form("The K0S MC particle doesn't have correct daughters, skipping!!"));
859 delete [] fLabelArray;
860 fLabelArray = 0x0;
861 return checkCD;
862 }
863
864 AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
865 AliAODMCParticle* mcPartDaughterD1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
866 if (!mcPartDaughterD0 || !mcPartDaughterD1) {
867 AliError("The K0S daughter particles not found in MC array");
868 delete [] fLabelArray;
869 fLabelArray = 0x0;
870 return checkCD;
871 }
872
873 if (! ( TMath::Abs(mcPartDaughterD0->GetPdgCode())==211 &&
874 TMath::Abs(mcPartDaughterD1->GetPdgCode())==211 ) ) {
875 AliDebug(2, "The K0S MC doesn't decay in pi+ pi-, skipping!!");
876 delete [] fLabelArray;
877 fLabelArray = 0x0;
878 return checkCD;
879 }
880
881 // K0S -> pi+ pi-
882
883 fLabelArray[0] = daughter0;//mcPartDaughter0->GetLabel(); // bachelor
884
885 if (mcPartDaughterD0->GetPdgCode()==211) {
886 fLabelArray[1] = daughterD0;//mcPartDaughterD0->GetLabel(); // pi+
887 fLabelArray[2] = daughterD1;//mcPartDaughterD1->GetLabel(); // pi-
888 AliDebug(2,Form(" daughter0=%d ------ daughter1=%d ------ dg0->GetLabel()=%d ------ dg1->GetLabel()=%d ",daughterD0,daughterD1,mcPartDaughterD0->GetLabel(),mcPartDaughterD1->GetLabel()));
889 } else if (mcPartDaughterD1->GetPdgCode()==211) {
890 fLabelArray[1] = daughterD1;//mcPartDaughterD1->GetLabel(); // pi+
891 fLabelArray[2] = daughterD0;//mcPartDaughterD0->GetLabel(); // pi-
892 AliDebug(2,Form(" daughter0=%d ------ daughter1=%d ------ dg0->GetLabel()=%d ------ dg1->GetLabel()=%d ",daughterD1,daughterD0,mcPartDaughterD1->GetLabel(),mcPartDaughterD0->GetLabel()));
893 }
894 }
895
896 AliDebug(2,Form(" label0=%d, label1=%d, label2=%d",fLabelArray[0],fLabelArray[1],fLabelArray[2]));
897
898 SetAccCut(); // setting the pt and eta acceptance cuts
899
900 checkCD = kTRUE;
901 return checkCD;
902
903}
904//____________________________________________
905Bool_t AliCFVertexingHFLctoV0bachelor::FillVectorFromMCarray(AliAODMCParticle *mcPartDaughterBachelor,
906 AliAODMCParticle *mcPartDaughterK0,
907 Double_t *vectorMC)
908{
909 // fill the vector
910
911 Bool_t bGenValues = kFALSE;
912
913 AliAODMCParticle *mcPartV0DaughterPos = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[1]));
914 AliAODMCParticle *mcPartV0DaughterNeg = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[2]));
915 AliAODMCParticle *mcPartDaughterV0 = 0x0;
916
2db138e0 917 if(!mcPartV0DaughterPos || !mcPartV0DaughterNeg) return bGenValues;
a578b2da 918
919 if (TMath::Abs(mcPartDaughterK0->GetPdgCode())==311) {
920 Int_t daughterK0 = mcPartDaughterK0->GetDaughter(0);
ff12b981 921 if (daughterK0<=0) {
a578b2da 922 AliDebug(2, Form("The K0/K0bar particle doesn't have correct daughter, skipping!!"));
923 return bGenValues;
924 }
925 mcPartDaughterV0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterK0));
926 if (!mcPartDaughterV0) {
927 AliDebug(2,"The K0/K0bar daughter particle not found in MC array");
928 return bGenValues;
929 }
930 if (TMath::Abs(mcPartDaughterV0->GetPdgCode())!=310) {
931 AliDebug(2,"The K0/K0bar daughter particle is not a K0S");
932 return bGenValues;
933 }
934 } else if (TMath::Abs(mcPartDaughterK0->GetPdgCode())==3122) {
935 mcPartDaughterV0 = dynamic_cast<AliAODMCParticle*>(mcPartDaughterK0);
936 if (!mcPartDaughterV0) {
937 AliDebug(2,"The Lambda particle not found in MC array");
938 return bGenValues;
939 }
940 }
941
9e4f1968 942 if (!mcPartDaughterV0) {
943 AliDebug(2,"V0 particle not found in MC array");
944 return bGenValues;
945 }
a578b2da 946
53c91ed7 947 //Double_t cTLc = Ctau(fmcPartCandidate); // by default wrt Primary Vtx
948 //Double_t pTbach = mcPartDaughterBachelor->Pt(); // get the bachelor pT
949 Double_t pbach = mcPartDaughterBachelor->P(); // get the bachelor p
a578b2da 950
951 Double_t vtx1[3] = {0,0,0}; // primary vertex
952 Bool_t hasPrimVtx = fmcPartCandidate->XvYvZv(vtx1); // cm
953
954 // getting vertex from daughters
955 Double_t vtx1daughter0[3] = {0,0,0}; // secondary vertex from daughter 0
956 Bool_t hasSecVtx1 = mcPartDaughterBachelor->XvYvZv(vtx1daughter0); //cm
957 Double_t vtx1daughter1[3] = {0,0,0}; // secondary vertex from daughter 1
958 Bool_t hasSecVtx2 = mcPartDaughterV0->XvYvZv(vtx1daughter1); //cm
959 if (!hasPrimVtx || !hasSecVtx1 || !hasSecVtx2) {
960 AliDebug(2,"At least one of Prim.vtx, V0vtx, BachelorVtx doesn't exist!");
961 //return bGenValues;
962 }
963
964 if (TMath::Abs(vtx1daughter0[0]-vtx1daughter1[0])>1E-5 ||
965 TMath::Abs(vtx1daughter0[1]-vtx1daughter1[1])>1E-5 ||
966 TMath::Abs(vtx1daughter0[2]-vtx1daughter1[2])>1E-5) {
967 AliError("Daughters have different secondary vertex, skipping the track");
968 //return bGenValues;
969 }
970
971 // getting the momentum from the daughters
972 Double_t px1[2] = {mcPartDaughterBachelor->Px(), mcPartDaughterV0->Px()};
973 Double_t py1[2] = {mcPartDaughterBachelor->Py(), mcPartDaughterV0->Py()};
974 Double_t pz1[2] = {mcPartDaughterBachelor->Pz(), mcPartDaughterV0->Pz()};
975
976 Int_t nprongs = 2;
977 Short_t charge = mcPartDaughterBachelor->Charge();
978 Double_t d0[2] = {0.,0.};
979 AliAODRecoDecayHF* decayLc = new AliAODRecoDecayHF(vtx1,vtx1daughter0,nprongs,charge,px1,py1,pz1,d0);
980 Double_t cosPAwrtPrimVtxLc = decayLc->CosPointingAngle();
981 delete decayLc;
982
983 // getting vertex from daughters
984 Double_t vtx2daughter0[3] = {0,0,0}; // secondary vertex from daughter 0
985 Bool_t hasSecVtx3 = mcPartV0DaughterPos->XvYvZv(vtx2daughter0); //cm
986 Double_t vtx2daughter1[3] = {0,0,0}; // secondary vertex from daughter 1
987 Bool_t hasSecVtx4 = mcPartV0DaughterNeg->XvYvZv(vtx2daughter1); //cm
988 if (!hasSecVtx3 || !hasSecVtx4) {
989 AliDebug(2,"At least one of V0Posvtx, V0Negtx doesn't exist!");
990 //return bGenValues;
991 }
992
993 if (TMath::Abs(vtx2daughter0[0]-vtx2daughter1[0])>1E-5 ||
994 TMath::Abs(vtx2daughter0[1]-vtx2daughter1[1])>1E-5 ||
995 TMath::Abs(vtx2daughter0[2]-vtx2daughter1[2])>1E-5) {
996 AliError("Daughters have different secondary vertex, skipping the track");
997 //return bGenValues;
998 }
999
1000 // getting the momentum from the daughters
1001 Double_t px[2] = {mcPartV0DaughterPos->Px(), mcPartV0DaughterNeg->Px()};
1002 Double_t py[2] = {mcPartV0DaughterPos->Py(), mcPartV0DaughterNeg->Py()};
1003 Double_t pz[2] = {mcPartV0DaughterPos->Pz(), mcPartV0DaughterNeg->Pz()};
1004
1005 nprongs = 2;
1006 charge = 0;
1007 AliAODRecoDecayHF* decay = new AliAODRecoDecayHF(vtx1,vtx2daughter0,nprongs,charge,px,py,pz,d0);
1008 Double_t cosPAwrtPrimVtxV0 = decay->CosPointingAngle();
53c91ed7 1009 /*
a578b2da 1010 Double_t cTV0 = 0.; //ct
1011 if (fGenLcOption==kCountK0Sp) {
1012 cTV0 = decay->Ct(310); // by default wrt Primary Vtx
1013 } else if (fGenLcOption==kCountLambdapi) {
1014 cTV0 = decay->Ct(3122); // by default wrt Primary Vtx
1015 }
53c91ed7 1016 */
a578b2da 1017
1018 Double_t invMass = 0.; //invMass
1019 if (fGenLcOption==kCountK0Sp) {
1020 invMass = decay->InvMass2Prongs(0,1,211,211);
1021 } else if (fGenLcOption==kCountLambdapi) {
1022 if (fmcPartCandidate->GetPdgCode() == 4122)
1023 invMass = decay->InvMass2Prongs(0,1,2212,211);
1024 else if (fmcPartCandidate->GetPdgCode() ==-4122)
1025 invMass = decay->InvMass2Prongs(0,1,211,2212);
1026 }
1027 delete decay;
1028
1029 vectorMC[0] = fmcPartCandidate->Pt();
1030 vectorMC[1] = fmcPartCandidate->Y() ;
1031 vectorMC[2] = fmcPartCandidate->Phi();
53c91ed7 1032 vectorMC[3] = 0; // dummy value x MC, onTheFlyStatus
1033 vectorMC[4] = fzMCVertex;
a578b2da 1034 vectorMC[5] = fCentValue; // reconstructed centrality
1035 vectorMC[6] = 1; // dummy value x MC, fFake
1036 vectorMC[7] = fMultiplicity; // reconstructed multiplicity
1037
1038 if (fConfiguration==AliCFTaskVertexingHF::kSnail) {
53c91ed7 1039 //vectorMC[8] = pTbach;
1040 vectorMC[8] = pbach;
1041 vectorMC[9] = mcPartDaughterV0->Pt();
1042 vectorMC[10] = mcPartDaughterV0->Y();
1043 vectorMC[11] = mcPartDaughterV0->Phi();
1044 vectorMC[12] = invMass;
1045 vectorMC[13] = 0; // dummy value x MC, V0 DCA
1046 vectorMC[14] = cosPAwrtPrimVtxV0;
a578b2da 1047 vectorMC[15] = cosPAwrtPrimVtxLc;
53c91ed7 1048 //vectorMC[16] = cTV0*1.E4; // in micron
1049 //vectorMC[17] = cTLc*1.E4; // in micron
a578b2da 1050 }
1051
1052 bGenValues = kTRUE;
1053 return bGenValues;
1054
1055}