Line data Source code
1 : // $Id$
2 :
3 : /**************************************************************************
4 : * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 : * *
6 : * Authors: *
7 : * for The ALICE HLT Project. *
8 : * *
9 : * Permission to use, copy, modify and distribute this software and its *
10 : * documentation strictly for non-commercial purposes is hereby granted *
11 : * without fee, provided that the above copyright notice appears in all *
12 : * copies and that both the copyright notice and this permission notice *
13 : * appear in the supporting documentation. The authors make no claims *
14 : * about the suitability of this software for any purpose. It is *
15 : * provided "as is" without express or implied warranty. *
16 : **************************************************************************/
17 :
18 : // @file AliHLTTRDTracklet.cxx
19 : // @author Theodor Rascanu
20 : // @date
21 : // @brief A datacontainer for tracklets for the HLT.
22 : //
23 :
24 : #include "AliHLTTRDTracklet.h"
25 :
26 : /**
27 : * Default Constructor
28 : */
29 : //============================================================================
30 : AliHLTTRDTracklet::AliHLTTRDTracklet():
31 0 : fN(0),
32 0 : fdX(-1),
33 0 : fS2Y(-1),
34 0 : fPt(-1),
35 0 : fX0(-1),
36 0 : fChi2(-1),
37 : // fExB(-1),
38 : // fVD(-1),
39 : // fT0(-1),
40 : // fS2PRF(-1),
41 : // fDiffL(-1),
42 : // fDiffT(-1),
43 : // fX(-1),
44 : // fY(-1),
45 : // fZ(-1),
46 : // fS2Z(-1),
47 0 : fDet(-1),
48 0 : fBits(0),
49 0 : fCount(0),
50 : #if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
51 : fSize(sizeof(AliHLTTRDTracklet)-sizeof(fClusters[0])),
52 : #else
53 0 : fSize(sizeof(AliHLTTRDTracklet))
54 : #endif
55 0 : {
56 0 : InitArrays();
57 0 : }
58 :
59 : /**
60 : * Main Constructor
61 : */
62 : //============================================================================
63 : AliHLTTRDTracklet::AliHLTTRDTracklet(const AliTRDseedV1* const inTracklet):
64 0 : fN(inTracklet->fN),
65 0 : fdX(inTracklet->fdX),
66 0 : fS2Y(inTracklet->fS2Y),
67 0 : fPt(inTracklet->fPt),
68 0 : fX0(inTracklet->fX0),
69 0 : fChi2(inTracklet->fChi2),
70 : // fExB(inTracklet->fExB),
71 : // fVD(inTracklet->fVD),
72 : // fT0(inTracklet->fT0),
73 : // fS2PRF(inTracklet->fS2PRF),
74 : // fDiffL(inTracklet->fDiffL),
75 : // fDiffT(inTracklet->fDiffT),
76 : // fX(inTracklet->fX),
77 : // fY(inTracklet->fY),
78 : // fZ(inTracklet->fZ),
79 : // fS2Z(inTracklet->fS2Z),
80 0 : fDet(inTracklet->fDet),
81 0 : fBits(0),
82 0 : fCount(0),
83 : #if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
84 : fSize(sizeof(AliHLTTRDTracklet)-sizeof(fClusters[0])),
85 : #else
86 0 : fSize(sizeof(AliHLTTRDTracklet))
87 : #endif
88 0 : {
89 0 : CopyDataMembers(inTracklet);
90 0 : }
91 :
92 : /**
93 : * Copy simple (non-pointer) data members from TRDTracklet to HLTTRDTracklet
94 : */
95 : //============================================================================
96 : void AliHLTTRDTracklet::CopyDataMembers(const AliTRDseedV1* const inTracklet)
97 : {
98 0 : for (Int_t i=0; i < 2; i++){
99 0 : fYref[i] = inTracklet->fYref[i];
100 0 : fZref[i] = inTracklet->fZref[i];
101 0 : fYfit[i] = inTracklet->fYfit[i];
102 0 : fZfit[i] = inTracklet->fZfit[i];
103 : }
104 0 : fC[0] = inTracklet->GetC();
105 : #ifndef HAVE_NOT_ALITRD_SEEDV1_r39693
106 0 : fC[1] = inTracklet->GetC(1);
107 : #endif //HAVE_NOT_ALITRD_SEEDV1_r39693
108 0 : for (Int_t i=0; i < 3; i++){
109 0 : fPad[i] = inTracklet->fPad[i];
110 : // fCov[i] = inTracklet->fCov[i];
111 : }
112 :
113 : // for (Int_t i=0; i < 7; i++){
114 : // fRefCov[i] = inTracklet->fRefCov[i];
115 : // }
116 :
117 : // for (Int_t i=0; i < AliTRDseedV1::kNslices; i++){
118 : // fdEdx[i] = inTracklet->fdEdx[i];
119 : // }
120 :
121 0 : for (Int_t i=0; i < AliPID::kSPECIES; i++){
122 0 : fProb[i] = inTracklet->fProb[i];
123 : }
124 :
125 0 : fBits = UInt_t(inTracklet->TestBits(-1)) >> 14;
126 :
127 0 : for (Int_t iTimeBin = 0; iTimeBin < AliTRDseedV1::kNclusters; iTimeBin++){
128 0 : AliTRDcluster* trdCluster = inTracklet->GetClusters(iTimeBin);
129 0 : if (trdCluster){
130 0 : fPos[fCount] = iTimeBin;
131 0 : new (&fClusters[fCount]) AliHLTTRDExtCluster(trdCluster);
132 0 : fCount++;
133 0 : fSize += sizeof(fClusters[0]);
134 0 : }
135 : }
136 : //if((void*)&fClusters[fCount]!=(void*)GetEndPointer()){printf("ERRR");return;}
137 0 : }
138 :
139 : /**
140 : * Copy data to the output TRDseedV1
141 : */
142 : //============================================================================
143 : void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1* const outTracklet) const
144 : {
145 : //outTracklet->Reset(); we always use a fresh trdtracklet as input, so this is useless
146 0 : outTracklet->SetBit(AliTRDseedV1::kOwner);
147 :
148 0 : outTracklet->fN = fN;
149 0 : outTracklet->fdX = fdX;
150 0 : outTracklet->fX0 = fX0;
151 0 : outTracklet->fS2Y = fS2Y;
152 0 : outTracklet->fPt = fPt;
153 0 : outTracklet->SetC(fC[0]);
154 : #ifndef HAVE_NOT_ALITRD_SEEDV1_r39693
155 0 : outTracklet->SetC(fC[1], 1);
156 : #endif //HAVE_NOT_ALITRD_SEEDV1_r39693
157 0 : outTracklet->fChi2 = fChi2;
158 : // outTracklet->fExB = fExB;
159 : // outTracklet->fVD = fVD;
160 : // outTracklet->fT0 = fT0;
161 : // outTracklet->fS2PRF = fS2PRF;
162 : // outTracklet->fDiffL = fDiffL;
163 : // outTracklet->fDiffT = fDiffT;
164 : // outTracklet->fX = fX;
165 : // outTracklet->fY = fY;
166 : // outTracklet->fZ = fZ;
167 : // outTracklet->fS2Z = fS2Z;
168 0 : outTracklet->fDet = fDet;
169 :
170 0 : for (Int_t i=0; i < 2; i++){
171 0 : outTracklet->fYref[i] = fYref[i];
172 0 : outTracklet->fZref[i] = fZref[i];
173 0 : outTracklet->fYfit[i] = fYfit[i];
174 0 : outTracklet->fZfit[i] = fZfit[i];
175 : }
176 :
177 0 : for (Int_t i=0; i < 3; i++){
178 0 : outTracklet->fPad[i] = fPad[i];
179 : // outTracklet->fCov[i] = fCov[i];
180 : }
181 :
182 : // for (Int_t i=0; i < 7; i++){
183 : // outTracklet->fRefCov[i] = fRefCov[i];
184 : // }
185 :
186 : // for (Int_t i=0; i < AliTRDseedV1::kNslices; i++){
187 : // outTracklet->fdEdx[i] = fdEdx[i];
188 : // }
189 :
190 0 : for (Int_t i=0; i < AliPID::kSPECIES; i++){
191 0 : outTracklet->fProb[i] = fProb[i];
192 : }
193 :
194 0 : outTracklet->SetBit(UInt_t(fBits)<<14);
195 :
196 0 : for(Int_t iCluster=0; iCluster < fCount; iCluster++){
197 0 : AliTRDcluster *trdCluster = new AliTRDcluster();
198 0 : fClusters[iCluster].ExportTRDCluster(trdCluster);
199 0 : trdCluster->SetDetector(fDet);
200 0 : outTracklet->fClusters[fPos[iCluster]] = trdCluster;
201 0 : outTracklet->fIndexes[fPos[iCluster]] = iCluster;
202 : }
203 0 : }
204 :
205 :
206 : /**
207 : * Init arrays
208 : */
209 : //============================================================================
210 : void AliHLTTRDTracklet::InitArrays()
211 : {
212 0 : for (Int_t i=0; i < 2; i++){
213 0 : fYref[i] = -1;
214 0 : fZref[i] = -1;
215 0 : fYfit[i] = -1;
216 0 : fZfit[i] = -1;
217 : }
218 0 : fC[0] = 0.; fC[1] = 0.;
219 0 : for (Int_t i=0; i < AliPID::kSPECIES; i++)
220 0 : fProb[i]=0;
221 0 : for (Int_t i=0; i<AliTRDseedV1::kNclusters; i++)
222 0 : fPos[i]=0;
223 :
224 0 : }
225 :
226 : /**
227 : * Prints main info about tracklet
228 : */
229 : //============================================================================
230 : void AliHLTTRDTracklet::Print(Bool_t printClusters) const
231 : {
232 : //printf("--hltTracklet-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
233 0 : printf(" fDet %i; fPt %f; fdX %f fN %i\n", fDet, fPt, fdX, fN);
234 :
235 0 : if(!printClusters) return;
236 0 : for (UInt_t iCluster = 0; iCluster < fCount; iCluster++){
237 0 : printf(" [%i] ",iCluster);
238 0 : fClusters[iCluster].Print();
239 : }
240 0 : }
241 :
242 : /**
243 : * Save tracklet at block position
244 : */
245 : //============================================================================
246 : AliHLTUInt32_t AliHLTTRDTracklet::SaveAt(AliHLTUInt8_t *const block, const AliTRDseedV1* const inTracklet)
247 : {
248 : AliHLTUInt32_t size=0;
249 :
250 0 : memcpy(block,inTracklet,sizeof(AliTRDseedV1));
251 : size+=sizeof(AliTRDseedV1);
252 :
253 0 : for(int i=0; i<AliTRDseedV1::kNclusters; i++){
254 0 : AliTRDcluster* inClust = inTracklet->GetClusters(i);
255 0 : if(inClust) size+=AliHLTTRDCluster::SaveAt(block+size, inClust);
256 : }
257 :
258 0 : return size;
259 : }
260 :
261 : /**
262 : * Read tracklet from block
263 : */
264 : //============================================================================
265 : AliHLTUInt32_t AliHLTTRDTracklet::LoadFrom(AliTRDseedV1 *const outTracklet, const AliHLTUInt8_t *const block)
266 : {
267 : AliHLTUInt32_t size=0;
268 :
269 0 : memcpy(((AliHLTUInt8_t*)outTracklet)+sizeof(void*),block+sizeof(void*),sizeof(AliTRDseedV1)-sizeof(void*));
270 : size+=sizeof(AliTRDseedV1);
271 :
272 0 : for(int i=0; i<AliTRDseedV1::kNclusters; i++){
273 0 : if(outTracklet->GetClusters(i)){
274 0 : AliTRDcluster *const outClust = new AliTRDcluster;
275 0 : outTracklet->fClusters[i]=outClust;
276 0 : size+=AliHLTTRDCluster::LoadFrom(outClust, block+size);
277 0 : }
278 : }
279 :
280 0 : outTracklet->SetBit(AliTRDseedV1::kOwner);
281 :
282 0 : return size;
283 0 : }
|
