[u/mrichter/AliRoot.git] / STEER / AliESDfriendTrack.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.                  *
 **************************************************************************/

//-------------------------------------------------------------------------
//               Implementation of the AliESDfriendTrack class
//  This class keeps complementary to the AliESDtrack information 
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
#include "AliTrackPointArray.h"
#include "AliESDfriendTrack.h"
#include "TObjArray.h"
#include "AliKalmanTrack.h"

ClassImp(AliESDfriendTrack)

AliESDfriendTrack::AliESDfriendTrack(): 
TObject(), 
f1P(0), 
fnMaxITScluster(0),
fnMaxTPCcluster(0),
fnMaxTRDcluster(0),
fITSindex(0x0),
fTPCindex(0x0),
fTRDindex(0x0),
fPoints(0),
fCalibContainer(0),
fITStrack(0),
fTRDtrack(0),
fTPCOut(0),
fITSOut(0),
fTRDIn(0)
{
  //
  // Default constructor
  //
	//  Int_t i;
  //  fITSindex = new Int_t[fnMaxITScluster];
  //fTPCindex = new Int_t[fnMaxTPCcluster];
  //fTRDindex = new Int_t[fnMaxTRDcluster];
  //for (i=0; i<kMaxITScluster; i++) fITSindex[i]=-2;
  //for (i=0; i<kMaxTPCcluster; i++) fTPCindex[i]=-2;
  //for (i=0; i<kMaxTRDcluster; i++) fTRDindex[i]=-2;
}

AliESDfriendTrack::AliESDfriendTrack(const AliESDfriendTrack &t): 
TObject(t),
f1P(t.f1P),
fnMaxITScluster(t.fnMaxITScluster),
fnMaxTPCcluster(t.fnMaxTPCcluster),
fnMaxTRDcluster(t.fnMaxTRDcluster),
fITSindex(0x0),
fTPCindex(0x0),
fTRDindex(0x0),
fPoints(0),
fCalibContainer(0),
fITStrack(0),
fTRDtrack(0),
fTPCOut(0),
fITSOut(0),
fTRDIn(0)
{
  //
  // Copy constructor
  //
  AliDebug(2,"Calling copy constructor");

  Int_t i;
  if (fnMaxITScluster != 0){
	  fITSindex = new Int_t[fnMaxITScluster];
	  for (i=0; i<fnMaxITScluster; i++) fITSindex[i]=t.fITSindex[i];
  }
  if (fnMaxTPCcluster != 0){
	  fTPCindex = new Int_t[fnMaxTPCcluster];
	  for (i=0; i<fnMaxTPCcluster; i++) fTPCindex[i]=t.fTPCindex[i];
  }
  if (fnMaxTRDcluster != 0){
	  fTRDindex = new Int_t[fnMaxTRDcluster];
	  for (i=0; i<fnMaxTRDcluster; i++) fTRDindex[i]=t.fTRDindex[i]; 
  }
  AliDebug(2,Form("fnMaxITScluster = %d",fnMaxITScluster));
  AliDebug(2,Form("fnMaxTPCcluster = %d",fnMaxTPCcluster));
  AliDebug(2,Form("fnMaxTRDcluster = %d",fnMaxTRDcluster));
  if (t.fPoints) fPoints=new AliTrackPointArray(*t.fPoints);
  if (t.fCalibContainer) {
     fCalibContainer = new TObjArray(5);
     Int_t no=t.fCalibContainer->GetEntriesFast();
     for (i=0; i<no; i++) {
       TObject *o=t.fCalibContainer->At(i);
       fCalibContainer->AddLast(o->Clone());
     }  
  }

  if (t.fTPCOut) fTPCOut = new AliExternalTrackParam(*(t.fTPCOut));
  if (t.fITSOut) fITSOut = new AliExternalTrackParam(*(t.fITSOut));
  if (t.fTRDIn)  fTRDIn = new AliExternalTrackParam(*(t.fTRDIn));

}

