[u/mrichter/AliRoot.git] / STEER / AliAODVertex.cxx

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

/* $Id$ */

//-------------------------------------------------------------------------
//     AOD track base class
//     Base class for Analysis Object Data
//     Generic version
//     Author: Markus Oldenburg, CERN
//     Inheritance from AliVVertex: A. Dainese
//-------------------------------------------------------------------------

#include "AliAODVertex.h"
#include "AliAODTrack.h"

ClassImp(AliAODVertex)

//______________________________________________________________________________
AliAODVertex::AliAODVertex() : 
  AliVVertex(),
  fChi2perNDF(-999.),
  fID(-1),
  fType(kUndef),
  fCovMatrix(NULL),
  fParent(),
  fDaughters()
  {
  // default constructor

  fPosition[0] = fPosition[1] = fPosition[2] = -999.;
}

//______________________________________________________________________________
AliAODVertex::AliAODVertex(const Double_t position[3], 
			   const Double_t covMatrix[6],
			   Double_t  chi2perNDF,
			   TObject  *parent,
			   Short_t id,
			   Char_t vtype) :
  AliVVertex(),
  fChi2perNDF(chi2perNDF),
  fID(id),
  fType(vtype),
  fCovMatrix(NULL),
  fParent(parent),
  fDaughters()
{
  // constructor

  SetPosition(position);
  if (covMatrix) SetCovMatrix(covMatrix);
}

//______________________________________________________________________________
AliAODVertex::AliAODVertex(const Float_t position[3], 
			   const Float_t  covMatrix[6],
			   Double_t  chi2perNDF,
			   TObject  *parent,
			   Short_t id,
			   Char_t vtype) :

  AliVVertex(),
  fChi2perNDF(chi2perNDF),
  fID(id),
  fType(vtype),
  fCovMatrix(NULL),
  fParent(parent),
  fDaughters()
{
  // constructor

  SetPosition(position);
  if (covMatrix) SetCovMatrix(covMatrix);
}

//______________________________________________________________________________
AliAODVertex::AliAODVertex(const Double_t position[3], 
			   Double_t  chi2perNDF,
			   Char_t vtype) :
  AliVVertex(),
  fChi2perNDF(chi2perNDF),
  fID(-1),
  fType(vtype),
  fCovMatrix(NULL),
  fParent(),
  fDaughters()
{
  // constructor without covariance matrix

  SetPosition(position);  
}

//______________________________________________________________________________
AliAODVertex::AliAODVertex(const Float_t position[3], 
			   Double_t  chi2perNDF,
			   Char_t vtype) :
  AliVVertex(),
  fChi2perNDF(chi2perNDF),
  fID(-1),
  fType(vtype),
  fCovMatrix(NULL),
  fParent(),
  fDaughters()
{
  // constructor without covariance matrix

  SetPosition(position);  
}

//______________________________________________________________________________
AliAODVertex::~AliAODVertex() 
{
  // Destructor

  delete fCovMatrix;
}

//______________________________________________________________________________
AliAODVertex::AliAODVertex(const AliAODVertex& vtx) :
  AliVVertex(vtx),
  fChi2perNDF(vtx.fChi2perNDF),
  fID(vtx.fID),
  fType(vtx.fType),
  fCovMatrix(NULL),
  fParent(vtx.fParent),
  fDaughters(vtx.fDaughters)
{
  // Copy constructor.
  
  for (int i = 0; i < 3; i++) 
    fPosition[i] = vtx.fPosition[i];

  if (vtx.fCovMatrix) fCovMatrix=new AliAODRedCov<3>(*vtx.fCovMatrix);
}

//______________________________________________________________________________
AliAODVertex& AliAODVertex::operator=(const AliAODVertex& vtx) 
{
  // Assignment operator
  if (this != &vtx) {

    // name and type
    AliVVertex::operator=(vtx);

    //momentum
    for (int i = 0; i < 3; i++) 
      fPosition[i] = vtx.fPosition[i];
    
    fChi2perNDF = vtx.fChi2perNDF;
    fID = vtx.fID;
    fType = vtx.fType;

    //covariance matrix
    delete fCovMatrix;
    fCovMatrix = NULL;   
    if (vtx.fCovMatrix) fCovMatrix=new AliAODRedCov<3>(*vtx.fCovMatrix);
    
    //other stuff
    fParent = vtx.fParent;
    fDaughters = vtx.fDaughters;
  }
  
  return *this;
}

