[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDTracklet.cxx

#include "AliHLTTRDTracklet.h"
#include "AliHLTTRDCluster.h"

/**
 * Default Constructor
 */
//============================================================================
AliHLTTRDTracklet::AliHLTTRDTracklet():
  fTRDtracklet(NULL),
  fSize(sizeof(AliHLTTRDTracklet)),
  fSigmaY(-1),
  fSigmaY2(-1),
  fTilt(-1),
  fPadLength(-1),
  fX0(-1),
  fMeanz(-1),
  fZProb(-1),
  fN(-1),
  fN2(-1),
  fNUsed(-1),
  fFreq(-1),
  fNChange(-1),
  fMPads(-1),
  fC(-1),
  fCC(-1),
  fChi2(-1),
  fChi2Z(-1),
  fDet(-1),
  fMom(-1),
  fdX(-1)
{
  InitArrays();
}

/**
 * Main Constructor
 */
//============================================================================
AliHLTTRDTracklet::AliHLTTRDTracklet(AliTRDseedV1 * inTracklet):
  fTRDtracklet(NULL),
  fSize(sizeof(AliHLTTRDTracklet)),
  fSigmaY(-1),
  fSigmaY2(-1),
  fTilt(-1),
  fPadLength(-1),
  fX0(-1),
  fMeanz(-1),
  fZProb(-1),
  fN(-1),
  fN2(-1),
  fNUsed(-1),
  fFreq(-1),
  fNChange(-1),
  fMPads(-1),
  fC(-1),
  fCC(-1),
  fChi2(-1),
  fChi2Z(-1),
  fDet(-1),
  fMom(-1),
  fdX(-1)
{
  InitArrays();
 
  fTRDtracklet = inTracklet;
  CopyDataMembers();
  //  Print(kFALSE);
  AddClusters();
}

/**
 * Add clusters to the HLTTRDTracklet
 */
//============================================================================
void AliHLTTRDTracklet::AddClusters()
{
  for (Int_t iTimeBin = 0; iTimeBin < knTimebins; iTimeBin++)
    {
//       if (fClusters[iTimeBin])
// 	HLTWarning("Trying to rewrite cluster in tracklet. Not good.");
      AliTRDcluster* trdCluster = fTRDtracklet->GetClusters(iTimeBin);
      if (trdCluster){
	AliHLTTRDCluster * hltCluster = new (GetEndPointer()) AliHLTTRDCluster(trdCluster);
	fSize += hltCluster->GetSize();
	//HLTInfo("cluster %i; adr 0x%x; endPointer 0x%x; fSize %i", iTimeBin, hltCluster, GetEndPointer(), fSize);
	fClusters[iTimeBin] = hltCluster;
      }
      else 
	fClusters[iTimeBin] = NULL;
      
    }
}

/**
 * Copy simple (non-pointer) data members from TRDTracklet to HLTTRDTracklet 
 */
//============================================================================  
void AliHLTTRDTracklet::CopyDataMembers()
{
  for (Int_t i=0; i < 2; i++){
    fYref[i] = fTRDtracklet->GetYref(i);
    fZref[i] = fTRDtracklet->GetZref(i);
  }
  fSigmaY = fTRDtracklet->GetSigmaY();
  fSigmaY2 = fTRDtracklet->GetSigmaY2();
  fTilt = fTRDtracklet->GetTilt();
  fPadLength = fTRDtracklet->GetPadLength();
  
  fX0 = fTRDtracklet->GetX0();
  for (Int_t i = 0; i < knTimebins; i++){
    fX[i] = fTRDtracklet->GetX(i);
    fY[i] = fTRDtracklet->GetY(i);
    fZ[i] = fTRDtracklet->GetZ(i);
    fIndexes[i] = fTRDtracklet->GetIndexes(i);
    fUsable[i] = fTRDtracklet->IsUsable(i);
  }

  for (Int_t i=0; i < 2; i++){
    fYfit[i] = fTRDtracklet->GetYfit(i);
    fZfit[i] = fTRDtracklet->GetZfit(i);
    fYfitR[i] = fTRDtracklet->GetYfitR(i);
    fZfitR[i] = fTRDtracklet->GetZfitR(i);
    fLabels[i] = fTRDtracklet->GetLabels(i);
  }
  
  fMeanz   = fTRDtracklet->GetMeanz();
  fZProb   = fTRDtracklet->GetZProb();
  fN       = fTRDtracklet->GetNbClusters();
  fN2      = fTRDtracklet->GetN2();
  fNUsed   = fTRDtracklet->GetNUsed();
  fFreq    = fTRDtracklet->GetFreq();
  fNChange = fTRDtracklet->GetNChange();
  fMPads = fTRDtracklet->GetMPads();
   
  fC = fTRDtracklet->GetC();
  fCC = fTRDtracklet->GetCC();
  fChi2 = fTRDtracklet->GetChi2();
  fChi2Z = fTRDtracklet->GetChi2Z();
  
  fDet = fTRDtracklet->GetDetector();
  fMom = fTRDtracklet->GetMomentum();
  fdX = fTRDtracklet->GetdX();
  
}

/**
 * Copy data to the output TRDseedV1
 */
//============================================================================
void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1 *outTracklet)
{
  outTracklet->Reset();
  /* ======= From AliTRDseedV1 ======== */
  outTracklet->SetDetector(fDet);
  outTracklet->SetMomentum(fMom);
  outTracklet->SetDX(fdX);
  
  /* ======= From AliTRDseed ======== */
  for (Int_t i=0; i < 2; i++){
    outTracklet->SetYref(i, fYref[i]);
    outTracklet->SetZref(i, fZref[i]);
  }
  
  outTracklet->SetSigmaY(fSigmaY);
  outTracklet->SetSigmaY2(fSigmaY2);
  outTracklet->SetTilt(fTilt);
  outTracklet->SetPadLength(fPadLength);
  outTracklet->SetX0(fX0);

  for (Int_t i=0; i < knTimebins; i++){
    outTracklet->SetX(i,fX[i]);
    outTracklet->SetX(i,fY[i]);
    outTracklet->SetX(i,fZ[i]);
    outTracklet->SetIndexes(i, fIndexes[i]);
    outTracklet->SetUsable(i, fUsable[i]);
  }
  for (Int_t i=0; i < 2; i++){
    outTracklet->SetYfit(i,fYfit[i]);
    outTracklet->SetYfitR(i,fYfitR[i]);
    outTracklet->SetZfit(i,fZfit[i]);
    outTracklet->SetZfitR(i,fZfitR[i]);
    outTracklet->SetLabels(i,fLabels[i]);
  }
  
  outTracklet->SetMeanz(fMeanz);
  outTracklet->SetZProb(fZProb);
  outTracklet->SetN(fN);
  outTracklet->SetN2(fN2);
  outTracklet->SetNUsed(fNUsed);
  outTracklet->SetFreq(fFreq);
  outTracklet->SetNChange(fNChange);
  outTracklet->SetMPads(fMPads);
  outTracklet->SetC(fC);
  outTracklet->SetCC(fCC);
  outTracklet->SetChi2(fChi2);
  outTracklet->SetChi2Z(fChi2Z);

  for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
    if (fClusters[iCluster]){
      AliTRDcluster *trdCluster = new AliTRDcluster();
      fClusters[iCluster]->ExportTRDCluster(trdCluster);
      outTracklet->SetClusters(iCluster, trdCluster);
    }
  }
  
}


