[u/mrichter/AliRoot.git] / PWG1 / TRD / info / AliTRDtrackInfo.cxx

/**************************************************************************
* Copyright(c) 1998-1999, 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: AliTRDtrackInfo.cxx 27496 2008-07-22 08:35:45Z cblume $ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  Reconstruction QA                                                     //
//                                                                        //
//  Authors:                                                              //
//    Alex Bercuci <A.Bercuci@gsi.de>                                     //
//    Markus Fasel <M.Fasel@gsi.de>                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "TDatabasePDG.h"
#include "TVectorT.h"

#include "AliTrackReference.h"
#include "AliExternalTrackParam.h"

#include "AliTRDseedV1.h"
#include "AliTRDtrackV1.h"
#include "AliTRDgeometry.h"
#include "AliTRDtrackerV1.h"

#include "AliTRDtrackInfo.h"

ClassImp(AliTRDtrackInfo)
ClassImp(AliTRDtrackInfo::AliMCinfo)
ClassImp(AliTRDtrackInfo::AliESDinfo)
Double_t AliTRDtrackInfo::AliMCinfo::fgKalmanStep = 2.;

//___________________________________________________
AliTRDtrackInfo::AliTRDtrackInfo():
  TObject()
  ,fNClusters(0)
  ,fTRDtrack(NULL)
  ,fMC(NULL)
  ,fESD()
{
  //
  // Default constructor
  //
}


//___________________________________________________
AliTRDtrackInfo::AliTRDtrackInfo(const AliTRDtrackInfo &trdInfo):
  TObject((const TObject&)trdInfo)  
  ,fNClusters(trdInfo.fNClusters)
  ,fTRDtrack(NULL)
  ,fMC(NULL)
  ,fESD(trdInfo.fESD)
{
  //
  // copy Entries
  //

  if(trdInfo.fMC) fMC = new AliMCinfo(*trdInfo.fMC);

  if(trdInfo.fTRDtrack){ 
    fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
    if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
  }
}

//___________________________________________________
AliTRDtrackInfo::AliMCinfo::AliMCinfo()
  :fLabel(0)
  ,fPDG(0)
  ,fNTrackRefs(0)
{
  // Set 0-Pointers
  memset(fTrackRefs, 0, sizeof(AliTrackReference *) * 12);
}

//___________________________________________________
AliTRDtrackInfo::AliMCinfo::AliMCinfo(const AliMCinfo &mc)
  :fLabel(mc.fLabel)
  ,fPDG(mc.fPDG)
  ,fNTrackRefs(mc.fNTrackRefs)
{
  //
  // Constructor
  //

  memset(fTrackRefs, 0, sizeof(AliTrackReference *) * 12);
  for(Int_t ien = 0; ien < 12; ien++){
    if(mc.fTrackRefs[ien])
      fTrackRefs[ien] = new AliTrackReference(*(mc.fTrackRefs[ien]));
  }
}

//___________________________________________________
AliTRDtrackInfo::AliESDinfo::AliESDinfo()
  :fId(-1)
  ,fStatus(0)
  ,fKinkIndex(0)
  ,fTPCncls(0)
  ,fTRDpidQuality(0)
  ,fTRDnSlices(0)
  ,fTRDslices(NULL)
  ,fOP(NULL)
{
  //
  // Constructor
  //

  memset(fTRDr, 0, AliPID::kSPECIES*sizeof(Double32_t));
}

//___________________________________________________
AliTRDtrackInfo::AliESDinfo::AliESDinfo(const AliESDinfo &esd)
  :fId(esd.fId)
  ,fStatus(esd.fStatus)
  ,fKinkIndex(esd.fKinkIndex)
  ,fTPCncls(esd.fTPCncls)
  ,fTRDpidQuality(esd.fTRDpidQuality)
  ,fTRDnSlices(esd.fTRDnSlices)
  ,fTRDslices(NULL)
  ,fOP(NULL)
{
  //
  // Constructor
  //

  memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));

  if(fTRDnSlices){
    fTRDslices = new Double32_t[fTRDnSlices];
    memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
  }
  if(esd.fOP) fOP = new AliExternalTrackParam(*esd.fOP);
}


//___________________________________________________
AliTRDtrackInfo::~AliTRDtrackInfo()
{
  //
  // Destructor
  //

  if(fMC) delete fMC;
  if(fTRDtrack) delete fTRDtrack;
}

//___________________________________________________
AliTRDtrackInfo::AliMCinfo::~AliMCinfo()
{
  //
  // Destructor
  //

  fNTrackRefs = 0;
  for(Int_t ien = 0; ien < 12; ien++){
    if(fTrackRefs[ien]) delete fTrackRefs[ien];
    fTrackRefs[ien] = NULL;
  }
}

//___________________________________________________
AliTRDtrackInfo::AliESDinfo::~AliESDinfo()
{
  //
  // Destructor
  //

  if(fTRDnSlices){
    delete [] fTRDslices;
    fTRDslices = NULL;
    fTRDnSlices = 0;
  }
  if(fOP) delete fOP; fOP = NULL;
}


//___________________________________________________
AliTRDtrackInfo& AliTRDtrackInfo::operator=(const AliTRDtrackInfo &trdInfo)
{
  //
  // = Operator
  //

  fNClusters  = trdInfo.fNClusters;
  fESD = trdInfo.fESD;

  if(trdInfo.fMC){
    if(!fMC)
      fMC = new AliMCinfo(*trdInfo.fMC);
    else
      new(fMC) AliMCinfo(*trdInfo.fMC);
  }

  if(trdInfo.fTRDtrack){
    if(!fTRDtrack)
      fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
    else
      new(fTRDtrack) AliTRDtrackV1(*trdInfo.fTRDtrack);
    if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
  }

  return *this;
}

//___________________________________________________
AliTRDtrackInfo::AliMCinfo& AliTRDtrackInfo::AliMCinfo::operator=(const AliMCinfo &mc)
{
  //
  // Assignment operator
  //

  fLabel      = mc.fLabel;
  fPDG        = mc.fPDG;
  fNTrackRefs = mc.fNTrackRefs;

  AliTrackReference **itr = &fTrackRefs[0];
  AliTrackReference* const *jtr = &mc.fTrackRefs[0];
  for(Int_t ien = 0; ien < 12; ien++, itr++, jtr++){
    if((*jtr)){
      if(!(*itr)) (*itr) = new AliTrackReference(*(*jtr));
      else new(&(*itr)) AliTrackReference(*(*jtr));
    } else (*itr) = NULL;
  }
  return *this;
}

//___________________________________________________
AliTRDtrackInfo::AliESDinfo& AliTRDtrackInfo::AliESDinfo::operator=(const AliESDinfo &esd)
{
  //
  // Assignment operator
  //

  fId          = esd.fId;
  fStatus      = esd.fStatus; 
  fTRDpidQuality = esd.fTRDpidQuality;
  fTRDnSlices  = esd.fTRDnSlices;
  fTRDslices   = NULL;

  memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));

  if(fTRDnSlices){
    fTRDslices = new Double32_t[fTRDnSlices];
    memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
  }
  if(esd.fOP){
    if(fOP) new(fOP) AliExternalTrackParam(esd.fOP);
    else fOP = new AliExternalTrackParam(esd.fOP);
  } else fOP = NULL;

  return *this;
}

//___________________________________________________
void AliTRDtrackInfo::Delete(const Option_t *)
{
  //
  // Delete
  //

  fNClusters  = 0;
  if(fMC) delete fMC; fMC = NULL;
  if(fTRDtrack) delete fTRDtrack; fTRDtrack = NULL;
}

//___________________________________________________
void AliTRDtrackInfo::SetTrack(const AliTRDtrackV1 *track)
{
  //
  // Set the TRD track
  //

  if(!fTRDtrack)
    fTRDtrack = new AliTRDtrackV1(*track);	
  else
    new(fTRDtrack)AliTRDtrackV1(*track);
  fTRDtrack->SetOwner();
  // Make a copy for the object in order to avoid ownership problems
}

//___________________________________________________
void AliTRDtrackInfo::AddTrackRef(const AliTrackReference *tref)
{
  //
  // Add track reference
  //

  if(fMC->fNTrackRefs >= 12){ 
    SetCurved();
    return;
  }
  // Make a copy for the object in order to avoid ownership problems
  fMC->fTrackRefs[fMC->fNTrackRefs++] = new AliTrackReference(*tref);
}

//___________________________________________________
AliTrackReference* AliTRDtrackInfo::GetTrackRef(Int_t idx) const
{
//
// Returns a track reference
//
  if(!fMC) return NULL;
  return (idx>=0 && idx < 12) ? fMC->fTrackRefs[idx] : NULL;
}

//___________________________________________________
AliTrackReference* AliTRDtrackInfo::GetTrackRef(AliTRDseedV1* const tracklet) const
{
//
// Returns a track reference
//
  if(!fMC) return NULL;
  Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
  AliTrackReference * const* jtr = &(fMC->fTrackRefs[0]);
  for(Int_t itr = 0; itr < fMC->fNTrackRefs; itr++, ++jtr){
    if(!(*jtr)) break;   
    if(TMath::Abs(tracklet->GetX0() - (*jtr)->LocalX()) < cw) return (*jtr);
  }
  return NULL;
}

//___________________________________________________
Int_t AliTRDtrackInfo::GetNumberOfClusters() const
{
  //
  // Returns the number of clusters
  //

  Int_t n = 0;
  if(!fTRDtrack) return 0;
  if(fTRDtrack->GetNumberOfTracklets() == 0) return n;
  AliTRDseedV1 *tracklet = NULL;
  for(Int_t ip=0; ip<6; ip++){
    if(!(tracklet = const_cast<AliTRDseedV1 *>(fTRDtrack->GetTracklet(ip)))) continue;
    n+=tracklet->GetN();
  }
  return n;
}


//___________________________________________________
void  AliTRDtrackInfo::SetOuterParam(const AliExternalTrackParam *op)
{
  //
  // Set outer track parameters
  //

  if(!op) return;
  if(fESD.fOP) new(fESD.fOP) AliExternalTrackParam(*op);
  else fESD.fOP = new AliExternalTrackParam(*op);
}

//___________________________________________________
Int_t AliTRDtrackInfo::GetNTracklets() const
{
  //
  // Return the number of tracklets
  //

  if(!fTRDtrack) return 0;
  return fTRDtrack->GetNumberOfTracklets();
}

//___________________________________________________
void AliTRDtrackInfo::SetSlices(Int_t n, Double32_t *s)
{
  //
  // Set the slices
  //
  if(fESD.fTRDnSlices != n){
    fESD.fTRDnSlices = 0;
    delete [] fESD.fTRDslices;
    fESD.fTRDslices = NULL;
  }

  if(!fESD.fTRDnSlices){
    fESD.fTRDnSlices = n;
    fESD.fTRDslices = new Double32_t[fESD.fTRDnSlices];
  }

  memcpy(fESD.fTRDslices, s, n*sizeof(Double32_t));
}
 
//___________________________________________________
Bool_t AliTRDtrackInfo::AliMCinfo::GetDirections(Float_t &x0, Float_t &y0, Float_t &z0, Float_t &dydx, Float_t &dzdx, Float_t &pt, UChar_t &status) const
{
// Check for 2 track ref for the tracklet defined bythe radial position x0
// The "status" is a bit map and gives a more informative output in case of failure:
//   - 0 : everything is OK
//   - BIT(0) : 0 track refs found
//   - BIT(1) : 1 track reference found
//   - BIT(2) : dx <= 0 between track references
//   - BIT(3) : dx > 0 && dx < 3.7 - tangent tracks 

  status = 0;
  Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
  Int_t nFound = 0;
  AliTrackReference *tr[2] = {NULL, NULL};
  AliTrackReference * const* jtr = &fTrackRefs[0];
  for(Int_t itr = 0; itr < fNTrackRefs; itr++, ++jtr){
    if(!(*jtr)) break;
/*
    if(fDebugLevel>=5) printf("\t\tref[%2d] x[%6.3f]\n", itr, (*jtr)->LocalX());*/
    if(TMath::Abs(x0 - (*jtr)->LocalX()) > cw) continue;
    tr[nFound++] = (*jtr);
    if(nFound == 2) break;
  } 
  if(nFound < 2){ 
    AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", Form("Missing track ref x0[%6.3f] nref[%d]", x0, nFound));
    if(!nFound) SETBIT(status, 0);
    else SETBIT(status, 1);
    return kFALSE;
  }
  if((pt=tr[1]->Pt()) < 1.e-3) return kFALSE;

  Double_t dx = tr[1]->LocalX() - tr[0]->LocalX();
  if(dx <= 0.){
    AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", Form("Track ref with wrong radial distances refX0[%6.3f] refX1[%6.3f]", tr[0]->LocalX(), tr[1]->LocalX()));
    SETBIT(status, 2);
    return kFALSE;
  }
  if(TMath::Abs(dx-AliTRDgeometry::CamHght()-AliTRDgeometry::CdrHght())>1.E-3) SETBIT(status, 3); 

  dydx = (tr[1]->LocalY() - tr[0]->LocalY()) / dx;
  dzdx = (tr[1]->Z() - tr[0]->Z()) / dx;
  //Float_t dx0 = tr[1]->LocalX() - x0;
  y0   =  tr[1]->LocalY()/* - dydx*dx0*/;
  z0   =  tr[1]->Z()/* - dzdx*dx0*/;
  x0   =  tr[1]->LocalX();
  return kTRUE;
}