AliESDfriendTrack::~AliESDfriendTrack() {
  //
  // Simple destructor
  //
   delete fPoints;
   if (fCalibContainer) fCalibContainer->Delete();
   delete fCalibContainer;
   delete fITStrack;
   delete fTRDtrack;
   delete fTPCOut;
   delete fITSOut;
   delete fTRDIn;
   delete[] fITSindex;
   delete[] fTPCindex;
   delete[] fTRDindex;
}


void AliESDfriendTrack::AddCalibObject(TObject * calibObject){
  //
  // add calibration object to array -
  // track is owner of the objects in the container 
  //
  if (!fCalibContainer) fCalibContainer = new TObjArray(5);
  fCalibContainer->AddLast(calibObject);
}

TObject * AliESDfriendTrack::GetCalibObject(Int_t index){
  //
  //
  //
  if (!fCalibContainer) return 0;
  if (index>=fCalibContainer->GetEntriesFast()) return 0;
  return fCalibContainer->At(index);
}


void AliESDfriendTrack::SetTPCOut(const AliExternalTrackParam &param) {
  // 
  // backup TPC out track
  //
  delete fTPCOut;
  fTPCOut=new AliExternalTrackParam(param);
} 
void AliESDfriendTrack::SetITSOut(const AliExternalTrackParam &param) {
  //
  // backup ITS out track
  //
  delete fITSOut;
  fITSOut=new AliExternalTrackParam(param);
} 
void AliESDfriendTrack::SetTRDIn(const AliExternalTrackParam  &param)  {
  //
  // backup TRD in track
  //
  delete fTRDIn;
  fTRDIn=new AliExternalTrackParam(param);
} 

void AliESDfriendTrack::SetITSIndices(Int_t* indices, Int_t n){

	//
	// setting fITSindex
	// instantiating the pointer if still NULL
	//

	fnMaxITScluster = n;
	AliDebug(2,Form("fnMaxITScluster = %d",fnMaxITScluster));
	if (fITSindex == 0x0){
		fITSindex = new Int_t[fnMaxITScluster];
	}
	for (Int_t i = 0; i < fnMaxITScluster; i++){
		fITSindex[i] = indices[i];
	}
}

void AliESDfriendTrack::SetTPCIndices(Int_t* indices, Int_t n){

	//
	// setting fTPCindex
	// instantiating the pointer if still NULL
	//

	fnMaxTPCcluster = n;
	AliDebug(2,Form("fnMaxTPCcluster = %d",fnMaxTPCcluster));
	if (fTPCindex == 0x0){
		fTPCindex = new Int_t[fnMaxTPCcluster];
	}
	for (Int_t i = 0; i < fnMaxTPCcluster; i++){
		fTPCindex[i] = indices[i];
	}
}

void AliESDfriendTrack::SetTRDIndices(Int_t* indices, Int_t n){

	//
	// setting fTRDindex
	// instantiating the pointer if still NULL
	//

	fnMaxTRDcluster = n;
	AliDebug(2,Form("fnMaxTRDcluster = %d",fnMaxTRDcluster));
	if (fTRDindex == 0x0){
		fTRDindex = new Int_t[fnMaxTRDcluster];
	}
	for (Int_t i = 0; i < fnMaxTRDcluster; i++){
		fTRDindex[i] = indices[i];
	}
}
Commit	Line	Data
1d99986f	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	//-------------------------------------------------------------------------
	17	// Implementation of the AliESDfriendTrack class
	18	// This class keeps complementary to the AliESDtrack information
	19	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
	20	//-------------------------------------------------------------------------
	21	#include "AliTrackPointArray.h"
	22	#include "AliESDfriendTrack.h"
00dce61a	23	#include "TObjArray.h"
be713d4d	24	#include "AliKalmanTrack.h"
1d99986f	25
	26	ClassImp(AliESDfriendTrack)
	27
15e85efa	28	AliESDfriendTrack::AliESDfriendTrack():
	29	TObject(),
	30	f1P(0),
6d3a7bbf	31	fnMaxITScluster(0),
	32	fnMaxTPCcluster(0),
	33	fnMaxTRDcluster(0),
	34	fITSindex(0x0),
	35	fTPCindex(0x0),
	36	fTRDindex(0x0),
