StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StMuEmcCollection.cxx
1 //###########################################################
2 // EMC Micro Event
3 // Author: Alexandre A. P. Suaide
4 // initial version 08/2001
5 //
6 // See README for details
7 //###########################################################
8 #include <string.h>
9 
10 #include "StMuEmcCollection.h"
11 #include "Stiostream.h"
12 #include "StMuEmcUtil.h"
13 static StMuEmcUtil util; // to ease decoding of EEMC hits
14 ClassImp(StMuEmcCollection)
15 
16 StMuEmcCollection::StMuEmcCollection()
17  : TObject()
18 {
19  int n = (char*)&mEndcapEmcPoints - (char*)&mTowerADC + sizeof(mEndcapEmcPoints);
20  memset(&mTowerADC,0,n);
21 }
22 
23 StMuEmcCollection::StMuEmcCollection(const StMuEmcCollection& o)
24  : TObject(o)
25 {
26  memcpy( mTowerADC, o.mTowerADC, sizeof(mTowerADC) );
27  memcpy( mEndcapTowerADC, o.mEndcapTowerADC, sizeof(mEndcapTowerADC) );
28 
29  for ( int i=0; i<2; i++) {
30  mSmdHits[i] = (TClonesArray*)o.mSmdHits[i]->Clone();
31  mEndcapSmdHits[i] = (TClonesArray*)o.mEndcapSmdHits[i]->Clone();
32  }
33  for ( int i=0; i<4; i++) {
34  mEmcClusters[i] = (TClonesArray*)o.mEmcClusters[i]->Clone();
35  mEndcapEmcClusters[i] = (TClonesArray*)o.mEndcapEmcClusters[i]->Clone();
36  }
37  mPrsHits = (TClonesArray*)o.mPrsHits->Clone();
38  mEmcPoints = (TClonesArray*)o.mEmcPoints->Clone();
39  mEndcapPrsHits = (TClonesArray*)o.mEndcapPrsHits->Clone();
40  mEndcapEmcPoints = (TClonesArray*)o.mEndcapEmcPoints->Clone();
41 }
42 
43 void StMuEmcCollection::init()
44 {
45  if (mPrsHits) return;
46  mEmcPoints = new TClonesArray("StMuEmcPoint",0);
47  mPrsHits = new TClonesArray("StMuEmcHit",0);
48  mEndcapEmcPoints= new TClonesArray("StMuEmcPoint",0);
49  mEndcapPrsHits = new TClonesArray("StMuEmcHit",0);
50  for(int i=0;i<4;i++)
51  {
52  mEmcClusters[i] = new TClonesArray("StMuEmcCluster",0);
53  mEndcapEmcClusters[i] = new TClonesArray("StMuEmcCluster",0);
54  if(i>=2) continue;
55  mSmdHits[i] = new TClonesArray("StMuEmcHit",0);
56  mEndcapSmdHits[i] = new TClonesArray("StMuEmcHit",0);
57  }
58 }
59 
60 
61 StMuEmcCollection::~StMuEmcCollection()
62 {
63  int n = &mEndcapEmcPoints-&mPrsHits +1;
64  TClonesArray **arr = &mPrsHits;
65  for(int i=0;i<n;i++) { delete arr[i]; arr[i] = 0;}
66 }
67 void StMuEmcCollection::DeleteThis()
68 {
69  for ( int i=0; i<2; i++) mSmdHits[i]->Delete();
70  for ( int i=0; i<4; i++) mEmcClusters[i]->Delete();
71  mEmcPoints->Delete();
72 }
73 
74 void StMuEmcCollection::clear(Option_t *option)
75 {
76  int n = &mEndcapEmcPoints-&mPrsHits +1;
77  TClonesArray **arr = &mPrsHits;
78  for(int i=0;i<n;i++) { if (arr[i]) arr[i]->Clear();}
79 
80  return;
81 }
82 void StMuEmcCollection::packbits(unsigned char *data, unsigned int value, unsigned int nbits, unsigned int index)
83 {
84  unsigned int start = index*nbits;
85  unsigned int startByte = start/8;
86  unsigned int startBit = start%8;
87  unsigned int a = 0;
88  unsigned int s = 1;
89  for(int i=0;i<4;i++) { a+=data[startByte+i]*s; s*=256; }
90  unsigned int mask = ((unsigned int)(1<<nbits)-1);
91  unsigned int b = ((value&mask)<<startBit) | (a&(~(mask<<startBit)));
92  data[startByte+0] = (unsigned char)((b & 0x000000FF));
93  data[startByte+1] = (unsigned char)((b & 0x0000FF00)>>8);
94  data[startByte+2] = (unsigned char)((b & 0x00FF0000)>>16);
95  data[startByte+3] = (unsigned char)((b & 0xFF000000)>>24);
96  return;
97 }
98 unsigned int StMuEmcCollection::unpackbits(const unsigned char *data, unsigned int nbits, unsigned int index) const
99 {
100  unsigned int start = index*nbits;
101  unsigned int startByte = start/8;
102  unsigned int startBit = start%8;
103  unsigned int a = 0;
104  unsigned int s = 1;
105  for(int i=0;i<4;i++) { a+=data[startByte+i]*s; s*=256; }
106  unsigned int mask = ((unsigned int)(1<<nbits)-1);
107  unsigned int b = (unsigned int)(a&(mask<<startBit))>>startBit;
108  return b;
109 }
110 int StMuEmcCollection::getTowerADC(int id, int detector) const
111 {
112  if (mTowerData)
113  return mTowerData->towerADC(id,detector);
114  if(detector == bemc)
115  {
116  if(id<1 || id>4800) return 0;
117  return (int)unpackbits(mTowerADC,12,(unsigned int)(id-1));
118  }
119  if(detector == eemc)
120  {
121  if(id<1 || id>720) return 0;
122  return (int)unpackbits(mEndcapTowerADC,12,(unsigned int)(id-1));
123  }
124  return 0;
125 }
126 
127 
128 int StMuEmcCollection::getNSmdHits(int detector) const
129 {
130  TClonesArray *tca = NULL;
131  if (!mPrsHits) return 0;
132  if(detector==bsmde || detector==bsmdp) tca = mSmdHits[detector-bsmde];
133  if(detector==esmdu || detector==esmdv) tca = mEndcapSmdHits[detector-esmdu];
134  if(tca) return tca->GetEntriesFast();
135  else return 0;
136 }
137 
138 StMuEmcHit* StMuEmcCollection::getSmdHit(int hitId,int detector)
139 {
140  TClonesArray *tca = NULL;
141  if (!mPrsHits) return 0;
142  if(detector==bsmde || detector==bsmdp) tca = mSmdHits[detector-bsmde];
143  if(detector==esmdu || detector==esmdv) tca = mEndcapSmdHits[detector-esmdu];
144  if(tca)
145  {
146  int counter = tca->GetEntriesFast();
147  if(hitId<0 || hitId>counter) return NULL;
148  return (StMuEmcHit*)tca->UncheckedAt(hitId);
149  }
150  return NULL;
151 }
152 
153 const StMuEmcHit* StMuEmcCollection::getSmdHit(int hitId,int detector) const
154 {
155  const TClonesArray *tca = NULL;
156  if (!mPrsHits) return 0;
157  if(detector==bsmde || detector==bsmdp) tca = mSmdHits[detector-bsmde];
158  if(detector==esmdu || detector==esmdv) tca = mEndcapSmdHits[detector-esmdu];
159  if(tca)
160  {
161  int counter = tca->GetEntriesFast();
162  if(hitId<0 || hitId>counter) return NULL;
163  return (const StMuEmcHit*)tca->UncheckedAt(hitId);
164  }
165  return NULL;
166 }
167 
168 int StMuEmcCollection::getNPrsHits(int detector) const
169 {
170  if (!mPrsHits) return 0;
171  TClonesArray *tca = NULL;
172  if(detector == bprs) tca = mPrsHits;
173  if(detector == eprs) tca = mEndcapPrsHits;
174  if(tca) return tca->GetEntriesFast();
175  else return 0;
176 }
177 
178 StMuEmcHit* StMuEmcCollection::getPrsHit(int hitId, int detector)
179 {
180  if (!mPrsHits) return 0;
181  TClonesArray *tca = NULL;
182  if(detector == bprs) tca = mPrsHits;
183  if(detector == eprs) tca = mEndcapPrsHits;
184  if(tca)
185  {
186  int counter = tca->GetEntriesFast();
187  if(hitId<0 || hitId>counter) return NULL;
188  return (StMuEmcHit*)tca->UncheckedAt(hitId);
189  }
190  return NULL;
191 }
192 
193 const StMuEmcHit* StMuEmcCollection::getPrsHit(int hitId, int detector) const
194 {
195  if (!mPrsHits) return 0;
196  const TClonesArray *tca = NULL;
197  if(detector == bprs) tca = mPrsHits;
198  if(detector == eprs) tca = mEndcapPrsHits;
199  if(tca)
200  {
201  int counter = tca->GetEntriesFast();
202  if(hitId<0 || hitId>counter) return NULL;
203  return (const StMuEmcHit*)tca->UncheckedAt(hitId);
204  }
205  return NULL;
206 }
207 
208 int StMuEmcCollection::getNClusters(int detector) const
209 {
210  if (!mPrsHits) return 0;
211  if(detector<bemc && detector>esmdv) return 0;
212  TClonesArray *tca =NULL;
213  if(detector>=bemc && detector <= bsmdp) tca = mEmcClusters[detector-bemc];
214  else tca = mEndcapEmcClusters[detector-eemc];
215 
216  //cout << "DEBUG :: detector bemc bsmdp "
217  // << detector << " " << bemc << " " << bsmdp << endl;
218 
219  if (tca) return tca->GetEntriesFast();
220  else return 0;
221 }
222 
223 StMuEmcCluster* StMuEmcCollection::getCluster(int clusterId,int detector)
224 {
225  if (!mPrsHits) return 0;
226  if(detector<bemc && detector>esmdv) return NULL;
227  TClonesArray *tca = NULL;
228  if(detector>=bemc && detector <= bsmdp) tca = mEmcClusters[detector-bemc];
229  else tca = mEndcapEmcClusters[detector-eemc];
230  int counter = tca->GetEntriesFast();
231  if(clusterId<0 || clusterId>counter) return NULL;
232  return (StMuEmcCluster*)tca->At(clusterId);
233 }
234 
235 const StMuEmcCluster* StMuEmcCollection::getCluster(int clusterId,int detector) const
236 {
237  if (!mPrsHits) return 0;
238  if(detector<bemc && detector>esmdv) return NULL;
239  const TClonesArray *tca = NULL;
240  if(detector>=bemc && detector <= bsmdp) tca = mEmcClusters[detector-bemc];
241  else tca = mEndcapEmcClusters[detector-eemc];
242  int counter = tca->GetEntriesFast();
243  if(clusterId<0 || clusterId>counter) return NULL;
244  return (const StMuEmcCluster*)tca->At(clusterId);
245 }
246 
247 int StMuEmcCollection::getNPoints() const
248 {
249  if (!mPrsHits) return 0;
250  const TClonesArray *tca =mEmcPoints;
251  if (tca) return tca->GetEntriesFast();
252  else return 0;
253 }
254 
255 int StMuEmcCollection::getNEndcapPoints() const
256 {
257  if (!mPrsHits) return 0;
258  const TClonesArray *tca =mEndcapEmcPoints;
259  if (tca) return tca->GetEntriesFast();
260  else return 0;
261 }
262 
263 StMuEmcPoint* StMuEmcCollection::getPoint(int pointId)
264 {
265  if (!mPrsHits) return 0;
266  TClonesArray *tca =mEmcPoints;
267  int counter = tca->GetEntriesFast();
268  if(pointId<0 || pointId>counter) return NULL;
269  return (StMuEmcPoint*)tca->At(pointId);
270 }
271 
272 const StMuEmcPoint* StMuEmcCollection::getPoint(int pointId) const
273 {
274  if (!mPrsHits) return 0;
275  const TClonesArray *tca =mEmcPoints;
276  int counter = tca->GetEntriesFast();
277  if(pointId<0 || pointId>counter) return NULL;
278  return (const StMuEmcPoint*)tca->At(pointId);
279 }
280 
281 StMuEmcPoint* StMuEmcCollection::getEndcapPoint(int pointId)
282 {
283  if (!mPrsHits) return 0;
284  TClonesArray *tca =mEndcapEmcPoints;
285 
286  if (tca){
287  int counter = tca->GetEntriesFast();
288  if(pointId<0 || pointId>counter) return NULL;
289  return (StMuEmcPoint*)tca->At(pointId);
290  } else {
291  return NULL;
292  }
293 }
294 
295 const StMuEmcPoint* StMuEmcCollection::getEndcapPoint(int pointId) const
296 {
297  if (!mPrsHits) return 0;
298  const TClonesArray *tca =mEndcapEmcPoints;
299 
300  if (tca){
301  int counter = tca->GetEntriesFast();
302  if(pointId<0 || pointId>counter) return NULL;
303  return (const StMuEmcPoint*)tca->At(pointId);
304  } else {
305  return NULL;
306  }
307 }
308 
309 void StMuEmcCollection::setTowerADC(int id,int adc, int detector)
310 {
311  if (!mPrsHits) init();
312  if (mTowerData) {
313  mTowerData->setTowerADC(id,adc,detector);
314  return;
315  }
316 
317  if(detector == bemc)
318  {
319  if(id<1 || id>4800) return;
320  packbits(mTowerADC,adc,12,(unsigned int)(id-1));
321  }
322  if(detector == eemc)
323  {
324  if(id<1 || id>720) return;
325  packbits(mEndcapTowerADC,adc,12,(unsigned int)(id-1));
326  }
327  return;
328 }
329 
330 void StMuEmcCollection::addSmdHit(int detector)
331 {
332  if (!mPrsHits) init();
333  TClonesArray *tca = NULL;
334  if(detector==bsmde || detector==bsmdp) tca = mSmdHits[detector-bsmde];
335  if(detector==esmdu || detector==esmdv) tca = mEndcapSmdHits[detector-esmdu];
336  if(tca)
337  {
338  int counter = tca->GetEntriesFast();
339  new ((*tca)[counter]) StMuEmcHit();
340  }
341  return;
342 }
343 
344 void StMuEmcCollection::addPrsHit(int detector)
345 {
346  if (!mPrsHits) init();
347  TClonesArray *tca = NULL;
348  if(detector == bprs) tca = mPrsHits;
349  if(detector == eprs) tca = mEndcapPrsHits;
350  if(tca)
351  {
352  int counter = tca->GetEntriesFast();
353  new ((*tca)[counter]) StMuEmcHit();
354  }
355  return;
356 }
357 
358 void StMuEmcCollection::addCluster(int detector)
359 {
360  if(detector<bemc && detector>esmdv) return;
361  if (!mPrsHits) init();
362  TClonesArray *tca =NULL;
363  if(detector>=bemc && detector <= bsmdp) tca = mEmcClusters[detector-bemc];
364  else tca = mEndcapEmcClusters[detector-eemc];
365  int counter = tca->GetEntriesFast();
366  new ((*tca)[counter]) StMuEmcCluster();
367  return;
368 }
369 
370 void StMuEmcCollection::addPoint()
371 {
372  if (!mPrsHits) init();
373  TClonesArray *tca =mEmcPoints;
374  int counter = tca->GetEntriesFast();
375  new ((*tca)[counter]) StMuEmcPoint();
376  return;
377 }
378 void StMuEmcCollection::addEndcapPoint()
379 {
380  if (!mPrsHits) init();
381  TClonesArray *tca =mEndcapEmcPoints;
382  int counter = tca->GetEntriesFast();
383  new ((*tca)[counter]) StMuEmcPoint();
384  return;
385 }
386 
387 
388 void StMuEmcCollection::getEndcapTowerADC(int ihit1, int &adc, int &sec, int &sub, int & eta) const
389 {
390  int ihit=ihit1+1; // it was not my idea to abort on index=0, JB
391  adc=getTowerADC(ihit,eemc);
392  if(! util.getEndcapBin(eemc,ihit,sec,eta,sub)) return ;
393  adc=sec=sub=eta=-1;
394  return;
395 }
396 
397 StMuEmcHit * StMuEmcCollection::getEndcapPrsHit(int ihit, int &sec, int &sub, int & eta, int &pre)
398 {
399  if (!mPrsHits) return 0;
400  StMuEmcHit * h = getPrsHit(ihit,eprs);
401  int ssub;
402  if( util.getEndcapBin(eprs,h->getId(),sec,eta,ssub)) return 0;
403  pre=1+(ssub-1)/5;
404  sub=1+(ssub-1)%5;
405  return h;
406 }
407 
408 const StMuEmcHit * StMuEmcCollection::getEndcapPrsHit(int ihit, int &sec, int &sub, int & eta, int &pre) const
409 {
410  if (!mPrsHits) return 0;
411  const StMuEmcHit * h = getPrsHit(ihit,eprs);
412  int ssub;
413  if( util.getEndcapBin(eprs,h->getId(),sec,eta,ssub)) return 0;
414  pre=1+(ssub-1)/5;
415  sub=1+(ssub-1)%5;
416  return h;
417 }
418 
419 int StMuEmcCollection::getNEndcapSmdHits(char uv) const
420 {
421  if(uv!='U' && uv!='V') return 0;
422  return getNSmdHits((int)esmdu+uv-'U');
423 }
424 
425 
426 StMuEmcHit * StMuEmcCollection::getEndcapSmdHit(char uv, int ihit,int &sec, int &strip)
427 {
428  if(uv!='U' && uv!='V') return 0;
429  if (!mPrsHits) return 0;
430  int det=(int)esmdu+uv-'U';
431  StMuEmcHit * h =getSmdHit(ihit,det);
432  int idum;
433  if( util.getEndcapBin(det,h->getId(),sec,strip,idum)) return 0;
434  return h;
435 }
436 
437 const StMuEmcHit * StMuEmcCollection::getEndcapSmdHit(char uv, int ihit,int &sec, int &strip) const
438 {
439  if(uv!='U' && uv!='V') return 0;
440  if (!mPrsHits) return 0;
441  int det=(int)esmdu+uv-'U';
442  const StMuEmcHit * h =getSmdHit(ihit,det);
443  int idum;
444  if( util.getEndcapBin(det,h->getId(),sec,strip,idum)) return 0;
445  return h;
446 }
447 
448 void StMuEmcCollection::setPrsArray(int detector, TClonesArray *cl) {
449  if (detector==bprs)
450  mPrsHits=cl;
451  else if (detector==eprs)
452  mEndcapPrsHits=cl;
453 }
454 
455 void StMuEmcCollection::setSmdArray(int detector, TClonesArray *cl) {
456  switch (detector) {
457  case bsmde:
458  mSmdHits[0]=cl;
459  break;
460  case bsmdp:
461  mSmdHits[1]=cl;
462  break;
463  case esmdu:
464  mEndcapSmdHits[0]=cl;
465  break;
466  case esmdv:
467  mEndcapSmdHits[1]=cl;
468  break;
469  }
470 }
471 
StMuEmcHit::getId
int getId() const
Return Module number.
Definition: StMuEmcHit.h:18
Generated by   doxygen 1.8.5