//___________________________________________________
void AliTRDtrackInfo::AliMCinfo::PropagateKalman(TVectorD *dx, TVectorD *dy, TVectorD *dz, TVectorD *pt, TVectorD *dpt, TVectorD *c) const
{
// Propagate Kalman from the first TRD track reference to 
// last one and save residuals in the y, z and pt.
// 
// This is to calibrate the dEdx and MS corrections

  if(!fNTrackRefs) return;
  for(Int_t itr=kNTrackRefs; itr--;){
    (*dx)[itr] = -1.; (*dy)[itr] = 100.; (*dz)[itr] = 100.; (*dpt)[itr] = 100.;
  }

  // Initialize TRD track to the first track reference
  AliTrackReference *tr(NULL);
  Int_t itr(0); while(!(tr = fTrackRefs[itr])) itr++;
  if(tr->Pt()<1.e-3) return;

  AliTRDtrackV1 tt;
  Double_t xyz[3]={tr->X(),tr->Y(),tr->Z()};
  Double_t pxyz[3]={tr->Px(),tr->Py(),tr->Pz()};
  Double_t var[6] = {1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4};
  Double_t cov[21]={
    var[0],  0.,  0.,  0.,  0.,  0.,
         var[1],  0.,  0.,  0.,  0.,
              var[2],  0.,  0.,  0.,
                   var[3],  0.,  0.,
                        var[4],  0.,
                             var[5]
  };
  TDatabasePDG db;
  const TParticlePDG *pdg=db.GetParticle(fPDG);
  if(!pdg){
    AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::PropagateKalman()", Form("PDG entry missing for code %d. References for track %d", fPDG, fNTrackRefs));
    return;
  }
  tt.Set(xyz, pxyz, cov, Short_t(pdg->Charge()));
  tt.SetMass(pdg->Mass());
  
  Double_t x0(tr->LocalX());
  const Double_t *cc(NULL);
  for(Int_t ip=0; itr<fNTrackRefs; itr++){
    if(!(tr = fTrackRefs[itr])) continue;
    if(!AliTRDtrackerV1::PropagateToX(tt, tr->LocalX(), fgKalmanStep)) continue;

    //if(update) ...
    (*dx)[ip]  = tt.GetX() - x0;
    (*dy)[ip]  = tt.GetY() - tr->LocalY();
    (*dz)[ip]  = tt.GetZ() - tr->Z();
    (*pt)[ip]  = tr->Pt();
    (*dpt)[ip] = tt.Pt()- tr->Pt();
    cc = tt.GetCovariance();
    c->Use(ip*15, (ip+1)*15, cc);
    ip++;
  }
}
Commit	Line	Data
1ee39b3a	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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: AliTRDtrackInfo.cxx 27496 2008-07-22 08:35:45Z cblume $ */
	17
	18	////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Reconstruction QA //
	21	// //
	22	// Authors: //
	23	// Alex Bercuci <A.Bercuci@gsi.de> //
	24	// Markus Fasel <M.Fasel@gsi.de> //
	25	// //
	26	////////////////////////////////////////////////////////////////////////////
	27
	28	#include "TDatabasePDG.h"
