[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliCFVertexingHFCascade.cxx

/**************************************************************************
 * Copyright(c) 1998-2011, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-----------------------------------------------------------------------
// Class for HF corrections as a function of many variables and steps
// For D* and other cascades
// 
// Author : A.Grelli a.grelli@uu.nl  UTECHT
//-----------------------------------------------------------------------

#include "AliAODRecoDecayHF2Prong.h"
#include "AliAODMCParticle.h"
#include "AliAODEvent.h"
#include "TClonesArray.h"
#include "AliCFVertexingHF.h"
#include "AliESDtrack.h"
#include "TDatabasePDG.h"
#include "AliAODRecoCascadeHF.h"
#include "AliCFVertexingHFCascade.h"
#include "AliCFContainer.h"

ClassImp(AliCFVertexingHFCascade)


//_________________________________________
  AliCFVertexingHFCascade::AliCFVertexingHFCascade(TClonesArray *mcArray, UShort_t originDselection):
  AliCFVertexingHF(mcArray, originDselection)
{	
  // standard constructor

  SetNProngs(3);
  fPtAccCut=new Float_t[fProngs];
  fEtaAccCut=new Float_t[fProngs];
  // element 0 in the cut arrays corresponds to the soft pion!!!!!!!! Careful when setting the values...
  fPtAccCut[0]=0.;
  fEtaAccCut[0]=0.;
  for(Int_t iP=1; iP<fProngs; iP++){
	  fPtAccCut[iP]=0.1;
	  fEtaAccCut[iP]=0.9;
  }

}


//_____________________________________
AliCFVertexingHFCascade& AliCFVertexingHFCascade::operator=(const AliCFVertexingHFCascade& c)
{
  // operator =
 
  if  (this != &c) {

    AliCFVertexingHF::operator=(c);
   
  }
  return *this;
}

//__________________________________________
Bool_t AliCFVertexingHFCascade::SetRecoCandidateParam(AliAODRecoDecayHF *recoCand)
{
  // set the AliAODRecoDecay candidate
  
  Bool_t bSignAssoc = kFALSE;
 
  fRecoCandidate = recoCand;
  AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)recoCand;

  if (!fRecoCandidate) {
    AliError("fRecoCandidate not found, problem in assignement\n");
    return bSignAssoc;
  }
  
  if ( fRecoCandidate->GetPrimaryVtx()) AliDebug(3,"fReco Candidate has a pointer to PrimVtx\n");
  //if (recoCand->GetPrimaryVtx()) printf("Reco Cand has a pointer to PrimVtx\n");
  
  //Int_t pdgCand = 413;

  Int_t pdgDgDStartoD0pi[2]={421,211};
  Int_t pdgDgD0toKpi[2]={321,211};

  Int_t nentries = fmcArray->GetEntriesFast();

  AliDebug(3,Form("nentries = %d\n", nentries));
 
  Int_t mcLabel =  dstarD0pi->MatchToMC(413,421,pdgDgDStartoD0pi,pdgDgD0toKpi,fmcArray); 
  
  if (mcLabel == -1) return bSignAssoc;

  if (fRecoCandidate->NumberOfFakeDaughters()>0){
	  fFake = 0;    // fake candidate
	  if (fFakeSelection==1) return bSignAssoc;
  }
  if (fRecoCandidate->NumberOfFakeDaughters()==0){
	  fFake = 2;    // non-fake candidate
	  if (fFakeSelection==2) return bSignAssoc;
  }
  
  SetMCLabel(mcLabel);
  fmcPartCandidate = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fmcLabel)); 

  if (!fmcPartCandidate){
    AliDebug(3,"No part candidate");
    return bSignAssoc;
  }
 
  bSignAssoc = kTRUE;
  return bSignAssoc;
}

//______________________________________________
Bool_t AliCFVertexingHFCascade::GetGeneratedValuesFromMCParticle(Double_t* vectorMC) 
{
  // 
  // collecting all the necessary info (pt, y, cosThetaStar, ptPi, ptKa, cT) from MC particle
  //
	
	Bool_t bGenValues = kFALSE;
	
	
	Int_t daughter0ds = fmcPartCandidate->GetDaughter(0);
	Int_t daughter1ds = fmcPartCandidate->GetDaughter(1);

        //the D0
	AliAODMCParticle* mcPartDaughterD0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0ds));
	AliAODMCParticle* mcPartDaughterPis = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1ds));

	if(!mcPartDaughterD0 || !mcPartDaughterPis) return kFALSE;

	Double_t vtx1[3] = {0,0,0};   // primary vertex		
	Double_t vtx2daughter0[3] = {0,0,0};   // secondary vertex from daughter 0
	Double_t vtx2daughter1[3] = {0,0,0};   // secondary vertex from daughter 1
	fmcPartCandidate->XvYvZv(vtx1);  // cm

	//D0 daughters
	Int_t daughter0 = mcPartDaughterD0->GetDaughter(0);
	Int_t daughter1 = mcPartDaughterD0->GetDaughter(1);

	AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0)); //D0
	AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1)); //pis

	if(!mcPartDaughter0 || !mcPartDaughter1) return kFALSE;

	// getting vertex from daughters
	mcPartDaughter0->XvYvZv(vtx2daughter0);  // cm
	mcPartDaughter1->XvYvZv(vtx2daughter1);  //cm
	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) {
	  AliError("Daughters have different secondary vertex, skipping the track");
	  return bGenValues;
	}
	
	Int_t nprongs = 2;
	Short_t charge = 0;
	// always instantiate the AliAODRecoDecay with the positive daughter first, the negative second
	AliAODMCParticle* positiveDaugh = mcPartDaughter0;
	AliAODMCParticle* negativeDaugh = mcPartDaughter1;
	if (mcPartDaughter0->GetPdgCode()<0 && mcPartDaughter1->GetPdgCode()>0){
		// inverting in case the positive daughter is the second one
		positiveDaugh = mcPartDaughter1;
		negativeDaugh = mcPartDaughter0;
	}
	// getting the momentum from the daughters
	Double_t px[2] = {positiveDaugh->Px(), negativeDaugh->Px()};		
	Double_t py[2] = {positiveDaugh->Py(), negativeDaugh->Py()};		
	Double_t pz[2] = {positiveDaugh->Pz(), negativeDaugh->Pz()};
	
	Double_t d0[2] = {0.,0.};		
	
	AliAODRecoDecayHF* decay = new AliAODRecoDecayHF(vtx1,vtx2daughter0,nprongs,charge,px,py,pz,d0);
	
	Double_t cosThetaStar = 0.;
	Double_t cosThetaStarD0 = 0.;
	Double_t cosThetaStarD0bar = 0.;
	cosThetaStarD0 = decay->CosThetaStar(1,421,211,321);
	cosThetaStarD0bar = decay->CosThetaStar(0,421,321,211);
	if (mcPartDaughterD0->GetPdgCode() == 421){  // D0
	  AliDebug(3, Form("D0, with pdgprong0 = %d, pdgprong1 = %d",mcPartDaughter0->GetPdgCode(),mcPartDaughter1->GetPdgCode()));
	  cosThetaStar = cosThetaStarD0;
	}
	else if (mcPartDaughterD0->GetPdgCode() == -421){  // D0bar{
	  AliDebug(3, Form("D0bar, with pdgprong0 = %d, pdgprong1 = %d",mcPartDaughter0->GetPdgCode(),mcPartDaughter1->GetPdgCode()));
	  cosThetaStar = cosThetaStarD0bar;
	}
	else{
	  AliWarning("There are problems!! particle was expected to be either a D0 or a D0bar, check...");
	  return vectorMC;
	}
	if (cosThetaStar < -1 || cosThetaStar > 1) {
	  AliWarning("Invalid value for cosine Theta star, returning");
	  return bGenValues;
	}
	
	Double_t vectorD0[2] ={0.,0.};

	// evaluate the correct cascade
	if (!EvaluateIfD0toKpi(mcPartDaughterD0,vectorD0)) {
	  AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!");
	  return bGenValues;  
	}	

	//ct
	Double_t cT = decay->Ct(421);
	// get the pT of the daughters
	Double_t pTD0 = 0.;
	Double_t pTpi = 0.;
	
	if (TMath::Abs(fmcPartCandidate->GetPdgCode()) == 413) {
		pTD0 = mcPartDaughterD0->Pt();
		pTpi = mcPartDaughterPis->Pt();
	}

	
	vectorMC[0] = fmcPartCandidate->Pt();
	vectorMC[1] = fmcPartCandidate->Y() ;
	vectorMC[2] = cosThetaStar ;
	vectorMC[3] = vectorD0[0]; 
	vectorMC[4] = vectorD0[1];
	vectorMC[5] = cT*1.E4 ;  // in micron
	vectorMC[6] = 0.;   // dummy value, meaningless in MC
	vectorMC[7] = 0.;   // dummy value, meaningless in MC, in micron
	vectorMC[8] = 0.;   // dummy value, meaningless in MC, in micron
	vectorMC[9] = -100000.; // dummy value, meaningless in MC, in micron^2
	vectorMC[10] = 1.01;    // dummy value, meaningless in MC
	vectorMC[11] = fmcPartCandidate->Phi(); 
	vectorMC[12] = fzMCVertex;    // z of reconstructed of primary vertex
	vectorMC[13] = fCentValue; // reconstructed centrality
	vectorMC[14] = 1.;           // always filling with 1 at MC level 

	delete decay;
	bGenValues = kTRUE;
	return bGenValues;
}
//____________________________________________
Bool_t AliCFVertexingHFCascade::GetRecoValuesFromCandidate(Double_t *vectorReco) const
{ 
  // read the variables for the container

  Bool_t bFillRecoValues=kFALSE;
  
  //Get the D* and the D0 from D*
  AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)fRecoCandidate;
  AliAODRecoDecayHF2Prong* d0toKpi = (AliAODRecoDecayHF2Prong*)dstarD0pi->Get2Prong();
  

  if (dstarD0pi->GetPrimaryVtx())printf("dstarD0pi has primary vtx\n");
  if (fRecoCandidate->GetPrimaryVtx())printf("fRecoCandidateDstar has primary vtx\n");

  Double_t pt =  dstarD0pi->Pt();
  Double_t rapidity =  dstarD0pi->YDstar();
  Double_t invMass=0.;
  Double_t cosThetaStar = 9999.;
  Double_t pTpi = 0.;
  Double_t pTK = 0.;
  Double_t dca = d0toKpi->GetDCA();
  Double_t d0pi = 0.;
  Double_t d0K = 0.;
  Double_t d0xd0 = d0toKpi->Prodd0d0();
  Double_t cosPointingAngle = d0toKpi->CosPointingAngle();
  Double_t phi = dstarD0pi->Phi();

  Int_t pdgCode = fmcPartCandidate->GetPdgCode();
 
  if (pdgCode > 0){
    cosThetaStar = d0toKpi->CosThetaStarD0();
    pTpi = d0toKpi->PtProng(0);
    pTK = d0toKpi->PtProng(1);
    d0pi = d0toKpi->Getd0Prong(0);
    d0K = d0toKpi->Getd0Prong(1);
    invMass=d0toKpi->InvMassD0();
  }
  else {
    cosThetaStar = d0toKpi->CosThetaStarD0bar();
    pTpi = d0toKpi->PtProng(1);
    pTK = d0toKpi->PtProng(0);
    d0pi = d0toKpi->Getd0Prong(1);
    d0K = d0toKpi->Getd0Prong(0);
    invMass= d0toKpi->InvMassD0bar();
  }
  
  Double_t cT = d0toKpi->CtD0();
  
  vectorReco[0] = pt;
  vectorReco[1] = rapidity;
  vectorReco[2] = cosThetaStar;
  vectorReco[3] = pTpi;
  vectorReco[4] = pTK;
  vectorReco[5] = cT*1.E4;  // in micron
  vectorReco[6] = dca*1.E4;  // in micron
  vectorReco[7] = d0pi*1.E4;  // in micron
  vectorReco[8] = d0K*1.E4;  // in micron
  vectorReco[9] = d0xd0*1.E8;  // in micron^2
  vectorReco[10] = cosPointingAngle;  // in micron
  vectorReco[11] = phi;  
  vectorReco[12] = fzPrimVertex;    // z of reconstructed of primary vertex
  vectorReco[13] = fCentValue;
  vectorReco[14] = fFake;      // whether the reconstructed candidate was a fake (fFake = 0) or not (fFake = 2) 

  bFillRecoValues = kTRUE;

  return bFillRecoValues;
}


//_____________________________________________________________
Bool_t AliCFVertexingHFCascade::CheckMCChannelDecay() const
{ 
  // check the required decay channel

  Bool_t checkCD = kFALSE;

  
  Int_t daughter0 = fmcPartCandidate->GetDaughter(0);
  Int_t daughter1 = fmcPartCandidate->GetDaughter(1);
  AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter0));
  AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughter1));

  if (!mcPartDaughter0 || !mcPartDaughter1) {
    AliDebug (2,"Problems in the MC Daughters\n");
    return checkCD;
  }

  if (!(TMath::Abs(mcPartDaughter0->GetPdgCode())==421 &&
	TMath::Abs(mcPartDaughter1->GetPdgCode())==211) && 
      !(TMath::Abs(mcPartDaughter0->GetPdgCode())==211 &&
	TMath::Abs(mcPartDaughter1->GetPdgCode())==421)) {
    AliDebug(2, "The D0 MC doesn't come from a Kpi decay, skipping!!");
    return checkCD;  
  }
  
  Double_t vectorD0[2] ={0.,0.};

  // D* is a cascade ...evaluate the correct cascade
  if (!EvaluateIfD0toKpi(mcPartDaughter0,vectorD0)) {
    AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!");
    return checkCD;  
  }
   
  checkCD = kTRUE;
  return checkCD;
  
}

//__________________________________________
Bool_t AliCFVertexingHFCascade::EvaluateIfD0toKpi(AliAODMCParticle* neutralDaugh, Double_t* vectorD0)const
{  
  //
  // chack wether D0 is decaing into kpi
  //
  
  Bool_t isHadronic = kFALSE;
  
  Int_t daughterD00 = neutralDaugh->GetDaughter(0);
  Int_t daughterD01 = neutralDaugh->GetDaughter(1);
  
  AliDebug(2, Form("daughter0 = %d and daughter1 = %d",daughterD00,daughterD01));
  if (daughterD00 == 0 || daughterD01 == 0) {
    AliDebug(2, "Error! the D0 MC doesn't have correct daughters!!");
    return isHadronic;  
  }
  
  if (TMath::Abs(daughterD01 - daughterD00) != 1) { // should be everytime true - see PDGdatabooklet
    AliDebug(2, "The D0 MC doesn't come from a 2-prong decay, skipping!!");
    return isHadronic;  
  }
  
  AliAODMCParticle* mcPartDaughterD00 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD00));
  AliAODMCParticle* mcPartDaughterD01 = dynamic_cast<AliAODMCParticle*>(fmcArray->At(daughterD01));
  if (!mcPartDaughterD00 || !mcPartDaughterD01) {
    AliWarning("D0 MC analysis: At least one Daughter Particle not found in tree, skipping"); 
    return isHadronic;  
  }
  
  if (!(TMath::Abs(mcPartDaughterD00->GetPdgCode())==321 &&
	TMath::Abs(mcPartDaughterD01->GetPdgCode())==211) && 
      !(TMath::Abs(mcPartDaughterD00->GetPdgCode())==211 &&
	TMath::Abs(mcPartDaughterD01->GetPdgCode())==321)) {
    AliDebug(2, "The D0 MC doesn't come from a Kpi decay, skipping!!");
    return isHadronic;  
  }
  
  Double_t pTD0pi = 0;
  Double_t pTD0K = 0;
  
  
  if (TMath::Abs(mcPartDaughterD00->GetPdgCode()) == 211) {
    pTD0pi = mcPartDaughterD00->Pt();
    pTD0K = mcPartDaughterD01->Pt();
  }
  else {
    pTD0pi = mcPartDaughterD01->Pt();
    pTD0K  = mcPartDaughterD00->Pt();
  }
  
  isHadronic = kTRUE;
  
  vectorD0[0] = pTD0pi;
  vectorD0[1] = pTD0K;
 
  return isHadronic;

}

//___________________________________________________________

void AliCFVertexingHFCascade::SetPtAccCut(Float_t* ptAccCut)
{
	//
	// setting the pt cut to be used in the Acceptance steps (MC+Reco)
	//

	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");
	if (fProngs>0){
		for (Int_t iP=0; iP<fProngs; iP++){
			fPtAccCut[iP]=ptAccCut[iP];
		}
	}
	return;
}		


//___________________________________________________________

void AliCFVertexingHFCascade::SetEtaAccCut(Float_t* etaAccCut)
{
	//
	// setting the eta cut to be used in the Acceptance steps (MC+Reco)
	//

	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");
	if (fProngs>0){
		for (Int_t iP=0; iP<fProngs; iP++){
			fEtaAccCut[iP]=etaAccCut[iP];
		}
	}
	return;
}	
//___________________________________________________________

void AliCFVertexingHFCascade::SetAccCut(Float_t* ptAccCut, Float_t* etaAccCut)
{
	//
	// setting the pt and eta cut to be used in the Acceptance steps (MC+Reco)
	//

	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");
	if (fProngs>0){
		for (Int_t iP=0; iP<fProngs; iP++){
			fPtAccCut[iP]=ptAccCut[iP];
			fEtaAccCut[iP]=etaAccCut[iP];
		}
	}
	return;
}		

//___________________________________________________________

void AliCFVertexingHFCascade::SetAccCut()
{
	//
	// setting the pt and eta cut to be used in the Acceptance steps (MC+Reco)
	//
  
  AliAODMCParticle* mcPartDaughter = dynamic_cast<AliAODMCParticle*>(fmcArray->At(fLabelArray[2]));  // should be the soft pion...  
  if(!mcPartDaughter) return;
  Int_t mother =  mcPartDaughter->GetMother();
  AliAODMCParticle* mcMother = dynamic_cast<AliAODMCParticle*>(fmcArray->At(mother)); 
  if(!mcMother) return;

  if (TMath::Abs(mcPartDaughter->GetPdgCode())!= 211 || TMath::Abs(mcMother->GetPdgCode())!=413){
    AliFatal("Apparently the soft pion is not in the third position, causing a crash!!");
  }	         
  if (fProngs>0){
    for (Int_t iP=0; iP<fProngs-1; iP++){
      fPtAccCut[iP]=0.1;
      fEtaAccCut[iP]=0.9;
    }
    fPtAccCut[2]=0.06;  // soft pion
    fEtaAccCut[2]=0.9;  // soft pion
  }
  return;
}		

//_____________________________________________________________
Double_t AliCFVertexingHFCascade::GetEtaProng(Int_t iProng) const 
{
	//
	// getting eta of the prong - overload the mother class method
	//

 if (fRecoCandidate){
   
   AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)fRecoCandidate;

   Double_t etaProng =-9999;
    if(iProng==0) etaProng =dstarD0pi->Get2Prong()->EtaProng(0);
    if(iProng==1) etaProng =dstarD0pi->Get2Prong()->EtaProng(1);
    if(iProng==2) etaProng =dstarD0pi->EtaProng(1);
    
    return etaProng;
    
  }
  return 999999;    
}
//_____________________________________________________________
Double_t AliCFVertexingHFCascade::GetPtProng(Int_t iProng) const 
{
	//
	// getting pt of the prong
	//
  
  if (fRecoCandidate){

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