/**
 * Init arrays
 */
//============================================================================
void AliHLTTRDTracklet::InitArrays()
{
  for (Int_t i=0; i < knTimebins; i++){
    fClusters[i] = NULL;
  }

  for (Int_t i=0; i < 2; i++){
    fYref[i] = -1;
    fZref[i] = -1;
  }
  for (Int_t i = 0; i < knTimebins; i++){
    fX[i] = -1;
    fY[i] = -1;
    fZ[i] = -1;
    fIndexes[i] = -1;
    fUsable[i] = -1;
  }

  for (Int_t i=0; i < 2; i++){
    fYfit[i] = -1;
    fZfit[i] = -1;
    fYfitR[i] = -1;
    fZfitR[i] = -1;
    fLabels[i] = -1;
  }
  
}

/**
 * Prints main info about tracklet
 */
//============================================================================
void AliHLTTRDTracklet::Print(Bool_t printClusters)
{
  //printf("--hltTracklet-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
  printf("      fDet %i; dMom %f; fdX %f fN %i\n", fDet, fMom, fdX, fN);

  if (printClusters){
    
    for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
      printf(" [%i] ",iCluster);
      if (fClusters[iCluster]){
	fClusters[iCluster]->Print();
      }
      else 
	printf("      NULL\n");
    }
  }
  
}