4226db3e	29	#include "TVectorT.h"
1ee39b3a	30
	31	#include "AliTrackReference.h"
	32	#include "AliExternalTrackParam.h"
	33
	34	#include "AliTRDseedV1.h"
	35	#include "AliTRDtrackV1.h"
	36	#include "AliTRDgeometry.h"
	37	#include "AliTRDtrackerV1.h"
	38
	39	#include "AliTRDtrackInfo.h"
	40
	41	ClassImp(AliTRDtrackInfo)
	42	ClassImp(AliTRDtrackInfo::AliMCinfo)
	43	ClassImp(AliTRDtrackInfo::AliESDinfo)
5066aa9a	44	Double_t AliTRDtrackInfo::AliMCinfo::fgKalmanStep = 2.;
1ee39b3a	45
	46	//___________________________________________________
	47	AliTRDtrackInfo::AliTRDtrackInfo():
	48	TObject()
	49	,fNClusters(0)
f232df0d	50	,fTRDtrack(NULL)
f232df0d	51	,fMC(NULL)
1ee39b3a	52	,fESD()
	53	{
	54	//
	55	// Default constructor
	56	//
	57	}
	58
	59
	60	//___________________________________________________
	61	AliTRDtrackInfo::AliTRDtrackInfo(const AliTRDtrackInfo &trdInfo):
	62	TObject((const TObject&)trdInfo)
	63	,fNClusters(trdInfo.fNClusters)