//______________________________________________________________________________
void AliAODVertex::AddDaughter(TObject *daughter)
{
  // Add reference to daughter track

  if (fDaughters.GetEntries()==0) {
    TRefArray* arr = &fDaughters;
    new(arr)TRefArray(TProcessID::GetProcessWithUID(daughter));  	
  }
  fDaughters.Add(daughter);	

  return;
}

//______________________________________________________________________________
template <class T> void AliAODVertex::GetSigmaXYZ(T sigma[3]) const
{
  // Return errors on vertex position in thrust frame
  
  if(fCovMatrix) {
    sigma[0]=fCovMatrix[3]; //GetCovXZ
    sigma[1]=fCovMatrix[4]; //GetCovYZ
    sigma[2]=fCovMatrix[5]; //GetCovZZ
  } else 
    sigma[0]=sigma[1]=sigma[2]=-999.;

  /*
  for (int i = 0, j = 6; i < 3; i++) {
    j -= i+1;
    sigma[2-i] = fCovMatrix ? TMath::Sqrt(fCovMatrix[j]) : -999.;
  }
  */
}

//______________________________________________________________________________
Int_t AliAODVertex::GetNContributors() const 
{
  // Returns the number of tracks used to fit this vertex.
  
  Int_t cont = 0;

  for (Int_t iDaug = 0; iDaug < GetNDaughters(); iDaug++) {
    if (((AliAODTrack*)fDaughters.At(iDaug))->GetUsedForVtxFit()) cont++;
  }

  return cont;
}