/**
 * Read clusters to TRDtracklet from the memory
 */
//============================================================================
void AliHLTTRDTracklet::ReadClustersFromMemory(void *input)
{
  AliHLTUInt8_t *iterPtr = (AliHLTUInt8_t*) input;
  AliHLTTRDCluster* hltCluster = NULL;
  
  for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
    // if we had something in the fClusters[iCluster] before copying,
    // then this entry in the array should not be empty. Fill it.
    if (fClusters[iCluster]){
      hltCluster = (AliHLTTRDCluster*) iterPtr;
      fClusters[iCluster] = hltCluster;
      iterPtr += hltCluster->GetSize();
      //hltCluster->Print();
    }
    
  }
}
Commit	Line	Data
d679dd6c	1	#include "AliHLTTRDTracklet.h"
	2	#include "AliHLTTRDCluster.h"
	3
	4	/**
	5	* Default Constructor
	6	*/
	7	//============================================================================
	8	AliHLTTRDTracklet::AliHLTTRDTracklet():
	9	fTRDtracklet(NULL),
	10	fSize(sizeof(AliHLTTRDTracklet)),
	11	fSigmaY(-1),
	12	fSigmaY2(-1),
	13	fTilt(-1),
	14	fPadLength(-1),
	15	fX0(-1),
	16	fMeanz(-1),
	17	fZProb(-1),
	18	fN(-1),
	19	fN2(-1),
	20	fNUsed(-1),
	21	fFreq(-1),
	22	fNChange(-1),
	23	fMPads(-1),
	24	fC(-1),
	25	fCC(-1),
	26	fChi2(-1),
	27	fChi2Z(-1),
	28	fDet(-1),
	29	fMom(-1),
	30	fdX(-1)
	31	{
	32	InitArrays();
	33	}
	34
	35	/**
	36	* Main Constructor
	37	*/
	38	//============================================================================
	39	AliHLTTRDTracklet::AliHLTTRDTracklet(AliTRDseedV1 * inTracklet):
	40	fTRDtracklet(NULL),
	41	fSize(sizeof(AliHLTTRDTracklet)),
	42	fSigmaY(-1),
	43	fSigmaY2(-1),
	44	fTilt(-1),
	45	fPadLength(-1),
	46	fX0(-1),
	47	fMeanz(-1),
	48	fZProb(-1),
	49	fN(-1),
	50	fN2(-1),
	51	fNUsed(-1),
	52	fFreq(-1),
	53	fNChange(-1),
	54	fMPads(-1),
	55	fC(-1),
	56	fCC(-1),
	57	fChi2(-1),
	58	fChi2Z(-1),
	59	fDet(-1),
	60	fMom(-1),
	61	fdX(-1)
	62	{
	63	InitArrays();
	64
65	fTRDtracklet = inTracklet;
66	CopyDataMembers();
67	// Print(kFALSE);
68	AddClusters();
69	}
70
71	/**
72	* Add clusters to the HLTTRDTracklet
73	*/
74	//============================================================================
75	void AliHLTTRDTracklet::AddClusters()
76	{
77	for (Int_t iTimeBin = 0; iTimeBin < knTimebins; iTimeBin++)
78	{
79	// if (fClusters[iTimeBin])
80	// HLTWarning("Trying to rewrite cluster in tracklet. Not good.");
81	AliTRDcluster* trdCluster = fTRDtracklet->GetClusters(iTimeBin);
82	if (trdCluster){
83	AliHLTTRDCluster * hltCluster = new (GetEndPointer()) AliHLTTRDCluster(trdCluster);
84	fSize += hltCluster->GetSize();
85	//HLTInfo("cluster %i; adr 0x%x; endPointer 0x%x; fSize %i", iTimeBin, hltCluster, GetEndPointer(), fSize);
86	fClusters[iTimeBin] = hltCluster;
87	}
88	else
89	fClusters[iTimeBin] = NULL;
90
91	}
92	}
93
94	/**
95	* Copy simple (non-pointer) data members from TRDTracklet to HLTTRDTracklet
96	*/
97	//============================================================================
98	void AliHLTTRDTracklet::CopyDataMembers()
99	{
100	for (Int_t i=0; i < 2; i++){
101	fYref[i] = fTRDtracklet->GetYref(i);
102	fZref[i] = fTRDtracklet->GetZref(i);
103	}
104	fSigmaY = fTRDtracklet->GetSigmaY();
105	fSigmaY2 = fTRDtracklet->GetSigmaY2();
106	fTilt = fTRDtracklet->GetTilt();
107	fPadLength = fTRDtracklet->GetPadLength();
108
109	fX0 = fTRDtracklet->GetX0();
110	for (Int_t i = 0; i < knTimebins; i++){
111	fX[i] = fTRDtracklet->GetX(i);
112	fY[i] = fTRDtracklet->GetY(i);
113	fZ[i] = fTRDtracklet->GetZ(i);
114	fIndexes[i] = fTRDtracklet->GetIndexes(i);
115	fUsable[i] = fTRDtracklet->IsUsable(i);
116	}
117
118	for (Int_t i=0; i < 2; i++){
119	fYfit[i] = fTRDtracklet->GetYfit(i);
120	fZfit[i] = fTRDtracklet->GetZfit(i);
121	fYfitR[i] = fTRDtracklet->GetYfitR(i);
122	fZfitR[i] = fTRDtracklet->GetZfitR(i);
123	fLabels[i] = fTRDtracklet->GetLabels(i);
124	}
125
126	fMeanz = fTRDtracklet->GetMeanz();
127	fZProb = fTRDtracklet->GetZProb();
128	fN = fTRDtracklet->GetNbClusters();
129	fN2 = fTRDtracklet->GetN2();
130	fNUsed = fTRDtracklet->GetNUsed();
131	fFreq = fTRDtracklet->GetFreq();
132	fNChange = fTRDtracklet->GetNChange();
133	fMPads = fTRDtracklet->GetMPads();
134
135	fC = fTRDtracklet->GetC();
136	fCC = fTRDtracklet->GetCC();
137	fChi2 = fTRDtracklet->GetChi2();
138	fChi2Z = fTRDtracklet->GetChi2Z();
139
140	fDet = fTRDtracklet->GetDetector();
141	fMom = fTRDtracklet->GetMomentum();
142	fdX = fTRDtracklet->GetdX();
143
144	}
145
146	/**
147	* Copy data to the output TRDseedV1
148	*/
149	//============================================================================
150	void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1 *outTracklet)
151	{
152	outTracklet->Reset();
153	/* ======= From AliTRDseedV1 ======== */
154	outTracklet->SetDetector(fDet);
155	outTracklet->SetMomentum(fMom);
156	outTracklet->SetDX(fdX);
157
158	/* ======= From AliTRDseed ======== */
159	for (Int_t i=0; i < 2; i++){
160	outTracklet->SetYref(i, fYref[i]);
161	outTracklet->SetZref(i, fZref[i]);
162	}
163
164	outTracklet->SetSigmaY(fSigmaY);
165	outTracklet->SetSigmaY2(fSigmaY2);
166	outTracklet->SetTilt(fTilt);
167	outTracklet->SetPadLength(fPadLength);
168	outTracklet->SetX0(fX0);
169
170	for (Int_t i=0; i < knTimebins; i++){
171	outTracklet->SetX(i,fX[i]);
172	outTracklet->SetX(i,fY[i]);
173	outTracklet->SetX(i,fZ[i]);
174	outTracklet->SetIndexes(i, fIndexes[i]);
175	outTracklet->SetUsable(i, fUsable[i]);
176	}
177	for (Int_t i=0; i < 2; i++){
178	outTracklet->SetYfit(i,fYfit[i]);
179	outTracklet->SetYfitR(i,fYfitR[i]);
180	outTracklet->SetZfit(i,fZfit[i]);
181	outTracklet->SetZfitR(i,fZfitR[i]);
182	outTracklet->SetLabels(i,fLabels[i]);
183	}
184
185	outTracklet->SetMeanz(fMeanz);
186	outTracklet->SetZProb(fZProb);
187	outTracklet->SetN(fN);
188	outTracklet->SetN2(fN2);
189	outTracklet->SetNUsed(fNUsed);
190	outTracklet->SetFreq(fFreq);
191	outTracklet->SetNChange(fNChange);
192	outTracklet->SetMPads(fMPads);
193	outTracklet->SetC(fC);
194	outTracklet->SetCC(fCC);
195	outTracklet->SetChi2(fChi2);
196	outTracklet->SetChi2Z(fChi2Z);
197
198	for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
199	if (fClusters[iCluster]){
200	AliTRDcluster *trdCluster = new AliTRDcluster();
201	fClusters[iCluster]->ExportTRDCluster(trdCluster);
202	outTracklet->SetClusters(iCluster, trdCluster);
203	}
204	}
205
206	}
207
208
209	/**
210	* Init arrays
211	*/
212	//============================================================================
213	void AliHLTTRDTracklet::InitArrays()
214	{
215	for (Int_t i=0; i < knTimebins; i++){
216	fClusters[i] = NULL;
217	}
218
219	for (Int_t i=0; i < 2; i++){
220	fYref[i] = -1;
221	fZref[i] = -1;
222	}
223	for (Int_t i = 0; i < knTimebins; i++){
224	fX[i] = -1;
225	fY[i] = -1;
226	fZ[i] = -1;
227	fIndexes[i] = -1;
228	fUsable[i] = -1;
229	}
230
231	for (Int_t i=0; i < 2; i++){
232	fYfit[i] = -1;
233	fZfit[i] = -1;
234	fYfitR[i] = -1;
235	fZfitR[i] = -1;
236	fLabels[i] = -1;
237	}
238
239	}
240
241	/**
242	* Prints main info about tracklet
243	*/
244	//============================================================================
245	void AliHLTTRDTracklet::Print(Bool_t printClusters)
246	{
247	//printf("--hltTracklet-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
248	printf(" fDet %i; dMom %f; fdX %f fN %i\n", fDet, fMom, fdX, fN);
249
250	if (printClusters){
251
252	for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
253	printf(" [%i] ",iCluster);
254	if (fClusters[iCluster]){
255	fClusters[iCluster]->Print();
256	}
257	else
258	printf(" NULL\n");
259	}
260	}
261
262	}
263
264	/**
265	* Read clusters to TRDtracklet from the memory
266	*/
267	//============================================================================
268	void AliHLTTRDTracklet::ReadClustersFromMemory(void *input)
269	{
270	AliHLTUInt8_t iterPtr = (AliHLTUInt8_t) input;
271	AliHLTTRDCluster* hltCluster = NULL;
272
273	for (Int_t iCluster = 0; iCluster < knTimebins; iCluster++){
274	// if we had something in the fClusters[iCluster] before copying,
275	// then this entry in the array should not be empty. Fill it.
276	if (fClusters[iCluster]){
277	hltCluster = (AliHLTTRDCluster*) iterPtr;
278	fClusters[iCluster] = hltCluster;
279	iterPtr += hltCluster->GetSize();
280	//hltCluster->Print();
281	}
282
283	}
284	}