f232df0d	64	,fTRDtrack(NULL)
a340fe39	65	,fMC(NULL)
1ee39b3a	66	,fESD(trdInfo.fESD)
	67	{
	68	//
	69	// copy Entries
	70	//
	71
	72	if(trdInfo.fMC) fMC = new AliMCinfo(*trdInfo.fMC);
	73
	74	if(trdInfo.fTRDtrack){
	75	fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
	76	if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
	77	}
	78	}
	79
	80	//___________________________________________________
	81	AliTRDtrackInfo::AliMCinfo::AliMCinfo()
	82	:fLabel(0)
	83	,fPDG(0)
	84	,fNTrackRefs(0)
	85	{
	86	// Set 0-Pointers
	87	memset(fTrackRefs, 0, sizeof(AliTrackReference ) 12);
	88	}
	89
	90	//___________________________________________________
	91	AliTRDtrackInfo::AliMCinfo::AliMCinfo(const AliMCinfo &mc)
	92	:fLabel(mc.fLabel)
	93	,fPDG(mc.fPDG)
	94	,fNTrackRefs(mc.fNTrackRefs)
	95	{
	96	//
	97	// Constructor
	98	//
	99
	100	memset(fTrackRefs, 0, sizeof(AliTrackReference ) 12);
	101	for(Int_t ien = 0; ien < 12; ien++){
	102	if(mc.fTrackRefs[ien])
	103	fTrackRefs[ien] = new AliTrackReference(*(mc.fTrackRefs[ien]));
	104	}
	105	}
	106
	107	//___________________________________________________
	108	AliTRDtrackInfo::AliESDinfo::AliESDinfo()
	109	:fId(-1)
	110	,fStatus(0)
	111	,fKinkIndex(0)
	112	,fTPCncls(0)
	113	,fTRDpidQuality(0)
	114	,fTRDnSlices(0)