00dce61a	37	fPoints(0),
00dce61a	38	fCalibContainer(0),
15e85efa	39	fITStrack(0),
ded25cc6	40	fTRDtrack(0),
	41	fTPCOut(0),
	42	fITSOut(0),
	43	fTRDIn(0)
15e85efa	44	{
1d99986f	45	//
	46	// Default constructor
	47	//
6d3a7bbf	48	// Int_t i;
	49	// fITSindex = new Int_t[fnMaxITScluster];
	50	//fTPCindex = new Int_t[fnMaxTPCcluster];
	51	//fTRDindex = new Int_t[fnMaxTRDcluster];
	52	//for (i=0; i<kMaxITScluster; i++) fITSindex[i]=-2;
	53	//for (i=0; i<kMaxTPCcluster; i++) fTPCindex[i]=-2;
	54	//for (i=0; i<kMaxTRDcluster; i++) fTRDindex[i]=-2;
1d99986f	55	}
	56
	57	AliESDfriendTrack::AliESDfriendTrack(const AliESDfriendTrack &t):
	58	TObject(t),
	59	f1P(t.f1P),
6d3a7bbf	60	fnMaxITScluster(t.fnMaxITScluster),
	61	fnMaxTPCcluster(t.fnMaxTPCcluster),
	62	fnMaxTRDcluster(t.fnMaxTRDcluster),
	63	fITSindex(0x0),
	64	fTPCindex(0x0),
	65	fTRDindex(0x0),
15e85efa	66	fPoints(0),
00dce61a	67	fCalibContainer(0),
15e85efa	68	fITStrack(0),
ded25cc6	69	fTRDtrack(0),
	70	fTPCOut(0),
	71	fITSOut(0),
	72	fTRDIn(0)
1d99986f	73	{
	74	//
	75	// Copy constructor
	76	//
6d3a7bbf	77	AliDebug(2,"Calling copy constructor");
6d3a7bbf	78
1d99986f	79	Int_t i;
6d3a7bbf	80	if (fnMaxITScluster != 0){
	81	fITSindex = new Int_t[fnMaxITScluster];
	82	for (i=0; i<fnMaxITScluster; i++) fITSindex[i]=t.fITSindex[i];
	83	}
	84	if (fnMaxTPCcluster != 0){
	85	fTPCindex = new Int_t[fnMaxTPCcluster];
	86	for (i=0; i<fnMaxTPCcluster; i++) fTPCindex[i]=t.fTPCindex[i];
	87	}
	88	if (fnMaxTRDcluster != 0){
	89	fTRDindex = new Int_t[fnMaxTRDcluster];
	90	for (i=0; i<fnMaxTRDcluster; i++) fTRDindex[i]=t.fTRDindex[i];
	91	}
	92	AliDebug(2,Form("fnMaxITScluster = %d",fnMaxITScluster));
	93	AliDebug(2,Form("fnMaxTPCcluster = %d",fnMaxTPCcluster));
	94	AliDebug(2,Form("fnMaxTRDcluster = %d",fnMaxTRDcluster));
1d99986f	95	if (t.fPoints) fPoints=new AliTrackPointArray(*t.fPoints);
f333ed51	96	if (t.fCalibContainer) {
	97	fCalibContainer = new TObjArray(5);
	98	Int_t no=t.fCalibContainer->GetEntriesFast();
6c27b212	99	for (i=0; i<no; i++) {
f333ed51	100	TObject *o=t.fCalibContainer->At(i);
	101	fCalibContainer->AddLast(o->Clone());
	102	}
	103	}
ded25cc6	104
	105	if (t.fTPCOut) fTPCOut = new AliExternalTrackParam(*(t.fTPCOut));
	106	if (t.fITSOut) fITSOut = new AliExternalTrackParam(*(t.fITSOut));
	107	if (t.fTRDIn) fTRDIn = new AliExternalTrackParam(*(t.fTRDIn));
6d3a7bbf	108
1d99986f	109	}
1d99986f	110
15e85efa	111	AliESDfriendTrack::~AliESDfriendTrack() {
1d99986f	112	//
15e85efa	113	// Simple destructor
1d99986f	114	//
15e85efa	115	delete fPoints;
f333ed51	116	if (fCalibContainer) fCalibContainer->Delete();
2c56c9f6	117	delete fCalibContainer;
15e85efa	118	delete fITStrack;
15e85efa	119	delete fTRDtrack;
ded25cc6	120	delete fTPCOut;
	121	delete fITSOut;
	122	delete fTRDIn;
82c82b62	123	delete[] fITSindex;
	124	delete[] fTPCindex;
	125	delete[] fTRDindex;
1d99986f	126	}
00dce61a	127
	128
	129	void AliESDfriendTrack::AddCalibObject(TObject * calibObject){
	130	//
	131	// add calibration object to array -
	132	// track is owner of the objects in the container
	133	//
	134	if (!fCalibContainer) fCalibContainer = new TObjArray(5);
	135	fCalibContainer->AddLast(calibObject);
	136	}
	137
	138	TObject * AliESDfriendTrack::GetCalibObject(Int_t index){
	139	//
	140	//
	141	//
	142	if (!fCalibContainer) return 0;
	143	if (index>=fCalibContainer->GetEntriesFast()) return 0;
	144	return fCalibContainer->At(index);
	145	}
