PWGHF/vertexingHF/AliCFVertexingHFLctoV0bachelor.cxx

   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
  30 #include "TDatabasePDG.h"
  31 #include "TClonesArray.h"
  32 #include "AliAODv0.h"
  33 #include "AliAODMCParticle.h"
  34 #include "AliAODRecoDecayHF.h"
  35 #include "AliAODRecoCascadeHF.h"
  36 #include "AliCFTaskVertexingHF.h"
  37 #include "AliCFContainer.h"
  38 #include "AliCFVertexingHF.h"
  39 #include "AliCFVertexingHFLctoV0bachelor.h"
  40
  41 #include <Riostream.h>
  42
  43 using std::cout;
  44 using std::endl;
  45
  46 ClassImp(AliCFVertexingHFLctoV0bachelor)
  47
  48 //_________________________________________
  49 AliCFVertexingHFLctoV0bachelor::AliCFVertexingHFLctoV0bachelor():
  50 fGenLcOption(0)
  51 {
  52   // standard constructor
  53 }
  54
  55 //_____________________________________
  56 AliCFVertexingHFLctoV0bachelor::AliCFVertexingHFLctoV0bachelor(TClonesArray *mcArray, UShort_t originDselection, Int_t lcDecay):
  57 AliCFVertexingHF(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 //_____________________________________
  74 AliCFVertexingHFLctoV0bachelor& 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 //__________________________________________
  87 Bool_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
  99   if (fRecoCandidate->GetPrimaryVtx()) AliDebug(4,"fReco Candidate has a pointer to PrimVtx\n");
 100
 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
 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   }
 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()));
 160     return bSignAssoc;
 161   }
 162
 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
 169   Int_t pdgDgLctoV0bachelor[2]={2212,310}; // first bachelor, second V0
 170   Int_t pdgDgV0toDaughters[2]={211,211};
 171   mcLabelK0S = lcV0bachelor->MatchToMC(pdgCand,pdgDgLctoV0bachelor[1],pdgDgLctoV0bachelor,pdgDgV0toDaughters,fmcArray,kTRUE);
 172
 173   // Lc->Lambda+pi and cc
 174   pdgDgLctoV0bachelor[0]=211, pdgDgLctoV0bachelor[1]=3122; // first bachelor, second V0
 175   pdgDgV0toDaughters[0]=2212,  pdgDgV0toDaughters[1]=211;
 176   mcLabelLambda = lcV0bachelor->MatchToMC(pdgCand,pdgDgLctoV0bachelor[1],pdgDgLctoV0bachelor,pdgDgV0toDaughters,fmcArray,kTRUE);
 177
 178   if (mcLabelK0S!=-1 && mcLabelLambda!=-1)
 179     AliDebug(2,"Strange: current Lc->V0+bachelor candidate has two MC different labels!");
 180
 181   if (fGenLcOption==kCountK0Sp) {
 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
 198   if (mcLabel==-1) {
 199     AliDebug(4,"No mcLabel found for current candidate");
 200     return bSignAssoc;
 201   }
 202   AliDebug(1,Form("Found mcLabel (%d) for current candidate",mcLabel));
 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
 213   SetMCLabel(mcLabel); // fmcLabel=mcLabel
 214   fmcPartCandidate = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fmcLabel));
 215   if (!fmcPartCandidate){
 216     AliDebug(3,"No MC object for current candidate");
 217     return bSignAssoc;
 218   }
 219
 220   bSignAssoc = kTRUE;
 221   return bSignAssoc;
 222
 223 }
 224
 225 //______________________________________________
 226 Bool_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
 235   if (fmcPartCandidate->GetNDaughters()!=2) {
 236     AliDebug(2,"Lc MC particle doesn't decay in 2 daughters");
 237     return bGenValues;
 238   }
 239
 240   Int_t daughter0lc = fmcPartCandidate->GetDaughter(0);
 241   Int_t daughter1lc = fmcPartCandidate->GetDaughter(1);
 242   if (daughter0lc<=0 || daughter1lc<=0) {
 243     AliDebug(2,"Lc daughters are not in MC array");
 244     return bGenValues;
 245   }
 246
 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");
 251     return bGenValues;
 252   }
 253
 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");
 278
 279   return bGenValues;
 280
 281 }
 282
 283 //____________________________________________
 284 Bool_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
 291   AliAODRecoCascadeHF* lcV0bachelor = dynamic_cast<AliAODRecoCascadeHF*>(fRecoCandidate);
 292
 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) {
 311     AliDebug(2,"No V0 or bachelor in this reco candidate, skipping!");
 312     return bFillRecoValues;
 313   }
 314
 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
 325   Bool_t onTheFlyStatus = v0toDaughters->GetOnFlyStatus();
 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
 336   if (!v0positiveTrack || !v0negativeTrack) {
 337     AliDebug(2,"No V0daughters in this reco candidate, skipping!");
 338     return bFillRecoValues;
 339   }
 340
 341   Double_t pt = lcV0bachelor->Pt();
 342   Double_t rapidity = lcV0bachelor->Y(4122);
 343
 344   Double_t cosPAwrtPrimVtxV0 = lcV0bachelor->CosV0PointingAngle();
 345
 346   Double_t pTbachelor = bachelor->Pt();
 347   Double_t pTV0pos = v0positiveTrack->Pt();
 348   Double_t pTV0neg = v0negativeTrack->Pt();
 349   Double_t phi = lcV0bachelor->Phi();
 350   Double_t dcaV0 = v0toDaughters->GetDCA();
 351   Double_t cTLc = lcV0bachelor->Ct(4122); // wrt PrimVtx
 352   //Double_t dcaLc = lcV0bachelor->GetDCA();
 353   Double_t cosPointingAngleLc = lcV0bachelor->CosPointingAngle();
 354
 355   Double_t cTV0 = 0.;
 356   AliAODVertex *vtx0 = (AliAODVertex*)lcV0bachelor->GetPrimaryVtx();
 357   if (!vtx0) {
 358     AliDebug(2,"Candidate has not primary vtx");
 359   } else {
 360     Double_t primVtxPos[3] = {0.,0.,0.}; vtx0->GetXYZ(primVtxPos);
 361     if (fGenLcOption==kCountK0Sp) {
 362       cTV0 = v0toDaughters->Ct(310,primVtxPos);
 363     } else if (fGenLcOption==kCountLambdapi) {
 364       cTV0 = v0toDaughters->Ct(3122,primVtxPos);
 365     }
 366   }
 367
 368   Double_t invMassV0 = 0.;
 369   if (fGenLcOption==kCountLambdapi) {
 370
 371     Short_t bachelorCharge = bachelor->Charge();
 372     if (bachelorCharge==1) {
 373       invMassV0 = v0toDaughters->MassLambda();
 374     } else if (bachelorCharge==-1) {
 375       invMassV0 = v0toDaughters->MassAntiLambda();
 376     }
 377
 378   } else if (fGenLcOption==kCountK0Sp) {
 379
 380     invMassV0 = v0toDaughters->MassK0Short();
 381
 382   }
 383
 384   vectorReco[0]  = pt;
 385   vectorReco[1]  = rapidity;
 386   vectorReco[2]  = phi;
 387   vectorReco[3]  = cosPAwrtPrimVtxV0;
 388   vectorReco[4]  = onTheFlyStatus;
 389   vectorReco[5]  = fCentValue;
 390   vectorReco[6]  = fFake; // whether the reconstructed candidate was a fake (fFake = 0) or not (fFake = 2)
 391   vectorReco[7]  = fMultiplicity;
 392
 393   if (fConfiguration==AliCFTaskVertexingHF::kSnail) {
 394     vectorReco[8]  = pTbachelor;
 395     vectorReco[9]  = pTV0pos;
 396     vectorReco[10] = pTV0neg;
 397     vectorReco[11] = invMassV0;
 398     vectorReco[12] = dcaV0;
 399     vectorReco[13] = cTV0*1.E4; // in micron
 400     vectorReco[14] = cTLc*1.E4; // in micron
 401     vectorReco[15] = cosPointingAngleLc;
 402   }
 403
 404   bFillRecoValues = kTRUE;
 405
 406   return bFillRecoValues;
 407 }
 408
 409 //_____________________________________________________________
 410 Bool_t AliCFVertexingHFLctoV0bachelor::CheckMCChannelDecay() const
 411 {
 412   // check the required decay channel
 413
 414   Bool_t checkCD = kFALSE;
 415
 416   if (fmcPartCandidate->GetNDaughters()!=2) {
 417     AliDebug(2, Form("The MC particle doesn't decay in 2 particles, skipping!!"));
 418     return checkCD;
 419   }
 420
 421   Int_t daughter0 = fmcPartCandidate->GetDaughter(0);
 422   Int_t daughter1 = fmcPartCandidate->GetDaughter(1);
 423   if (daughter0<=0 || daughter1<=0){
 424     AliDebug(2, Form("The MC particle doesn't have correct daughters, skipping!!"));
 425     return checkCD;
 426   }
 427   AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0));
 428   AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1));
 429   if (!mcPartDaughter0 || !mcPartDaughter1) {
 430     AliDebug(2,"Problems in the MC Daughters\n");
 431     return checkCD;
 432   }
 433
 434   // Lc -> Lambda + pion AND cc
 435   if (fGenLcOption==kCountLambdapi) {
 436
 437     if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
 438           TMath::Abs(mcPartDaughter1->GetPdgCode())==211) &&
 439         !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211  &&
 440           TMath::Abs(mcPartDaughter1->GetPdgCode())==3122)) {
 441       AliDebug(2, "The Lc MC doesn't decay in Lambda+pion (or cc), skipping!!");
 442       return checkCD;
 443     }
 444
 445     if (TMath::Abs(mcPartDaughter0->GetPdgCode())==3122) {
 446       mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
 447       mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
 448     }
 449     if (!mcPartDaughter0 || !mcPartDaughter1) {
 450       AliDebug(2,"Problems in the MC Daughters\n");
 451       return checkCD;
 452     }
 453
 454     if (mcPartDaughter1->GetNDaughters()!=2) {
 455       AliDebug(2, "The Lambda MC particle doesn't decay in 2 particles, skipping!!");
 456       return checkCD;
 457     }
 458
 459     Int_t daughter1D0 = mcPartDaughter1->GetDaughter(0);
 460     Int_t daughter1D1 = mcPartDaughter1->GetDaughter(1);
 461     if (daughter1D0<=0 || daughter1D1<=0) {
 462       AliDebug(2, Form("The Lambda MC particle doesn't have correct daughters, skipping!!"));
 463       return checkCD;
 464     }
 465
 466     AliAODMCParticle* mcPartDaughter1D0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D0));
 467     AliAODMCParticle* mcPartDaughter1D1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D1));
 468     if(!mcPartDaughter1D0 || !mcPartDaughter1D1) {
 469       AliError("The Lambda daughter particle not found in MC array");
 470       return checkCD;
 471     }
 472
 473     if (!(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==211   &&
 474           TMath::Abs(mcPartDaughter1D1->GetPdgCode())==2212) &&
 475         !(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==2212  &&
 476           TMath::Abs(mcPartDaughter1D1->GetPdgCode())==211)) {
 477       AliDebug(2, "The Lambda MC doesn't decay in pi+proton (or cc), skipping!!");
 478       return checkCD;
 479     }
 480
 481   } else if (fGenLcOption==kCountK0Sp) { // Lc -> K0bar + proton AND cc
 482
 483     if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==311   &&
 484           TMath::Abs(mcPartDaughter1->GetPdgCode())==2212) &&
 485         !(TMath::Abs(mcPartDaughter0->GetPdgCode())==2212  &&
 486           TMath::Abs(mcPartDaughter1->GetPdgCode())==311)) {
 487       AliDebug(2, "The Lc MC doesn't decay in K0+proton (or cc), skipping!!");
 488       return checkCD;
 489     }
 490
 491     if (TMath::Abs(mcPartDaughter0->GetPdgCode())==311) {
 492       mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
 493       mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
 494     }
 495     if (!mcPartDaughter0 || !mcPartDaughter1) {
 496       AliDebug(2,"Problems in the MC Daughters after swapping V0 and bachelor\n");
 497       return checkCD;
 498     }
 499
 500     Int_t daughter = mcPartDaughter1->GetDaughter(0);
 501     if (daughter<=0) {
 502       AliDebug(2, Form("The K0/K0bar MC particle doesn't have correct daughter, skipping!!"));
 503       return checkCD;
 504     }
 505
 506     AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter));
 507     if(!mcPartDaughter){
 508       AliError("The K0/K0bar daughter particle not found in MC array");
 509       return checkCD;
 510     }
 511
 512     if (!(TMath::Abs(mcPartDaughter->GetPdgCode())==310)) {
 513       AliDebug(2, "The K0/K0bar MC doesn't go in K0S, skipping!!");
 514       return checkCD;
 515     }
 516
 517     if (mcPartDaughter->GetNDaughters()!=2) {
 518       AliDebug(2, "The K0S MC doesn't decay in 2 particles, skipping!!");
 519       return checkCD;
 520     }
 521
 522     Int_t daughterD0 = mcPartDaughter->GetDaughter(0);
 523     Int_t daughterD1 = mcPartDaughter->GetDaughter(1);
 524     if (daughterD0<=0 || daughterD1<=0) {
 525       AliDebug(2, Form("The K0S MC particle doesn't have correct daughters, skipping!!"));
 526       return checkCD;
 527     }
 528
 529     AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
 530     AliAODMCParticle* mcPartDaughterD1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
 531     if (!mcPartDaughterD0 || !mcPartDaughterD1) {
 532       AliError("Daughter particle not found in MC array");
 533       return checkCD;
 534     }
 535
 536     if (! ( TMath::Abs(mcPartDaughterD0->GetPdgCode())==211 &&
 537             TMath::Abs(mcPartDaughterD1->GetPdgCode())==211 ) ) {
 538       AliDebug(2, "The K0S MC doesn't decay in pi+ pi-, skipping!!");
 539       return checkCD;
 540     }
 541
 542   }
 543
 544   checkCD = kTRUE;
 545   return checkCD;
 546
 547 }
 548
 549 //_____________________________________________________________
 550 Double_t AliCFVertexingHFLctoV0bachelor::GetEtaProng(Int_t iProng) const
 551 {
 552   //
 553   // getting eta of the prong - overload the mother class method
 554   //
 555
 556   Double_t etaProng =-9999;
 557
 558   if (!fRecoCandidate) {
 559     AliDebug(2,"No reco candidate selected");
 560     return etaProng;
 561   }
 562
 563   AliAODRecoCascadeHF* lcV0bachelor = (AliAODRecoCascadeHF*)fRecoCandidate;
 564   AliAODTrack* bachelor = (AliAODTrack*)lcV0bachelor->GetBachelor();
 565   AliAODTrack* v0Pos = (AliAODTrack*)lcV0bachelor->Getv0PositiveTrack();
 566   AliAODTrack* v0Neg = (AliAODTrack*)lcV0bachelor->Getv0NegativeTrack();
 567   if (!(lcV0bachelor->Getv0()) || !bachelor || !v0Pos || !v0Neg) {
 568     AliDebug(2,"No V0 for this reco candidate selected");
 569     return etaProng;
 570   }
 571
 572   if (iProng==0) etaProng = bachelor->Eta();
 573   else if (iProng==1) etaProng = v0Pos->Eta();
 574   else if (iProng==2) etaProng = v0Neg->Eta();
 575
 576   AliDebug(4,Form("Eta value for prong number %1d = %f",iProng,etaProng));
 577
 578   return etaProng;
 579
 580 }
 581
 582 //_____________________________________________________________
 583
 584 Double_t AliCFVertexingHFLctoV0bachelor::GetPtProng(Int_t iProng) const
 585 {
 586   //
 587   // getting pt of the prong
 588   //
 589
 590   Double_t ptProng=-9999.;
 591
 592   if (!fRecoCandidate) {
 593     AliDebug(2,"No reco candidate selected");
 594     return ptProng;
 595   }
 596
 597   AliAODRecoCascadeHF* lcV0bachelor = (AliAODRecoCascadeHF*)fRecoCandidate;
 598   AliAODTrack* bachelor = (AliAODTrack*)lcV0bachelor->GetBachelor();
 599   AliAODTrack* v0Pos = (AliAODTrack*)lcV0bachelor->Getv0PositiveTrack();
 600   AliAODTrack* v0Neg = (AliAODTrack*)lcV0bachelor->Getv0NegativeTrack();
 601   if (!(lcV0bachelor->Getv0()) || !bachelor || !v0Pos || !v0Neg) {
 602     AliDebug(2,"No V0 for this reco candidate selected");
 603     return ptProng;
 604   }
 605
 606   if (iProng==0) ptProng = bachelor->Pt();
 607   else if (iProng==1) ptProng = v0Pos->Pt();
 608   else if (iProng==2) ptProng = v0Neg->Pt();
 609
 610   AliDebug(4,Form("Pt value for prong number %1d = %f",iProng,ptProng));
 611
 612   return ptProng;
 613
 614 }
 615
 616 //_____________________________________________________________
 617
 618 Double_t AliCFVertexingHFLctoV0bachelor::Ctau(AliAODMCParticle *mcPartCandidate)
 619 {
 620
 621   Double_t cTau = 999999.;
 622
 623   Int_t daughterD0 = mcPartCandidate->GetDaughter(0);
 624   Int_t daughterD1 = mcPartCandidate->GetDaughter(1);
 625   if (daughterD0<=0 || daughterD1<=0) {
 626     AliDebug(2, Form("The Lc MC particle doesn't have correct daughters, skipping!!"));
 627     return cTau;
 628   }
 629
 630   AliAODMCParticle *mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
 631   AliAODMCParticle *mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
 632   if (!mcPartDaughter0 || !mcPartDaughter1) {
 633     AliDebug(2,"The candidate daughter particles not found in MC array");
 634     return cTau;
 635   }
 636
 637   Double_t vtx1[3] = {0,0,0};   // primary vertex
 638   Bool_t hasProdVertex = mcPartCandidate->XvYvZv(vtx1);  // cm
 639
 640   Double_t vtx1daughter[3] = {0,0,0};   // secondary vertex
 641   Bool_t v0Vertex = mcPartDaughter0->XvYvZv(vtx1daughter);  //cm
 642   Double_t vtx2daughter[3] = {0,0,0};   // secondary vertex
 643   Bool_t bachVertex = hasProdVertex && mcPartDaughter1->XvYvZv(vtx2daughter);  //cm
 644
 645   if (!hasProdVertex || !v0Vertex || !bachVertex) {
 646     AliDebug(2,"At least one of Prim.vtx, V0vtx, BachelorVtx doesn't exist!");
 647     return cTau;
 648   }
 649
 650   if (TMath::Abs(vtx1daughter[0]-vtx2daughter[0])>1E-5 ||
 651       TMath::Abs(vtx1daughter[1]-vtx2daughter[1])>1E-5 ||
 652       TMath::Abs(vtx1daughter[2]-vtx2daughter[2])>1E-5) {
 653     AliDebug(2,"Bachelor and V0 haven't common vtx!");
 654     return cTau;
 655   }
 656
 657   Double_t decayLength = 0.;
 658   for (Int_t ii=0; ii<3; ii++) decayLength += (vtx1daughter[ii]-vtx1[ii])*(vtx1daughter[ii]-vtx1[ii]);
 659   decayLength = TMath::Sqrt(decayLength);
 660
 661   cTau = decayLength * mcPartCandidate->M()/mcPartCandidate->P();
 662
 663   AliDebug(2,Form(" cTau(4122)=%f",cTau));
 664
 665   return cTau;
 666
 667 }
 668
 669 //------------
 670 Bool_t AliCFVertexingHFLctoV0bachelor::SetLabelArray()
 671 {
 672   //
 673   // setting the label arrays
 674   //
 675
 676   Bool_t checkCD = kFALSE;
 677
 678   if (fmcPartCandidate->GetNDaughters()!=2) {
 679     AliDebug(2, Form("The MC particle have %d daughters (not 2), skipping!!",fmcPartCandidate->GetNDaughters()));
 680     fmcPartCandidate->Print();
 681     return checkCD;
 682   }
 683
 684   Int_t daughter0 = fmcPartCandidate->GetDaughter(0);
 685   Int_t daughter1 = fmcPartCandidate->GetDaughter(1);
 686   if (daughter0<=0 || daughter1<=0){
 687     AliDebug(2, Form("The MC particle doesn't have correct daughters, skipping!!"));
 688     return checkCD;
 689   }
 690
 691   AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0));
 692   AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1));
 693   if (!mcPartDaughter0 || !mcPartDaughter1) {
 694     AliDebug(2,"Problems in the MC Daughters\n");
 695     return checkCD;
 696   }
 697
 698
 699   fLabelArray = new Int_t[fProngs];
 700
 701   if (fGenLcOption==kCountLambdapi) { // Lc -> Lambda + pion OR cc
 702
 703     if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==3122 &&
 704           TMath::Abs(mcPartDaughter1->GetPdgCode())==211) &&
 705         !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211  &&
 706           TMath::Abs(mcPartDaughter1->GetPdgCode())==3122)) {
 707       AliDebug(2, "The Lc MC doesn't decay in Lambda+pion (or cc), skipping!!");
 708       delete [] fLabelArray;
 709       fLabelArray = 0x0;
 710       return checkCD;
 711     }
 712
 713     // it is Lc -> Lambda + pion OR cc
 714     if (TMath::Abs(mcPartDaughter0->GetPdgCode())==3122) {
 715       mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
 716       mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
 717       Int_t daughterTemp = daughter0;
 718       daughter0 = daughter1; // the bachelor label
 719       daughter1 = daughterTemp; // the V0 label
 720     }
 721
 722     if (mcPartDaughter1->GetNDaughters()!=2) {
 723       AliDebug(2, "The Lambda MC particle doesn't decay in 2 particles, skipping!!");
 724       delete [] fLabelArray;
 725       fLabelArray = 0x0;
 726       return checkCD;
 727     }
 728
 729     Int_t daughter1D0 = mcPartDaughter1->GetDaughter(0);
 730     Int_t daughter1D1 = mcPartDaughter1->GetDaughter(1);
 731     if (daughter1D0<=0 || daughter1D1<=0) {
 732       AliDebug(2, Form("The Lambda MC particle doesn't have correct daughters, skipping!!"));
 733       delete [] fLabelArray;
 734       fLabelArray = 0x0;
 735       return checkCD;
 736     }
 737
 738     AliAODMCParticle* mcPartDaughter1D0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D0));
 739     AliAODMCParticle* mcPartDaughter1D1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1D1));
 740     if (!mcPartDaughter1D0 || !mcPartDaughter1D1) {
 741       AliError("The Lambda daughter particles not found in MC array");
 742       delete [] fLabelArray;
 743       fLabelArray = 0x0;
 744       return checkCD;
 745     }
 746
 747     if (!(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==211   &&
 748           TMath::Abs(mcPartDaughter1D1->GetPdgCode())==2212) &&
 749         !(TMath::Abs(mcPartDaughter1D0->GetPdgCode())==2212  &&
 750           TMath::Abs(mcPartDaughter1D1->GetPdgCode())==211)) {
 751       AliDebug(2, "The Lambda MC doesn't decay in pi+proton (or cc), skipping!!");
 752       delete [] fLabelArray;
 753       fLabelArray = 0x0;
 754       return checkCD;
 755     }
 756
 757     // Lambda -> p+pi OR cc
 758
 759     fLabelArray[0] = daughter0;//mcPartDaughter0->GetLabel(); // bachelor
 760
 761     if (fmcPartCandidate->Charge()>0) {
 762
 763       if (mcPartDaughter1D0->GetPdgCode()==2212) {
 764         fLabelArray[1] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // proton
 765         fLabelArray[2] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // pion
 766       } else if (mcPartDaughter1D1->GetPdgCode()==2212) {
 767         fLabelArray[1] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // proton
 768         fLabelArray[2] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // pion
 769       }
 770
 771     } else if (fmcPartCandidate->Charge()<0) {
 772
 773       if (mcPartDaughter1D0->GetPdgCode()==211) {
 774         fLabelArray[1] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // pion
 775         fLabelArray[2] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // proton
 776       } else if (mcPartDaughter1D1->GetPdgCode()==211) {
 777         fLabelArray[1] = daughter1D1;//mcPartDaughter1D1->GetLabel(); // pion
 778         fLabelArray[2] = daughter1D0;//mcPartDaughter1D0->GetLabel(); // proton
 779       }
 780
 781     }
 782
 783   } else if (fGenLcOption==kCountK0Sp) { // Lc -> K0bar + proton OR cc
 784
 785     if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==311   &&
 786           TMath::Abs(mcPartDaughter1->GetPdgCode())==2212) &&
 787         !(TMath::Abs(mcPartDaughter0->GetPdgCode())==2212  &&
 788           TMath::Abs(mcPartDaughter1->GetPdgCode())==311)) {
 789       AliDebug(2, "The Lc MC doesn't decay in K0bar+proton (or cc), skipping!!");
 790       delete [] fLabelArray;
 791       fLabelArray = 0x0;
 792       return checkCD;
 793     }
 794
 795     if (TMath::Abs(mcPartDaughter0->GetPdgCode())==311) {
 796       mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); // the bachelor
 797       mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); // the V0
 798       Int_t daughterTemp = daughter0;
 799       daughter0 = daughter1; // the bachelor label
 800       daughter1 = daughterTemp; // the V0 label
 801     }
 802
 803     if (mcPartDaughter1->GetNDaughters()!=1) {
 804       AliDebug(2, "The K0/K0bar MC particle doesn't decay in 1 particles, skipping!!");
 805       delete [] fLabelArray;
 806       fLabelArray = 0x0;
 807       return checkCD;
 808     }
 809
 810     Int_t daughter = mcPartDaughter1->GetDaughter(0);
 811     if (daughter<=0) {
 812       AliDebug(2, Form("The K0/K0bar MC particle doesn't have correct daughter, skipping!!"));
 813       delete [] fLabelArray;
 814       fLabelArray = 0x0;
 815       return checkCD;
 816     }
 817
 818     AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter));
 819     if (!mcPartDaughter) {
 820       AliError("The K0/K0bar daughter particle not found in MC array");
 821       delete [] fLabelArray;
 822       fLabelArray = 0x0;
 823       return checkCD;
 824     }
 825
 826     if (!(TMath::Abs(mcPartDaughter->GetPdgCode())==310)) {
 827       AliDebug(2, "The K0/K0bar MC doesn't go in K0S, skipping!!");
 828       delete [] fLabelArray;
 829       fLabelArray = 0x0;
 830       return checkCD;
 831     }
 832
 833     if (mcPartDaughter->GetNDaughters()!=2) {
 834       AliDebug(2, "The K0S MC doesn't decay in 2 particles, skipping!!");
 835       delete [] fLabelArray;
 836       fLabelArray = 0x0;
 837       return checkCD;
 838     }
 839
 840     Int_t daughterD0 = mcPartDaughter->GetDaughter(0);
 841     Int_t daughterD1 = mcPartDaughter->GetDaughter(1);
 842     if (daughterD0<=0 || daughterD1<=0) {
 843       AliDebug(2, Form("The K0S MC particle doesn't have correct daughters, skipping!!"));
 844       delete [] fLabelArray;
 845       fLabelArray = 0x0;
 846       return checkCD;
 847     }
 848
 849     AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD0));
 850     AliAODMCParticle* mcPartDaughterD1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD1));
 851     if (!mcPartDaughterD0 || !mcPartDaughterD1) {
 852       AliError("The K0S daughter particles not found in MC array");
 853       delete [] fLabelArray;
 854       fLabelArray = 0x0;
 855       return checkCD;
 856     }
 857
 858     if (! ( TMath::Abs(mcPartDaughterD0->GetPdgCode())==211 &&
 859             TMath::Abs(mcPartDaughterD1->GetPdgCode())==211 ) ) {
 860       AliDebug(2, "The K0S MC doesn't decay in pi+ pi-, skipping!!");
 861       delete [] fLabelArray;
 862       fLabelArray = 0x0;
 863       return checkCD;
 864     }
 865
 866     // K0S -> pi+ pi-
 867
 868     fLabelArray[0] = daughter0;//mcPartDaughter0->GetLabel(); // bachelor
 869
 870     if (mcPartDaughterD0->GetPdgCode()==211) {
 871       fLabelArray[1] = daughterD0;//mcPartDaughterD0->GetLabel(); // pi+
 872       fLabelArray[2] = daughterD1;//mcPartDaughterD1->GetLabel(); // pi-
 873       AliDebug(2,Form(" daughter0=%d ------ daughter1=%d ------ dg0->GetLabel()=%d ------ dg1->GetLabel()=%d ",daughterD0,daughterD1,mcPartDaughterD0->GetLabel(),mcPartDaughterD1->GetLabel()));
 874     } else if (mcPartDaughterD1->GetPdgCode()==211) {
 875       fLabelArray[1] = daughterD1;//mcPartDaughterD1->GetLabel(); // pi+
 876       fLabelArray[2] = daughterD0;//mcPartDaughterD0->GetLabel(); // pi-
 877       AliDebug(2,Form(" daughter0=%d ------ daughter1=%d ------ dg0->GetLabel()=%d ------ dg1->GetLabel()=%d ",daughterD1,daughterD0,mcPartDaughterD1->GetLabel(),mcPartDaughterD0->GetLabel()));
 878     }
 879   }
 880
 881   AliDebug(2,Form(" label0=%d, label1=%d, label2=%d",fLabelArray[0],fLabelArray[1],fLabelArray[2]));
 882
 883   SetAccCut(); // setting the pt and eta acceptance cuts
 884
 885   checkCD = kTRUE;
 886   return checkCD;
 887
 888 }
 889 //____________________________________________
 890 Bool_t AliCFVertexingHFLctoV0bachelor::FillVectorFromMCarray(AliAODMCParticle *mcPartDaughterBachelor,
 891                                                              AliAODMCParticle *mcPartDaughterK0,
 892                                                              Double_t *vectorMC)
 893 {
 894   // fill the vector
 895
 896   Bool_t bGenValues = kFALSE;
 897
 898   AliAODMCParticle *mcPartV0DaughterPos = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[1]));
 899   AliAODMCParticle *mcPartV0DaughterNeg = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[2]));
 900   AliAODMCParticle *mcPartDaughterV0 = 0x0;
 901
 902   if(!mcPartV0DaughterPos && !mcPartV0DaughterNeg) return bGenValues;
 903
 904   if (TMath::Abs(mcPartDaughterK0->GetPdgCode())==311) {
 905     Int_t daughterK0 = mcPartDaughterK0->GetDaughter(0);
 906     if (daughterK0<=0) {
 907       AliDebug(2, Form("The K0/K0bar particle doesn't have correct daughter, skipping!!"));
 908       return bGenValues;
 909     }
 910     mcPartDaughterV0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterK0));
 911     if (!mcPartDaughterV0) {
 912       AliDebug(2,"The K0/K0bar daughter particle not found in MC array");
 913       return bGenValues;
 914     }
 915     if (TMath::Abs(mcPartDaughterV0->GetPdgCode())!=310) {
 916       AliDebug(2,"The K0/K0bar daughter particle is not a K0S");
 917       return bGenValues;
 918     }
 919   } else if (TMath::Abs(mcPartDaughterK0->GetPdgCode())==3122) {
 920     mcPartDaughterV0 = dynamic_cast<AliAODMCParticle*>(mcPartDaughterK0);
 921     if (!mcPartDaughterV0) {
 922       AliDebug(2,"The Lambda particle not found in MC array");
 923       return bGenValues;
 924     }
 925   }
 926
 927   if (!mcPartDaughterV0) {
 928     AliDebug(2,"V0 particle not found in MC array");
 929     return bGenValues;
 930   }
 931
 932   Double_t cTLc = Ctau(fmcPartCandidate); // by default wrt Primary Vtx
 933   Double_t pTbach = mcPartDaughterBachelor->Pt(); // get the bachelor pT
 934
 935   Double_t vtx1[3] = {0,0,0};   // primary vertex
 936   Bool_t hasPrimVtx = fmcPartCandidate->XvYvZv(vtx1);  // cm
 937
 938   // getting vertex from daughters
 939   Double_t vtx1daughter0[3] = {0,0,0};   // secondary vertex from daughter 0
 940   Bool_t hasSecVtx1 = mcPartDaughterBachelor->XvYvZv(vtx1daughter0);  //cm
 941   Double_t vtx1daughter1[3] = {0,0,0};   // secondary vertex from daughter 1
 942   Bool_t hasSecVtx2 = mcPartDaughterV0->XvYvZv(vtx1daughter1);  //cm
 943   if (!hasPrimVtx || !hasSecVtx1 || !hasSecVtx2) {
 944     AliDebug(2,"At least one of Prim.vtx, V0vtx, BachelorVtx doesn't exist!");
 945     //return bGenValues;
 946   }
 947
 948   if (TMath::Abs(vtx1daughter0[0]-vtx1daughter1[0])>1E-5 ||
 949       TMath::Abs(vtx1daughter0[1]-vtx1daughter1[1])>1E-5 ||
 950       TMath::Abs(vtx1daughter0[2]-vtx1daughter1[2])>1E-5) {
 951     AliError("Daughters have different secondary vertex, skipping the track");
 952     //return bGenValues;
 953   }
 954
 955   // getting the momentum from the daughters
 956   Double_t px1[2] = {mcPartDaughterBachelor->Px(), mcPartDaughterV0->Px()};
 957   Double_t py1[2] = {mcPartDaughterBachelor->Py(), mcPartDaughterV0->Py()};
 958   Double_t pz1[2] = {mcPartDaughterBachelor->Pz(), mcPartDaughterV0->Pz()};
 959
 960   Int_t nprongs = 2;
 961   Short_t charge = mcPartDaughterBachelor->Charge();
 962   Double_t d0[2] = {0.,0.};
 963   AliAODRecoDecayHF* decayLc = new AliAODRecoDecayHF(vtx1,vtx1daughter0,nprongs,charge,px1,py1,pz1,d0);
 964   Double_t cosPAwrtPrimVtxLc = decayLc->CosPointingAngle();
 965   delete decayLc;
 966
 967   // getting vertex from daughters
 968   Double_t vtx2daughter0[3] = {0,0,0};   // secondary vertex from daughter 0
 969   Bool_t hasSecVtx3 = mcPartV0DaughterPos->XvYvZv(vtx2daughter0);  //cm
 970   Double_t vtx2daughter1[3] = {0,0,0};   // secondary vertex from daughter 1
 971   Bool_t hasSecVtx4 = mcPartV0DaughterNeg->XvYvZv(vtx2daughter1);  //cm
 972   if (!hasSecVtx3 || !hasSecVtx4) {
 973     AliDebug(2,"At least one of V0Posvtx, V0Negtx doesn't exist!");
 974     //return bGenValues;
 975   }
 976
 977   if (TMath::Abs(vtx2daughter0[0]-vtx2daughter1[0])>1E-5 ||
 978       TMath::Abs(vtx2daughter0[1]-vtx2daughter1[1])>1E-5 ||
 979       TMath::Abs(vtx2daughter0[2]-vtx2daughter1[2])>1E-5) {
 980     AliError("Daughters have different secondary vertex, skipping the track");
 981     //return bGenValues;
 982   }
 983
 984   // getting the momentum from the daughters
 985   Double_t px[2] = {mcPartV0DaughterPos->Px(), mcPartV0DaughterNeg->Px()};
 986   Double_t py[2] = {mcPartV0DaughterPos->Py(), mcPartV0DaughterNeg->Py()};
 987   Double_t pz[2] = {mcPartV0DaughterPos->Pz(), mcPartV0DaughterNeg->Pz()};
 988
 989   nprongs = 2;
 990   charge = 0;
 991   AliAODRecoDecayHF* decay = new AliAODRecoDecayHF(vtx1,vtx2daughter0,nprongs,charge,px,py,pz,d0);
 992   Double_t cosPAwrtPrimVtxV0 = decay->CosPointingAngle();
 993   Double_t cTV0 = 0.; //ct
 994   if (fGenLcOption==kCountK0Sp) {
 995     cTV0 = decay->Ct(310); // by default wrt Primary Vtx
 996   } else if (fGenLcOption==kCountLambdapi) {
 997     cTV0 = decay->Ct(3122); // by default wrt Primary Vtx
 998   }
 999