f232df0d	115	,fTRDslices(NULL)
f232df0d	116	,fOP(NULL)
1ee39b3a	117	{
	118	//
	119	// Constructor
	120	//
	121
	122	memset(fTRDr, 0, AliPID::kSPECIES*sizeof(Double32_t));
	123	}
	124
	125	//___________________________________________________
	126	AliTRDtrackInfo::AliESDinfo::AliESDinfo(const AliESDinfo &esd)
	127	:fId(esd.fId)
	128	,fStatus(esd.fStatus)
	129	,fKinkIndex(esd.fKinkIndex)
	130	,fTPCncls(esd.fTPCncls)
	131	,fTRDpidQuality(esd.fTRDpidQuality)
	132	,fTRDnSlices(esd.fTRDnSlices)
f232df0d	133	,fTRDslices(NULL)
f232df0d	134	,fOP(NULL)
1ee39b3a	135	{
	136	//
	137	// Constructor
	138	//
	139
	140	memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));
	141
	142	if(fTRDnSlices){
	143	fTRDslices = new Double32_t[fTRDnSlices];
	144	memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
	145	}
	146	if(esd.fOP) fOP = new AliExternalTrackParam(*esd.fOP);
	147	}
	148
	149
	150	//___________________________________________________
	151	AliTRDtrackInfo::~AliTRDtrackInfo()
	152	{
	153	//
	154	// Destructor
	155	//
	156
	157	if(fMC) delete fMC;
	158	if(fTRDtrack) delete fTRDtrack;
	159	}
	160
	161	//___________________________________________________
	162	AliTRDtrackInfo::AliMCinfo::~AliMCinfo()
	163	{
	164	//
	165	// Destructor
	166	//
	167
	168	fNTrackRefs = 0;
	169	for(Int_t ien = 0; ien < 12; ien++){
	170	if(fTrackRefs[ien]) delete fTrackRefs[ien];
f232df0d	171	fTrackRefs[ien] = NULL;
1ee39b3a	172	}
	173	}
	174
	175	//___________________________________________________
	176	AliTRDtrackInfo::AliESDinfo::~AliESDinfo()
	177	{
	178	//
	179	// Destructor
	180	//
	181
	182	if(fTRDnSlices){
	183	delete [] fTRDslices;
f232df0d	184	fTRDslices = NULL;
1ee39b3a	185	fTRDnSlices = 0;
1ee39b3a	186	}
f232df0d	187	if(fOP) delete fOP; fOP = NULL;
1ee39b3a	188	}
	189
	190
	191	//___________________________________________________
	192	AliTRDtrackInfo& AliTRDtrackInfo::operator=(const AliTRDtrackInfo &trdInfo)
	193	{
	194	//
	195	// = Operator
	196	//
	197
	198	fNClusters = trdInfo.fNClusters;
	199	fESD = trdInfo.fESD;
	200
	201	if(trdInfo.fMC){
	202	if(!fMC)
	203	fMC = new AliMCinfo(*trdInfo.fMC);
	204	else
	205	new(fMC) AliMCinfo(*trdInfo.fMC);
	206	}
	207
	208	if(trdInfo.fTRDtrack){
	209	if(!fTRDtrack)
	210	fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
	211	else
	212	new(fTRDtrack) AliTRDtrackV1(*trdInfo.fTRDtrack);
	213	if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
	214	}
	215
	216	return *this;
	217	}
	218
	219	//___________________________________________________
	220	AliTRDtrackInfo::AliMCinfo& AliTRDtrackInfo::AliMCinfo::operator=(const AliMCinfo &mc)
	221	{
	222	//
	223	// Assignment operator
	224	//
	225
	226	fLabel = mc.fLabel;
	227	fPDG = mc.fPDG;
	228	fNTrackRefs = mc.fNTrackRefs;
	229
	230	AliTrackReference **itr = &fTrackRefs[0];
	231	AliTrackReference* const *jtr = &mc.fTrackRefs[0];
	232	for(Int_t ien = 0; ien < 12; ien++, itr++, jtr++){
	233	if((*jtr)){
	234	if(!(itr)) (itr) = new AliTrackReference((jtr));
	235	else new(&(itr)) AliTrackReference((*jtr));
f232df0d	236	} else (*itr) = NULL;
1ee39b3a	237	}
	238	return *this;
	239	}
	240
	241	//___________________________________________________
	242	AliTRDtrackInfo::AliESDinfo& AliTRDtrackInfo::AliESDinfo::operator=(const AliESDinfo &esd)
	243	{
	244	//
	245	// Assignment operator
	246	//
	247
	248	fId = esd.fId;
	249	fStatus = esd.fStatus;
	250	fTRDpidQuality = esd.fTRDpidQuality;
	251	fTRDnSlices = esd.fTRDnSlices;
f232df0d	252	fTRDslices = NULL;
1ee39b3a	253
	254	memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));
	255
	256	if(fTRDnSlices){
	257	fTRDslices = new Double32_t[fTRDnSlices];
	258	memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
	259	}
	260	if(esd.fOP){
	261	if(fOP) new(fOP) AliExternalTrackParam(esd.fOP);
	262	else fOP = new AliExternalTrackParam(esd.fOP);
f232df0d	263	} else fOP = NULL;
1ee39b3a	264
	265	return *this;
	266	}
	267
	268	//___________________________________________________
	269	void AliTRDtrackInfo::Delete(const Option_t *)
	270	{
	271	//
	272	// Delete
	273	//
	274
	275	fNClusters = 0;
f232df0d	276	if(fMC) delete fMC; fMC = NULL;
f232df0d	277	if(fTRDtrack) delete fTRDtrack; fTRDtrack = NULL;
1ee39b3a	278	}
	279
	280	//___________________________________________________
	281	void AliTRDtrackInfo::SetTrack(const AliTRDtrackV1 *track)
	282	{
	283	//
	284	// Set the TRD track
	285	//
	286
	287	if(!fTRDtrack)
	288	fTRDtrack = new AliTRDtrackV1(*track);
	289	else
	290	new(fTRDtrack)AliTRDtrackV1(*track);
	291	fTRDtrack->SetOwner();
	292	// Make a copy for the object in order to avoid ownership problems
	293	}
	294
	295	//___________________________________________________
	296	void AliTRDtrackInfo::AddTrackRef(const AliTrackReference *tref)
	297	{
	298	//
	299	// Add track reference
	300	//
	301
1ee39b3a	302	if(fMC->fNTrackRefs >= 12){
	303	SetCurved();
	304	return;
	305	}
	306	// Make a copy for the object in order to avoid ownership problems
	307	fMC->fTrackRefs[fMC->fNTrackRefs++] = new AliTrackReference(*tref);
	308	}
	309
	310	//___________________________________________________
	311	AliTrackReference* AliTRDtrackInfo::GetTrackRef(Int_t idx) const
	312	{
	313	//
	314	// Returns a track reference
	315	//
f232df0d	316	if(!fMC) return NULL;
f232df0d	317	return (idx>=0 && idx < 12) ? fMC->fTrackRefs[idx] : NULL;
1ee39b3a	318	}
	319
	320	//___________________________________________________
	321	AliTrackReference* AliTRDtrackInfo::GetTrackRef(AliTRDseedV1* const tracklet) const
	322	{
	323	//
	324	// Returns a track reference
	325	//
f232df0d	326	if(!fMC) return NULL;
1ee39b3a	327	Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
	328	AliTrackReference * const* jtr = &(fMC->fTrackRefs[0]);
	329	for(Int_t itr = 0; itr < fMC->fNTrackRefs; itr++, ++jtr){
	330	if(!(*jtr)) break;
	331	if(TMath::Abs(tracklet->GetX0() - (jtr)->LocalX()) < cw) return (jtr);
	332	}
f232df0d	333	return NULL;
1ee39b3a	334	}
	335
	336	//___________________________________________________
	337	Int_t AliTRDtrackInfo::GetNumberOfClusters() const
	338	{
	339	//
	340	// Returns the number of clusters
	341	//
	342
	343	Int_t n = 0;
	344	if(!fTRDtrack) return 0;
	345	if(fTRDtrack->GetNumberOfTracklets() == 0) return n;
f232df0d	346	AliTRDseedV1 *tracklet = NULL;
1ee39b3a	347	for(Int_t ip=0; ip<6; ip++){
	348	if(!(tracklet = const_cast<AliTRDseedV1 *>(fTRDtrack->GetTracklet(ip)))) continue;
	349	n+=tracklet->GetN();
	350	}
	351	return n;
	352	}
	353
	354
	355	//___________________________________________________
	356	void AliTRDtrackInfo::SetOuterParam(const AliExternalTrackParam *op)
	357	{
	358	//
	359	// Set outer track parameters
	360	//
	361
	362	if(!op) return;
	363	if(fESD.fOP) new(fESD.fOP) AliExternalTrackParam(*op);
	364	else fESD.fOP = new AliExternalTrackParam(*op);
	365	}
	366
	367	//___________________________________________________
	368	Int_t AliTRDtrackInfo::GetNTracklets() const
	369	{
	370	//
	371	// Return the number of tracklets
	372	//
	373
e2927481	374	if(!fTRDtrack) return 0;
1ee39b3a	375	return fTRDtrack->GetNumberOfTracklets();
	376	}
	377
	378	//___________________________________________________
	379	void AliTRDtrackInfo::SetSlices(Int_t n, Double32_t *s)
	380	{
	381	//
	382	// Set the slices
	383	//
1ee39b3a	384	if(fESD.fTRDnSlices != n){
	385	fESD.fTRDnSlices = 0;
	386	delete [] fESD.fTRDslices;
f232df0d	387	fESD.fTRDslices = NULL;
1ee39b3a	388	}
	389
	390	if(!fESD.fTRDnSlices){
	391	fESD.fTRDnSlices = n;
f232df0d	392	fESD.fTRDslices = new Double32_t[fESD.fTRDnSlices];
1ee39b3a	393	}
	394
	395	memcpy(fESD.fTRDslices, s, n*sizeof(Double32_t));
	396	}
	397
	398	//___________________________________________________
	399	Bool_t AliTRDtrackInfo::AliMCinfo::GetDirections(Float_t &x0, Float_t &y0, Float_t &z0, Float_t &dydx, Float_t &dzdx, Float_t &pt, UChar_t &status) const
	400	{
	401	// Check for 2 track ref for the tracklet defined bythe radial position x0
	402	// The "status" is a bit map and gives a more informative output in case of failure:
	403	// - 0 : everything is OK
	404	// - BIT(0) : 0 track refs found
	405	// - BIT(1) : 1 track reference found
	406	// - BIT(2) : dx <= 0 between track references
	407	// - BIT(3) : dx > 0 && dx < 3.7 - tangent tracks
	408
	409	status = 0;
	410	Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
	411	Int_t nFound = 0;
f232df0d	412	AliTrackReference *tr[2] = {NULL, NULL};
1ee39b3a	413	AliTrackReference * const* jtr = &fTrackRefs[0];
	414	for(Int_t itr = 0; itr < fNTrackRefs; itr++, ++jtr){
	415	if(!(*jtr)) break;
	416	/*
	417	if(fDebugLevel>=5) printf("\t\tref[%2d] x[%6.3f]\n", itr, (jtr)->LocalX());/
	418	if(TMath::Abs(x0 - (*jtr)->LocalX()) > cw) continue;
	419	tr[nFound++] = (*jtr);
	420	if(nFound == 2) break;
	421	}
	422	if(nFound < 2){
f232df0d	423	AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", Form("Missing track ref x0[%6.3f] nref[%d]", x0, nFound));
1ee39b3a	424	if(!nFound) SETBIT(status, 0);
	425	else SETBIT(status, 1);
	426	return kFALSE;
	427	}
	428	if((pt=tr[1]->Pt()) < 1.e-3) return kFALSE;
	429
	430	Double_t dx = tr[1]->LocalX() - tr[0]->LocalX();
	431	if(dx <= 0.){
	432	AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", Form("Track ref with wrong radial distances refX0[%6.3f] refX1[%6.3f]", tr[0]->LocalX(), tr[1]->LocalX()));
	433	SETBIT(status, 2);
	434	return kFALSE;
	435	}
	436	if(TMath::Abs(dx-AliTRDgeometry::CamHght()-AliTRDgeometry::CdrHght())>1.E-3) SETBIT(status, 3);
	437
	438	dydx = (tr[1]->LocalY() - tr[0]->LocalY()) / dx;
	439	dzdx = (tr[1]->Z() - tr[0]->Z()) / dx;
	440	//Float_t dx0 = tr[1]->LocalX() - x0;
	441	y0 = tr[1]->LocalY()/* - dydxdx0/;
	442	z0 = tr[1]->Z()/* - dzdxdx0/;
	443	x0 = tr[1]->LocalX();
	444	return kTRUE;
	445	}
	446
	447	//___________________________________________________
5066aa9a	448	void AliTRDtrackInfo::AliMCinfo::PropagateKalman(TVectorD dx, TVectorD dy, TVectorD dz, TVectorD pt, TVectorD dpt, TVectorD c) const
1ee39b3a	449	{
	450	// Propagate Kalman from the first TRD track reference to
	451	// last one and save residuals in the y, z and pt.
	452	//
	453	// This is to calibrate the dEdx and MS corrections
	454
4226db3e	455	if(!fNTrackRefs) return;
1ee39b3a	456	for(Int_t itr=kNTrackRefs; itr--;){
4226db3e	457	(dx)[itr] = -1.; (dy)[itr] = 100.; (dz)[itr] = 100.; (dpt)[itr] = 100.;
1ee39b3a	458	}
1ee39b3a	459
1ee39b3a	460	// Initialize TRD track to the first track reference
4226db3e	461	AliTrackReference *tr(NULL);
4226db3e	462	Int_t itr(0); while(!(tr = fTrackRefs[itr])) itr++;
1ee39b3a	463	if(tr->Pt()<1.e-3) return;
	464
	465	AliTRDtrackV1 tt;
	466	Double_t xyz[3]={tr->X(),tr->Y(),tr->Z()};
	467	Double_t pxyz[3]={tr->Px(),tr->Py(),tr->Pz()};
	468	Double_t var[6] = {1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4};
	469	Double_t cov[21]={
	470	var[0], 0., 0., 0., 0., 0.,
	471	var[1], 0., 0., 0., 0.,
	472	var[2], 0., 0., 0.,
	473	var[3], 0., 0.,
	474	var[4], 0.,
	475	var[5]
	476	};
	477	TDatabasePDG db;
	478	const TParticlePDG *pdg=db.GetParticle(fPDG);
	479	if(!pdg){
	480	AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::PropagateKalman()", Form("PDG entry missing for code %d. References for track %d", fPDG, fNTrackRefs));
	481	return;
	482	}
	483	tt.Set(xyz, pxyz, cov, Short_t(pdg->Charge()));
	484	tt.SetMass(pdg->Mass());
	485
4226db3e	486	Double_t x0(tr->LocalX());
	487	const Double_t *cc(NULL);
	488	for(Int_t ip=0; itr<fNTrackRefs; itr++){
	489	if(!(tr = fTrackRefs[itr])) continue;
5066aa9a	490	if(!AliTRDtrackerV1::PropagateToX(tt, tr->LocalX(), fgKalmanStep)) continue;
1ee39b3a	491
1ee39b3a	492	//if(update) ...
4226db3e	493	(*dx)[ip] = tt.GetX() - x0;
	494	(*dy)[ip] = tt.GetY() - tr->LocalY();
	495	(*dz)[ip] = tt.GetZ() - tr->Z();
5066aa9a	496	(*pt)[ip] = tr->Pt();
4226db3e	497	(*dpt)[ip] = tt.Pt()- tr->Pt();
1ee39b3a	498	cc = tt.GetCovariance();
4226db3e	499	c->Use(ip15, (ip+1)15, cc);
1ee39b3a	500	ip++;
	501	}
	502	}