ded25cc6	146
	147
	148	void AliESDfriendTrack::SetTPCOut(const AliExternalTrackParam &param) {
	149	//
	150	// backup TPC out track
	151	//
	152	delete fTPCOut;
	153	fTPCOut=new AliExternalTrackParam(param);
	154	}
	155	void AliESDfriendTrack::SetITSOut(const AliExternalTrackParam &param) {
	156	//
	157	// backup ITS out track
	158	//
	159	delete fITSOut;
	160	fITSOut=new AliExternalTrackParam(param);
	161	}
	162	void AliESDfriendTrack::SetTRDIn(const AliExternalTrackParam &param) {
	163	//
	164	// backup TRD in track
	165	//
	166	delete fTRDIn;
	167	fTRDIn=new AliExternalTrackParam(param);
	168	}
	169
6d3a7bbf	170	void AliESDfriendTrack::SetITSIndices(Int_t* indices, Int_t n){
	171
	172	//
	173	// setting fITSindex
	174	// instantiating the pointer if still NULL
	175	//
	176
	177	fnMaxITScluster = n;
	178	AliDebug(2,Form("fnMaxITScluster = %d",fnMaxITScluster));
	179	if (fITSindex == 0x0){
	180	fITSindex = new Int_t[fnMaxITScluster];
	181	}
	182	for (Int_t i = 0; i < fnMaxITScluster; i++){
	183	fITSindex[i] = indices[i];
	184	}
	185	}
	186
	187	void AliESDfriendTrack::SetTPCIndices(Int_t* indices, Int_t n){
	188
	189	//
	190	// setting fTPCindex
	191	// instantiating the pointer if still NULL
	192	//
	193
	194	fnMaxTPCcluster = n;
	195	AliDebug(2,Form("fnMaxTPCcluster = %d",fnMaxTPCcluster));
	196	if (fTPCindex == 0x0){
	197	fTPCindex = new Int_t[fnMaxTPCcluster];
	198	}
	199	for (Int_t i = 0; i < fnMaxTPCcluster; i++){
	200	fTPCindex[i] = indices[i];
	201	}
	202	}
	203
	204	void AliESDfriendTrack::SetTRDIndices(Int_t* indices, Int_t n){
	205
	206	//
	207	// setting fTRDindex
	208	// instantiating the pointer if still NULL
	209	//
	210
	211	fnMaxTRDcluster = n;
	212	AliDebug(2,Form("fnMaxTRDcluster = %d",fnMaxTRDcluster));
	213	if (fTRDindex == 0x0){
	214	fTRDindex = new Int_t[fnMaxTRDcluster];
	215	}
	216	for (Int_t i = 0; i < fnMaxTRDcluster; i++){
	217	fTRDindex[i] = indices[i];
	218	}
	219	}
	220