[u/mrichter/AliRoot.git] / PWG3 / AliAODRecoDecayHF4Prong.cxx

/**************************************************************************
 * Copyright(c) 1998-2006, 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.                  *
 **************************************************************************/

/////////////////////////////////////////////////////////////
//
// Base class for AOD reconstructed heavy-flavour 4-prong decay
//
// Authors: G.E.Bruno Giuseppe.Bruno@to.infn.it, R.Romita Rossella.Romita@ba.infn.it
/////////////////////////////////////////////////////////////

#include <TDatabasePDG.h>
#include "AliAODRecoDecayHF.h"
#include "AliAODRecoDecayHF4Prong.h"
#include "TRandom.h" // for the time being

ClassImp(AliAODRecoDecayHF4Prong)

//--------------------------------------------------------------------------
AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong() :
  AliAODRecoDecayHF(), 
  //fSigmaVert(0),
  fDist12toPrim(0),
  fDist23toPrim(0),
  fDist14toPrim(0),
  fDist34toPrim(0)
{
  //
  // Default Constructor
  //
}
//--------------------------------------------------------------------------
AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2,
						 Double_t *px,Double_t *py,Double_t *pz,
						 Double_t *d0,Double_t *d0err,
						 Double_t *dca, //Double_t sigvert,
						 Double_t dist12,Double_t dist23,
						 Double_t dist14,Double_t dist34,
						 Short_t charge) :
  AliAODRecoDecayHF(vtx2,4,charge,px,py,pz,d0,d0err),
  // fSigmaVert(sigvert),
  fDist12toPrim(dist12),
  fDist23toPrim(dist23),
  fDist14toPrim(dist14),
  fDist34toPrim(dist34)
{
  //
  // Constructor with AliAODVertex for decay vertex
  //
  Double_t dcafloat[6];
  for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i];
  SetDCAs(6,dcafloat);
}
//--------------------------------------------------------------------------
AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2,
						 Double_t *d0,Double_t *d0err,
						 Double_t *dca, //Double_t sigvert,
						 Double_t dist12,Double_t dist23, 
						 Double_t dist14,Double_t dist34, 
						 Short_t charge) :
  AliAODRecoDecayHF(vtx2,4,charge,d0,d0err),
  //fSigmaVert(sigvert),
  fDist12toPrim(dist12),
  fDist23toPrim(dist23),
  fDist14toPrim(dist14),
  fDist34toPrim(dist34)
{
  //
  // Constructor with AliAODVertex for decay vertex and without prongs momenta
  //
  Double_t dcafloat[6];
  for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i];
  SetDCAs(6,dcafloat);
}
//--------------------------------------------------------------------------
AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(const AliAODRecoDecayHF4Prong &source) :
  AliAODRecoDecayHF(source),
  //fSigmaVert(source.fSigmaVert),
  fDist12toPrim(source.fDist12toPrim),
  fDist23toPrim(source.fDist23toPrim),
  fDist14toPrim(source.fDist14toPrim),
  fDist34toPrim(source.fDist34toPrim)
{
  //
  // Copy constructor
  //
}
//--------------------------------------------------------------------------
AliAODRecoDecayHF4Prong &AliAODRecoDecayHF4Prong::operator=(const AliAODRecoDecayHF4Prong &source)
{
  //
  // assignment operator
  //
  if(&source == this) return *this;
  fOwnPrimaryVtx = source.fOwnPrimaryVtx;
  fSecondaryVtx = source.fSecondaryVtx;
  fCharge = source.fCharge;
  fNProngs = source.fNProngs;
  fNDCA = source.fNDCA;
  fNPID = source.fNPID;
  fEventNumber = source.fEventNumber;
  fRunNumber = source.fRunNumber;
  fDist12toPrim= source.fDist12toPrim;
  fDist23toPrim= source.fDist23toPrim;
  fDist14toPrim= source.fDist14toPrim;
  fDist34toPrim= source.fDist34toPrim;
  //fSigmaVert= source.fSigmaVert;
  if(source.GetNProngs()>0) {
    fd0 = new Double_t[GetNProngs()];
    fd0err = new Double_t[GetNProngs()];
    memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t));
    memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t));
    if(source.fPx) {
      fPx = new Double_t[GetNProngs()];
      fPy = new Double_t[GetNProngs()];
      fPz = new Double_t[GetNProngs()];
      memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t));
      memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t));
      memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t));
    }
    if(source.fPID) {
      fPID = new Double_t[5*GetNProngs()];
      memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t));
    }
    if(source.fDCA) {
      fDCA = new Double32_t[GetNProngs()*(GetNProngs()-1)/2];
      memcpy(fDCA,source.fDCA,(GetNProngs()*(GetNProngs()-1)/2)*sizeof(Float_t));
    }
  }
  return *this;
}
//--------------------------------------------------------------------------
Bool_t AliAODRecoDecayHF4Prong::SelectD0(const Double_t *cuts,Int_t &okD0,Int_t &okD0bar)
  const {
//
// This function compares the D0 with a set of cuts:
// 
// to be implemented 
//
// cuts[1] = ... 
// cuts[2] = ...
// cuts[3] = ...
// cuts[4] = ...
//
// If candidate D0 does not pass the cuts return kFALSE
//

  okD0=0; okD0bar=0;
  Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
  Double_t mD0=InvMassD0();
  if(TMath::Abs(mD0-mD0PDG)>cuts[0]) return kFALSE;

  //single track
  //if(TMath::Abs(PtProng(2)) < cuts[2] || TMath::Abs(Getd0Prong(2))<cuts[4])return kFALSE;//Pion2

  //DCA
  //for(Int_t i=0;i<3;i++) if(cuts[11]>0 && GetDCA(i)>cuts[11])return kFALSE;

  //2track cuts
  //if(fDist12toPrim<cuts[5] || fDist23toPrim<cuts[5])return kFALSE;
  //if(Getd0Prong(0)*Getd0Prong(1)<0 && Getd0Prong(2)*Getd0Prong(1)<0)return kFALSE;

  //sec vert
  //if(fSigmaVert>cuts[6])return kFALSE;

  //if(DecayLength()<cuts[7])return kFALSE;
  
  return kFALSE; // for the time being 
  // return kTRUE; // after implementation 
}
Commit	Line	Data
3244eeed	1	/**************************************************************************
	2	* Copyright(c) 1998-2006, 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	//
	18	// Base class for AOD reconstructed heavy-flavour 4-prong decay
	19	//
	20	// Authors: G.E.Bruno Giuseppe.Bruno@to.infn.it, R.Romita Rossella.Romita@ba.infn.it
	21	/////////////////////////////////////////////////////////////
	22
	23	#include <TDatabasePDG.h>
	24	#include "AliAODRecoDecayHF.h"
	25	#include "AliAODRecoDecayHF4Prong.h"
	26	#include "TRandom.h" // for the time being
	27
	28	ClassImp(AliAODRecoDecayHF4Prong)
	29
	30	//--------------------------------------------------------------------------
	31	AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong() :
	32	AliAODRecoDecayHF(),
	33	//fSigmaVert(0),
	34	fDist12toPrim(0),
	35	fDist23toPrim(0),
	36	fDist14toPrim(0),
	37	fDist34toPrim(0)
	38	{
	39	//
	40	// Default Constructor
	41	//
	42	}
	43	//--------------------------------------------------------------------------
	44	AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2,
	45	Double_t px,Double_t py,Double_t *pz,
	46	Double_t d0,Double_t d0err,
	47	Double_t *dca, //Double_t sigvert,
	48	Double_t dist12,Double_t dist23,
	49	Double_t dist14,Double_t dist34,
	50	Short_t charge) :
	51	AliAODRecoDecayHF(vtx2,4,charge,px,py,pz,d0,d0err),
	52	// fSigmaVert(sigvert),
	53	fDist12toPrim(dist12),
	54	fDist23toPrim(dist23),
	55	fDist14toPrim(dist14),
	56	fDist34toPrim(dist34)
	57	{
	58	//
	59	// Constructor with AliAODVertex for decay vertex
	60	//
057c80d4	61	Double_t dcafloat[6];
3244eeed	62	for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i];
	63	SetDCAs(6,dcafloat);
	64	}
	65	//--------------------------------------------------------------------------
	66	AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2,
	67	Double_t d0,Double_t d0err,
	68	Double_t *dca, //Double_t sigvert,
	69	Double_t dist12,Double_t dist23,
	70	Double_t dist14,Double_t dist34,
	71	Short_t charge) :
	72	AliAODRecoDecayHF(vtx2,4,charge,d0,d0err),
	73	//fSigmaVert(sigvert),
	74	fDist12toPrim(dist12),
	75	fDist23toPrim(dist23),
	76	fDist14toPrim(dist14),
	77	fDist34toPrim(dist34)
	78	{
	79	//
	80	// Constructor with AliAODVertex for decay vertex and without prongs momenta
	81	//
057c80d4	82	Double_t dcafloat[6];
3244eeed	83	for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i];
	84	SetDCAs(6,dcafloat);
	85	}
	86	//--------------------------------------------------------------------------
	87	AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(const AliAODRecoDecayHF4Prong &source) :
	88	AliAODRecoDecayHF(source),
	89	//fSigmaVert(source.fSigmaVert),
	90	fDist12toPrim(source.fDist12toPrim),
	91	fDist23toPrim(source.fDist23toPrim),
	92	fDist14toPrim(source.fDist14toPrim),
	93	fDist34toPrim(source.fDist34toPrim)
	94	{
	95	//
	96	// Copy constructor
	97	//
	98	}
	99	//--------------------------------------------------------------------------
	100	AliAODRecoDecayHF4Prong &AliAODRecoDecayHF4Prong::operator=(const AliAODRecoDecayHF4Prong &source)
	101	{
	102	//
	103	// assignment operator
	104	//
	105	if(&source == this) return *this;
	106	fOwnPrimaryVtx = source.fOwnPrimaryVtx;
	107	fSecondaryVtx = source.fSecondaryVtx;
	108	fCharge = source.fCharge;
	109	fNProngs = source.fNProngs;
	110	fNDCA = source.fNDCA;
	111	fNPID = source.fNPID;
	112	fEventNumber = source.fEventNumber;
	113	fRunNumber = source.fRunNumber;
	114	fDist12toPrim= source.fDist12toPrim;
	115	fDist23toPrim= source.fDist23toPrim;
	116	fDist14toPrim= source.fDist14toPrim;
	117	fDist34toPrim= source.fDist34toPrim;
	118	//fSigmaVert= source.fSigmaVert;
	119	if(source.GetNProngs()>0) {
	120	fd0 = new Double_t[GetNProngs()];
	121	fd0err = new Double_t[GetNProngs()];
	122	memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t));
	123	memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t));
	124	if(source.fPx) {
	125	fPx = new Double_t[GetNProngs()];
	126	fPy = new Double_t[GetNProngs()];
	127	fPz = new Double_t[GetNProngs()];
	128	memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t));
	129	memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t));
	130	memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t));
	131	}
	132	if(source.fPID) {
	133	fPID = new Double_t[5*GetNProngs()];
	134	memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t));
	135	}
	136	if(source.fDCA) {
057c80d4	137	fDCA = new Double32_t[GetNProngs()*(GetNProngs()-1)/2];
3244eeed	138	memcpy(fDCA,source.fDCA,(GetNProngs()(GetNProngs()-1)/2)sizeof(Float_t));
	139	}
	140	}
	141	return *this;
	142	}
	143	//--------------------------------------------------------------------------
	144	Bool_t AliAODRecoDecayHF4Prong::SelectD0(const Double_t *cuts,Int_t &okD0,Int_t &okD0bar)
	145	const {
	146	//
	147	// This function compares the D0 with a set of cuts:
	148	//
	149	// to be implemented
	150	//
	151	// cuts[1] = ...
	152	// cuts[2] = ...
	153	// cuts[3] = ...
	154	// cuts[4] = ...
	155	//
	156	// If candidate D0 does not pass the cuts return kFALSE
	157	//
	158
13977a79	159	okD0=0; okD0bar=0;
3244eeed	160	Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
	161	Double_t mD0=InvMassD0();
	162	if(TMath::Abs(mD0-mD0PDG)>cuts[0]) return kFALSE;
	163
	164	//single track
	165	//if(TMath::Abs(PtProng(2)) < cuts[2] \|\| TMath::Abs(Getd0Prong(2))<cuts[4])return kFALSE;//Pion2
	166
	167	//DCA
	168	//for(Int_t i=0;i<3;i++) if(cuts[11]>0 && GetDCA(i)>cuts[11])return kFALSE;
	169
	170	//2track cuts
	171	//if(fDist12toPrim<cuts[5] \|\| fDist23toPrim<cuts[5])return kFALSE;
	172	//if(Getd0Prong(0)Getd0Prong(1)<0 && Getd0Prong(2)Getd0Prong(1)<0)return kFALSE;
	173
	174	//sec vert
	175	//if(fSigmaVert>cuts[6])return kFALSE;
	176
	177	//if(DecayLength()<cuts[7])return kFALSE;
	178
	179	return kFALSE; // for the time being
	180	// return kTRUE; // after implementation
	181	}