1000   Double_t invMass = 0.; //invMass
1001   if (fGenLcOption==kCountK0Sp) {
1002     invMass = decay->InvMass2Prongs(0,1,211,211);
1003   } else if (fGenLcOption==kCountLambdapi) {
1004     if (fmcPartCandidate->GetPdgCode() == 4122)
1005       invMass = decay->InvMass2Prongs(0,1,2212,211);
1006     else if (fmcPartCandidate->GetPdgCode() ==-4122)
1007       invMass = decay->InvMass2Prongs(0,1,211,2212);
1008   }
1009   delete decay;
1010
1011   vectorMC[0]  = fmcPartCandidate->Pt();
1012   vectorMC[1]  = fmcPartCandidate->Y() ;
1013   vectorMC[2]  = fmcPartCandidate->Phi();
1014   vectorMC[3]  = cosPAwrtPrimVtxV0;
1015   vectorMC[4]  = 0; // dummy value x MC, onTheFlyStatus
1016   vectorMC[5]  = fCentValue; // reconstructed centrality
1017   vectorMC[6]  = 1; // dummy value x MC, fFake
1018   vectorMC[7]  = fMultiplicity; // reconstructed multiplicity
1019
1020   if (fConfiguration==AliCFTaskVertexingHF::kSnail) {
1021     vectorMC[8]  = pTbach;
1022     vectorMC[9]  = mcPartV0DaughterPos->Pt();
1023     vectorMC[10] = mcPartV0DaughterNeg->Pt();
1024     vectorMC[11] = invMass;
1025     vectorMC[12] = 0; // dummy value x MC, V0 DCA
1026     vectorMC[13] = cTV0*1.E4; // in micron
1027     vectorMC[14] = cTLc*1.E4; // in micron
1028     vectorMC[15] = cosPAwrtPrimVtxLc;
1029   }
1030
1031   bGenValues = kTRUE;
1032   return bGenValues;
1033
1034 }