//______________________________________________________________________________
Bool_t AliAODVertex::HasDaughter(TObject *daughter) const 
{
  // Checks if the given daughter (particle) is part of this vertex.

  TRefArrayIter iter(&fDaughters);
  while (TObject *daugh = iter.Next()) {
    if (daugh == daughter) return kTRUE;
  }
  return kFALSE;
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixXX(Double_t phi, Double_t theta) const
{
  // XX term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  Double_t ct = TMath::Cos(theta);
  Double_t st = TMath::Sin(theta);
  return
     covMatrix[0]*cp*cp*ct*ct  // GetCovXX
    +covMatrix[1]*2.*cp*sp*ct*ct  // GetCovXY
    +covMatrix[3]*2.*cp*ct*st  // GetCovXZ
    +covMatrix[2]*sp*sp*ct*ct  // GetCovYY
    +covMatrix[4]*2.*sp*ct*st  // GetCovYZ
    +covMatrix[5]*st*st;  // GetCovZZ
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixXY(Double_t phi, Double_t theta) const
{
  // XY term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  Double_t ct = TMath::Cos(theta);
  Double_t st = TMath::Sin(theta);
  return 
    -covMatrix[0]*cp*sp*ct  // GetCovXX
    +covMatrix[1]*ct*(cp*cp-sp*sp)  // GetCovXY
    -covMatrix[3]*sp*st  // GetCovXZ
    +covMatrix[2]*cp*sp*ct  // GetCovYY
    +covMatrix[4]*cp*st;  // GetCovYZ
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixXZ(Double_t phi, Double_t theta) const
{
  // XZ term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  Double_t ct = TMath::Cos(theta);
  Double_t st = TMath::Sin(theta);
  return 
    -covMatrix[0]*cp*cp*ct*st  // GetCovXX
    -covMatrix[1]*2.*cp*sp*ct*st  // GetCovXY
    +covMatrix[3]*cp*(ct*ct-st*st)  // GetCovXZ
    -covMatrix[2]*sp*sp*ct*st  // GetCovYY
    +covMatrix[4]*sp*(ct*ct-st*st)  // GetCovYZ
    +covMatrix[5]*ct*st;  // GetCovZZ
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixYY(Double_t phi) const
{
  // YY term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  return
     covMatrix[0]*sp*sp  // GetCovXX
    -covMatrix[1]*2.*cp*sp  // GetCovXY
    +covMatrix[2]*cp*cp;  // GetCovYY
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixYZ(Double_t phi, Double_t theta) const
{
  // YZ term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  Double_t ct = TMath::Cos(theta);
  Double_t st = TMath::Sin(theta);
  return 
     covMatrix[0]*cp*sp*st  // GetCovXX
    +covMatrix[1]*st*(sp*sp-cp*cp)  // GetCovXY
    -covMatrix[3]*sp*ct  // GetCovXZ
    -covMatrix[2]*cp*sp*st  // GetCovYY
    +covMatrix[4]*cp*ct;  // GetCovYZ
}

//______________________________________________________________________________
Double_t AliAODVertex::RotatedCovMatrixZZ(Double_t phi, Double_t theta) const
{
  // ZZ term of covariance matrix after rotation by phi around z-axis
  // and, then, by theta around new y-axis

  if (!fCovMatrix) {
    //AliFatal("Covariance matrix not set");
    return -999.;
  }

  Double_t covMatrix[6];

  GetCovMatrix(covMatrix);

  Double_t cp = TMath::Cos(phi);
  Double_t sp = TMath::Sin(phi);
  Double_t ct = TMath::Cos(theta);
  Double_t st = TMath::Sin(theta);
  return
     covMatrix[0]*cp*cp*st*st  // GetCovXX
    +covMatrix[1]*2.*cp*sp*st*st  // GetCovXY
    -covMatrix[3]*2.*cp*ct*st  // GetCovXZ
    +covMatrix[2]*sp*sp*st*st  // GetCovYY
    -covMatrix[4]*2.*sp*sp*ct*st  // GetCovYZ
    +covMatrix[5]*ct*ct;  // GetCovZZ
}

//______________________________________________________________________________
Double_t AliAODVertex::DistanceToVertex(AliAODVertex *vtx) const
{
  // distance in 3D to another AliAODVertex

  Double_t dx = GetX()-vtx->GetX();
  Double_t dy = GetY()-vtx->GetY();
  Double_t dz = GetZ()-vtx->GetZ();

  return TMath::Sqrt(dx*dx+dy*dy+dz*dz);
}

//______________________________________________________________________________
Double_t AliAODVertex::DistanceXYToVertex(AliAODVertex *vtx) const
{
  // distance in XY to another AliAODVertex

  Double_t dx = GetX()-vtx->GetX();
  Double_t dy = GetY()-vtx->GetY();

  return TMath::Sqrt(dx*dx+dy*dy);
}

//______________________________________________________________________________
Double_t AliAODVertex::ErrorDistanceToVertex(AliAODVertex *vtx) const
{
  // error on the distance in 3D to another AliAODVertex

  Double_t phi,theta;
  PhiAndThetaToVertex(vtx,phi,theta);
  // error2 due to this vertex
  Double_t error2 = RotatedCovMatrixXX(phi,theta);
  // error2 due to vtx vertex
  Double_t error2vtx = vtx->RotatedCovMatrixXX(phi,theta);

  return TMath::Sqrt(error2+error2vtx);
}

//______________________________________________________________________________
Double_t AliAODVertex::ErrorDistanceXYToVertex(AliAODVertex *vtx) const
{
  // error on the distance in XY to another AliAODVertex

  Double_t phi,theta;
  PhiAndThetaToVertex(vtx,phi,theta);
  // error2 due to this vertex
  Double_t error2 = RotatedCovMatrixXX(phi);
  // error2 due to vtx vertex
  Double_t error2vtx = vtx->RotatedCovMatrixXX(phi);

  return TMath::Sqrt(error2+error2vtx);
}

//______________________________________________________________________________
template <class T, class P> 
void AliAODVertex::PhiAndThetaToVertex(AliAODVertex *vtx, P &phi, T &theta) const
{
  // rotation angles around z-axis (phi) and around new y-axis (theta)
  // with which vtx is seen (used by RotatedCovMatrix... methods)

  phi = TMath::Pi()+TMath::ATan2(-vtx->GetY()+GetY(),-vtx->GetX()+GetX());
  Double_t vtxxphi = vtx->GetX()*TMath::Cos(phi)+vtx->GetY()*TMath::Sin(phi);
  Double_t xphi = GetX()*TMath::Cos(phi)+GetY()*TMath::Sin(phi);
  theta = TMath::ATan2(vtx->GetZ()-GetZ(),vtxxphi-xphi);
}

//______________________________________________________________________________
void AliAODVertex::PrintIndices() const 
{
  // Print indices of particles originating form this vertex

  TRefArrayIter iter(&fDaughters);
  while (TObject *daugh = iter.Next()) {
    printf("Particle %p originates from this vertex.\n", static_cast<void*>(daugh));
  }
}

//______________________________________________________________________________
void AliAODVertex::Print(Option_t* /*option*/) const 
{
  // Print information of all data members

  printf("Vertex position:\n");
  printf("     x = %f\n", fPosition[0]);
  printf("     y = %f\n", fPosition[1]);
  printf("     z = %f\n", fPosition[2]);
  printf(" parent particle: %p\n", static_cast<void*>(fParent.GetObject()));
  printf(" origin of %d particles\n", fDaughters.GetEntriesFast());
  printf(" vertex type %d\n", fType);
  
  /*
  if (fCovMatrix) {
    printf("Covariance matrix:\n");
    printf(" %12.10f  %12.10f  %12.10f\n %12.10f  %12.10f  %12.10f\n %12.10f  %12.10f  %12.10f\n", 
	   fCovMatrix[0],
	   fCovMatrix[1],
	   fCovMatrix[3],
	   fCovMatrix[1],
	   fCovMatrix[2],
	   fCovMatrix[4],
	   fCovMatrix[3],
	   fCovMatrix[4],
	   fCovMatrix[5]); 
	   } */
  printf(" Chi^2/NDF = %f\n", fChi2perNDF);
}
Commit	Line	Data
df9db588	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, 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	// AOD track base class
	20	// Base class for Analysis Object Data
	21	// Generic version
	22	// Author: Markus Oldenburg, CERN
bdd011d6	23	// Inheritance from AliVVertex: A. Dainese
df9db588	24	//-------------------------------------------------------------------------
	25
	26	#include "AliAODVertex.h"
0657f082	27	#include "AliAODTrack.h"
0657f082	28
df9db588	29	ClassImp(AliAODVertex)
	30
	31	//______________________________________________________________________________
	32	AliAODVertex::AliAODVertex() :
bdd011d6	33	AliVVertex(),
0657f082	34	fChi2perNDF(-999.),
02153d58	35	fID(-1),
9333290e	36	fType(kUndef),
9f7c531f	37	fCovMatrix(NULL),
0f09edc3	38	fParent(),
9333290e	39	fDaughters()
9333290e	40	{
df9db588	41	// default constructor
	42
	43	fPosition[0] = fPosition[1] = fPosition[2] = -999.;
	44	}
	45
	46	//______________________________________________________________________________
	47	AliAODVertex::AliAODVertex(const Double_t position[3],
31fd97b2	48	const Double_t covMatrix[6],
0657f082	49	Double_t chi2perNDF,
df9db588	50	TObject *parent,
02153d58	51	Short_t id,
df9db588	52	Char_t vtype) :
bdd011d6	53	AliVVertex(),
0657f082	54	fChi2perNDF(chi2perNDF),
02153d58	55	fID(id),
9333290e	56	fType(vtype),
9f7c531f	57	fCovMatrix(NULL),
df9db588	58	fParent(parent),
9333290e	59	fDaughters()
df9db588	60	{
	61	// constructor
	62
	63	SetPosition(position);
	64	if (covMatrix) SetCovMatrix(covMatrix);
	65	}
	66
	67	//______________________________________________________________________________
	68	AliAODVertex::AliAODVertex(const Float_t position[3],
	69	const Float_t covMatrix[6],
0657f082	70	Double_t chi2perNDF,
df9db588	71	TObject *parent,
02153d58	72	Short_t id,
df9db588	73	Char_t vtype) :
4d209fca	74
bdd011d6	75	AliVVertex(),
0657f082	76	fChi2perNDF(chi2perNDF),
02153d58	77	fID(id),
9333290e	78	fType(vtype),
9f7c531f	79	fCovMatrix(NULL),
df9db588	80	fParent(parent),
9333290e	81	fDaughters()
df9db588	82	{
	83	// constructor
	84
	85	SetPosition(position);
	86	if (covMatrix) SetCovMatrix(covMatrix);
	87	}
	88
	89	//______________________________________________________________________________
	90	AliAODVertex::AliAODVertex(const Double_t position[3],
0657f082	91	Double_t chi2perNDF,
df9db588	92	Char_t vtype) :
bdd011d6	93	AliVVertex(),
0657f082	94	fChi2perNDF(chi2perNDF),
02153d58	95	fID(-1),
9333290e	96	fType(vtype),
9f7c531f	97	fCovMatrix(NULL),
0f09edc3	98	fParent(),
9333290e	99	fDaughters()
df9db588	100	{
	101	// constructor without covariance matrix
	102
	103	SetPosition(position);
	104	}
	105
	106	//______________________________________________________________________________
	107	AliAODVertex::AliAODVertex(const Float_t position[3],
0657f082	108	Double_t chi2perNDF,
df9db588	109	Char_t vtype) :
bdd011d6	110	AliVVertex(),
0657f082	111	fChi2perNDF(chi2perNDF),
02153d58	112	fID(-1),
9333290e	113	fType(vtype),
9f7c531f	114	fCovMatrix(NULL),
0f09edc3	115	fParent(),
9333290e	116	fDaughters()
df9db588	117	{
	118	// constructor without covariance matrix
	119
	120	SetPosition(position);
	121	}
	122
	123	//______________________________________________________________________________
	124	AliAODVertex::~AliAODVertex()
	125	{
	126	// Destructor
	127
	128	delete fCovMatrix;
	129	}
	130
	131	//______________________________________________________________________________
	132	AliAODVertex::AliAODVertex(const AliAODVertex& vtx) :
bdd011d6	133	AliVVertex(vtx),
0657f082	134	fChi2perNDF(vtx.fChi2perNDF),
02153d58	135	fID(vtx.fID),
9333290e	136	fType(vtx.fType),
9f7c531f	137	fCovMatrix(NULL),
df9db588	138	fParent(vtx.fParent),
9333290e	139	fDaughters(vtx.fDaughters)
df9db588	140	{
	141	// Copy constructor.
	142
	143	for (int i = 0; i < 3; i++)
	144	fPosition[i] = vtx.fPosition[i];
	145
5d62ce04	146	if (vtx.fCovMatrix) fCovMatrix=new AliAODRedCov<3>(*vtx.fCovMatrix);
df9db588	147	}
	148
	149	//______________________________________________________________________________
	150	AliAODVertex& AliAODVertex::operator=(const AliAODVertex& vtx)
	151	{
	152	// Assignment operator
	153	if (this != &vtx) {
	154
	155	// name and type
bdd011d6	156	AliVVertex::operator=(vtx);
df9db588	157
	158	//momentum
	159	for (int i = 0; i < 3; i++)
	160	fPosition[i] = vtx.fPosition[i];
	161
0657f082	162	fChi2perNDF = vtx.fChi2perNDF;
02153d58	163	fID = vtx.fID;
9333290e	164	fType = vtx.fType;
9f7c531f	165
df9db588	166	//covariance matrix
df9db588	167	delete fCovMatrix;
9f7c531f	168	fCovMatrix = NULL;
5d62ce04	169	if (vtx.fCovMatrix) fCovMatrix=new AliAODRedCov<3>(*vtx.fCovMatrix);
df9db588	170
df9db588	171	//other stuff
df9db588	172	fParent = vtx.fParent;
df9db588	173	fDaughters = vtx.fDaughters;
df9db588	174	}
	175
	176	return *this;
	177	}
	178
cfa5b70c	179	//______________________________________________________________________________
	180	void AliAODVertex::AddDaughter(TObject *daughter)
	181	{
	182	// Add reference to daughter track
	183
	184	if (fDaughters.GetEntries()==0) {
	185	TRefArray* arr = &fDaughters;
	186	new(arr)TRefArray(TProcessID::GetProcessWithUID(daughter));
	187	}
	188	fDaughters.Add(daughter);
	189
	190	return;
	191	}
	192
df9db588	193	//______________________________________________________________________________
	194	template <class T> void AliAODVertex::GetSigmaXYZ(T sigma[3]) const
	195	{
	196	// Return errors on vertex position in thrust frame
	197
	198	if(fCovMatrix) {
	199	sigma[0]=fCovMatrix[3]; //GetCovXZ
	200	sigma[1]=fCovMatrix[4]; //GetCovYZ
	201	sigma[2]=fCovMatrix[5]; //GetCovZZ
	202	} else
	203	sigma[0]=sigma[1]=sigma[2]=-999.;
	204
	205	/*
	206	for (int i = 0, j = 6; i < 3; i++) {
	207	j -= i+1;
	208	sigma[2-i] = fCovMatrix ? TMath::Sqrt(fCovMatrix[j]) : -999.;
	209	}
	210	*/
	211	}
	212
0657f082	213	//______________________________________________________________________________
	214	Int_t AliAODVertex::GetNContributors() const
	215	{
	216	// Returns the number of tracks used to fit this vertex.
	217
	218	Int_t cont = 0;
	219
	220	for (Int_t iDaug = 0; iDaug < GetNDaughters(); iDaug++) {
	221	if (((AliAODTrack*)fDaughters.At(iDaug))->GetUsedForVtxFit()) cont++;
	222	}
	223
	224	return cont;
	225	}
	226
df9db588	227	//______________________________________________________________________________
	228	Bool_t AliAODVertex::HasDaughter(TObject *daughter) const
	229	{
	230	// Checks if the given daughter (particle) is part of this vertex.
	231
	232	TRefArrayIter iter(&fDaughters);
	233	while (TObject *daugh = iter.Next()) {
	234	if (daugh == daughter) return kTRUE;
	235	}
	236	return kFALSE;
	237	}
	238
	239	//______________________________________________________________________________
	240	Double_t AliAODVertex::RotatedCovMatrixXX(Double_t phi, Double_t theta) const
	241	{
	242	// XX term of covariance matrix after rotation by phi around z-axis
	243	// and, then, by theta around new y-axis
	244
	245	if (!fCovMatrix) {
	246	//AliFatal("Covariance matrix not set");
	247	return -999.;
	248	}
	249
	250	Double_t covMatrix[6];
	251
	252	GetCovMatrix(covMatrix);
	253
	254	Double_t cp = TMath::Cos(phi);
	255	Double_t sp = TMath::Sin(phi);
	256	Double_t ct = TMath::Cos(theta);
	257	Double_t st = TMath::Sin(theta);
	258	return
	259	covMatrix[0]cpcpctct // GetCovXX
	260	+covMatrix[1]2.cpspct*ct // GetCovXY
	261	+covMatrix[3]2.cpctst // GetCovXZ
	262	+covMatrix[2]spspctct // GetCovYY
	263	+covMatrix[4]2.spctst // GetCovYZ
	264	+covMatrix[5]stst; // GetCovZZ
	265	}
	266
	267	//______________________________________________________________________________
	268	Double_t AliAODVertex::RotatedCovMatrixXY(Double_t phi, Double_t theta) const
	269	{
	270	// XY term of covariance matrix after rotation by phi around z-axis
	271	// and, then, by theta around new y-axis
	272
	273	if (!fCovMatrix) {
	274	//AliFatal("Covariance matrix not set");
	275	return -999.;
	276	}
	277
	278	Double_t covMatrix[6];
	279
	280	GetCovMatrix(covMatrix);
	281
	282	Double_t cp = TMath::Cos(phi);
	283	Double_t sp = TMath::Sin(phi);
	284	Double_t ct = TMath::Cos(theta);
	285	Double_t st = TMath::Sin(theta);
	286	return
	287	-covMatrix[0]cpsp*ct // GetCovXX
	288	+covMatrix[1]ct(cpcp-spsp) // GetCovXY
	289	-covMatrix[3]spst // GetCovXZ
	290	+covMatrix[2]cpsp*ct // GetCovYY
291	+covMatrix[4]cpst; // GetCovYZ
292	}
293
294	//______________________________________________________________________________
295	Double_t AliAODVertex::RotatedCovMatrixXZ(Double_t phi, Double_t theta) const
296	{
297	// XZ term of covariance matrix after rotation by phi around z-axis
298	// and, then, by theta around new y-axis
299
300	if (!fCovMatrix) {
301	//AliFatal("Covariance matrix not set");
302	return -999.;
303	}
304
305	Double_t covMatrix[6];
306
307	GetCovMatrix(covMatrix);
308
309	Double_t cp = TMath::Cos(phi);
310	Double_t sp = TMath::Sin(phi);
311	Double_t ct = TMath::Cos(theta);
312	Double_t st = TMath::Sin(theta);
313	return
314	-covMatrix[0]cpcpctst // GetCovXX
315	-covMatrix[1]2.cpspct*st // GetCovXY
316	+covMatrix[3]cp(ctct-stst) // GetCovXZ
317	-covMatrix[2]spspctst // GetCovYY
318	+covMatrix[4]sp(ctct-stst) // GetCovYZ
319	+covMatrix[5]ctst; // GetCovZZ
320	}
321
322	//______________________________________________________________________________
323	Double_t AliAODVertex::RotatedCovMatrixYY(Double_t phi) const
324	{
325	// YY term of covariance matrix after rotation by phi around z-axis
326	// and, then, by theta around new y-axis
327
328	if (!fCovMatrix) {
329	//AliFatal("Covariance matrix not set");
330	return -999.;
331	}
332
333	Double_t covMatrix[6];
334
335	GetCovMatrix(covMatrix);
336
337	Double_t cp = TMath::Cos(phi);
338	Double_t sp = TMath::Sin(phi);
339	return
340	covMatrix[0]spsp // GetCovXX
341	-covMatrix[1]2.cp*sp // GetCovXY
342	+covMatrix[2]cpcp; // GetCovYY
343	}
344
345	//______________________________________________________________________________
346	Double_t AliAODVertex::RotatedCovMatrixYZ(Double_t phi, Double_t theta) const
347	{
348	// YZ term of covariance matrix after rotation by phi around z-axis
349	// and, then, by theta around new y-axis
350
351	if (!fCovMatrix) {
352	//AliFatal("Covariance matrix not set");
353	return -999.;
354	}
355
356	Double_t covMatrix[6];
357
358	GetCovMatrix(covMatrix);
359
360	Double_t cp = TMath::Cos(phi);
361	Double_t sp = TMath::Sin(phi);
362	Double_t ct = TMath::Cos(theta);
363	Double_t st = TMath::Sin(theta);
364	return
365	covMatrix[0]cpsp*st // GetCovXX
366	+covMatrix[1]st(spsp-cpcp) // GetCovXY
367	-covMatrix[3]spct // GetCovXZ
368	-covMatrix[2]cpsp*st // GetCovYY
369	+covMatrix[4]cpct; // GetCovYZ
370	}
371
372	//______________________________________________________________________________
373	Double_t AliAODVertex::RotatedCovMatrixZZ(Double_t phi, Double_t theta) const
374	{
375	// ZZ term of covariance matrix after rotation by phi around z-axis
376	// and, then, by theta around new y-axis
377
378	if (!fCovMatrix) {
379	//AliFatal("Covariance matrix not set");
380	return -999.;
381	}
382
383	Double_t covMatrix[6];
384
385	GetCovMatrix(covMatrix);
386
387	Double_t cp = TMath::Cos(phi);
388	Double_t sp = TMath::Sin(phi);
389	Double_t ct = TMath::Cos(theta);
390	Double_t st = TMath::Sin(theta);
391	return
392	covMatrix[0]cpcpstst // GetCovXX
393	+covMatrix[1]2.cpspst*st // GetCovXY
394	-covMatrix[3]2.cpctst // GetCovXZ
395	+covMatrix[2]spspstst // GetCovYY
396	-covMatrix[4]2.spspct*st // GetCovYZ
397	+covMatrix[5]ctct; // GetCovZZ
398	}
399
400	//______________________________________________________________________________
401	Double_t AliAODVertex::DistanceToVertex(AliAODVertex *vtx) const
402	{
403	// distance in 3D to another AliAODVertex
404
405	Double_t dx = GetX()-vtx->GetX();
406	Double_t dy = GetY()-vtx->GetY();
407	Double_t dz = GetZ()-vtx->GetZ();
408
409	return TMath::Sqrt(dxdx+dydy+dz*dz);
410	}
411
412	//______________________________________________________________________________
413	Double_t AliAODVertex::DistanceXYToVertex(AliAODVertex *vtx) const
414	{
415	// distance in XY to another AliAODVertex
416
417	Double_t dx = GetX()-vtx->GetX();
418	Double_t dy = GetY()-vtx->GetY();
419
420	return TMath::Sqrt(dxdx+dydy);
421	}
422
423	//______________________________________________________________________________
424	Double_t AliAODVertex::ErrorDistanceToVertex(AliAODVertex *vtx) const
425	{
426	// error on the distance in 3D to another AliAODVertex
427
428	Double_t phi,theta;
429	PhiAndThetaToVertex(vtx,phi,theta);
430	// error2 due to this vertex
431	Double_t error2 = RotatedCovMatrixXX(phi,theta);
432	// error2 due to vtx vertex
433	Double_t error2vtx = vtx->RotatedCovMatrixXX(phi,theta);
434
435	return TMath::Sqrt(error2+error2vtx);
436	}
437
438	//______________________________________________________________________________
439	Double_t AliAODVertex::ErrorDistanceXYToVertex(AliAODVertex *vtx) const
440	{
441	// error on the distance in XY to another AliAODVertex
442
443	Double_t phi,theta;
444	PhiAndThetaToVertex(vtx,phi,theta);
445	// error2 due to this vertex
446	Double_t error2 = RotatedCovMatrixXX(phi);
447	// error2 due to vtx vertex
448	Double_t error2vtx = vtx->RotatedCovMatrixXX(phi);
449
450	return TMath::Sqrt(error2+error2vtx);
451	}
452
453	//______________________________________________________________________________
454	template <class T, class P>
455	void AliAODVertex::PhiAndThetaToVertex(AliAODVertex *vtx, P &phi, T &theta) const
456	{
457	// rotation angles around z-axis (phi) and around new y-axis (theta)
458	// with which vtx is seen (used by RotatedCovMatrix... methods)
459
b1a9edc8	460	phi = TMath::Pi()+TMath::ATan2(-vtx->GetY()+GetY(),-vtx->GetX()+GetX());
df9db588	461	Double_t vtxxphi = vtx->GetX()TMath::Cos(phi)+vtx->GetY()TMath::Sin(phi);
	462	Double_t xphi = GetX()TMath::Cos(phi)+GetY()TMath::Sin(phi);
	463	theta = TMath::ATan2(vtx->GetZ()-GetZ(),vtxxphi-xphi);
	464	}
	465
	466	//______________________________________________________________________________
	467	void AliAODVertex::PrintIndices() const
	468	{
	469	// Print indices of particles originating form this vertex
	470
	471	TRefArrayIter iter(&fDaughters);
	472	while (TObject *daugh = iter.Next()) {
f12d42ce	473	printf("Particle %p originates from this vertex.\n", static_cast<void*>(daugh));
df9db588	474	}
	475	}
	476
	477	//______________________________________________________________________________
	478	void AliAODVertex::Print(Option_t* /option/) const
	479	{
	480	// Print information of all data members
	481
	482	printf("Vertex position:\n");
	483	printf(" x = %f\n", fPosition[0]);
	484	printf(" y = %f\n", fPosition[1]);
	485	printf(" z = %f\n", fPosition[2]);
f12d42ce	486	printf(" parent particle: %p\n", static_cast<void*>(fParent.GetObject()));
df9db588	487	printf(" origin of %d particles\n", fDaughters.GetEntriesFast());
	488	printf(" vertex type %d\n", fType);
	489
	490	/*
	491	if (fCovMatrix) {
	492	printf("Covariance matrix:\n");
	493	printf(" %12.10f %12.10f %12.10f\n %12.10f %12.10f %12.10f\n %12.10f %12.10f %12.10f\n",
	494	fCovMatrix[0],
	495	fCovMatrix[1],
	496	fCovMatrix[3],
	497	fCovMatrix[1],
	498	fCovMatrix[2],
	499	fCovMatrix[4],
	500	fCovMatrix[3],
	501	fCovMatrix[4],
	502	fCovMatrix[5]);
	503	} */
0657f082	504	printf(" Chi^2/NDF = %f\n", fChi2perNDF);
df9db588	505	}
df9db588	506