CbmRoot
CbmMcbm2018HodoPar.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmMcbm2018HodoPar source file -----
3 // ----- Created 31/07/19 by P.-A. Loizeau -----
4 // -------------------------------------------------------------------------
5 
6 #include "CbmMcbm2018HodoPar.h"
7 
8 #include "FairDetParIo.h"
9 #include "FairLogger.h"
10 #include "FairParIo.h"
11 #include "FairParamList.h"
12 
13 #include "TMath.h"
14 #include "TString.h"
15 
16 using namespace std;
17 
18 // ----- Standard constructor ------------------------------------------
19 CbmMcbm2018HodoPar::CbmMcbm2018HodoPar(const char* name,
20  const char* title,
21  const char* context)
22  : FairParGenericSet(name, title, context)
23  , fuNbModules(0)
24  , fiModAddress()
25  , fdModCenterPosX()
26  , fdModCenterPosY()
27  , fiModSwapXY()
28  , fiModInvertX()
29  , fiModInvertY()
30  , fuNrOfDpbs(0)
31  , fiDbpIdArray()
32  , fiCrobActiveFlag()
33  , fiFebModuleIdx()
34  , fdFebAdcGain()
35  , fdFebAdcBase()
36  , fdFebAdcThrGain()
37  , fiFebAdcThrOffs() {
38  detName = "Hodo";
39 }
40 // -------------------------------------------------------------------------
41 
42 
43 // ----- Destructor ----------------------------------------------------
44 CbmMcbm2018HodoPar::~CbmMcbm2018HodoPar() {}
45 // -------------------------------------------------------------------------
46 
47 
48 // ----- Public method clear -------------------------------------------
49 void CbmMcbm2018HodoPar::clear() {
50  status = kFALSE;
51  resetInputVersions();
52 }
53 // -------------------------------------------------------------------------
54 
55 // -------------------------------------------------------------------------
56 
57 void CbmMcbm2018HodoPar::putParams(FairParamList* l) {
58  if (!l) return;
59 
60  l->add("NbModules", fuNbModules);
61  l->add("ModAddress", fiModAddress);
62  l->add("ModCenterPosX", fdModCenterPosX);
63  l->add("ModCenterPosY", fdModCenterPosY);
64  l->add("ModSwapXY", fiModSwapXY);
65  l->add("ModInvertX", fiModInvertX);
66  l->add("ModInvertY", fiModInvertY);
67 
68  l->add("NrOfDpbs", fuNrOfDpbs);
69  l->add("DbpIdArray", fiDbpIdArray);
70  l->add("CrobActiveFlag", fiCrobActiveFlag);
71 
72  l->add("FebModuleIdx", fiFebModuleIdx);
73  l->add("FebAdcGain", fdFebAdcGain);
74  l->add("FebAdcBase", fdFebAdcBase);
75  l->add("FebAdcThrGain", fdFebAdcThrGain);
76  l->add("FebAdcThrOffs", fiFebAdcThrOffs);
77 }
78 
79 // -------------------------------------------------------------------------
80 
81 Bool_t CbmMcbm2018HodoPar::getParams(FairParamList* l) {
82 
83  if (!l) return kFALSE;
84 
85  if (!l->fill("NbModules", &fuNbModules)) return kFALSE;
86 
87  fiModAddress.Set(fuNbModules);
88  fdModCenterPosX.Set(fuNbModules);
89  fdModCenterPosY.Set(fuNbModules);
90  fiModSwapXY.Set(fuNbModules);
91  fiModInvertX.Set(fuNbModules);
92  fiModInvertY.Set(fuNbModules);
93  if (!l->fill("ModAddress", &fiModAddress)) return kFALSE;
94  if (!l->fill("ModCenterPosX", &fdModCenterPosX)) return kFALSE;
95  if (!l->fill("ModCenterPosY", &fdModCenterPosY)) return kFALSE;
96  if (!l->fill("ModSwapXY", &fiModSwapXY)) return kFALSE;
97  if (!l->fill("ModInvertX", &fiModInvertX)) return kFALSE;
98  if (!l->fill("ModInvertY", &fiModInvertY)) return kFALSE;
99 
100  if (!l->fill("NrOfDpbs", &fuNrOfDpbs)) return kFALSE;
101 
102  fiDbpIdArray.Set(fuNrOfDpbs);
103  if (!l->fill("DbpIdArray", &fiDbpIdArray)) return kFALSE;
104 
105  fiCrobActiveFlag.Set(fuNrOfDpbs * kuNbCrobsPerDpb);
106  if (!l->fill("CrobActiveFlag", &fiCrobActiveFlag)) return kFALSE;
107 
108  fiFebModuleIdx.Set(fuNrOfDpbs * kuNbCrobsPerDpb * kuNbFebsPerCrob);
109  fdFebAdcGain.Set(fuNrOfDpbs * kuNbCrobsPerDpb * kuNbFebsPerCrob);
110  fdFebAdcBase.Set(fuNrOfDpbs * kuNbCrobsPerDpb * kuNbFebsPerCrob);
111  fdFebAdcThrGain.Set(fuNrOfDpbs * kuNbCrobsPerDpb * kuNbFebsPerCrob);
112  fiFebAdcThrOffs.Set(fuNrOfDpbs * kuNbCrobsPerDpb * kuNbFebsPerCrob);
113  if (!l->fill("FebModuleIdx", &fiFebModuleIdx)) return kFALSE;
114  if (!l->fill("FebAdcGain", &fdFebAdcGain)) return kFALSE;
115  if (!l->fill("FebAdcBase", &fdFebAdcBase)) return kFALSE;
116  if (!l->fill("FebAdcThrGain", &fdFebAdcThrGain)) return kFALSE;
117  if (!l->fill("FebAdcThrOffs", &fiFebAdcThrOffs)) return kFALSE;
118 
119  return kTRUE;
120 }
121 // -------------------------------------------------------------------------
122 Int_t CbmMcbm2018HodoPar::ElinkIdxToFebIdx(UInt_t uElink) {
123  //LOG(info) <<" uElink "<<uElink<<" kuNbElinksPerCrob "<<kuNbElinksPerCrob;
124  if (uElink < kuNbElinksPerCrob)
125  return kiCrobMapElinkFebIdx[uElink];
126  else {
127  LOG(warning)
128  << "CbmMcbm2018HodoPar::ElinkIdxToFebIdx => Index out of bound, "
129  << "returning crazy value!";
130  return -1;
131  } // else of if( uElink < kuNbElinksPerCrob )
132 }
133 // -------------------------------------------------------------------------
134 UInt_t CbmMcbm2018HodoPar::ElinkIdxToAsicIdxFebMuch(UInt_t uElink) {
135  if (uElink < kuNbElinksPerCrob)
136  return kuCrobMapElinkFebMuch[uElink];
137  else {
138  LOG(warning)
139  << "CbmMcbm2018HodoPar::ElinkIdxToAsicIdxFebMuch => Index out of bound, "
140  << "returning crazy value!";
141  return 0xFFFF;
142  } // else of if( uElink < kuNbElinksPerCrob )
143 }
144 // -------------------------------------------------------------------------
145 UInt_t CbmMcbm2018HodoPar::ChannelToFiber(UInt_t uChan) {
146  if (uChan < kuNbChanPerAsic)
147  return kuChannelToFiberMap[uChan];
148  else {
149  LOG(warning) << "CbmMcbm2018HodoPar::ChannelToFiber => Index out of bound, "
150  << "returning crazy value!";
151  return 0xFFFF;
152  } // else of if( uChan < kuNbChanPerAsic )
153 }
154 UInt_t CbmMcbm2018HodoPar::ChannelToPixel(UInt_t uChan) {
155  if (uChan < kuNbChanPerAsic)
156  return kuChannelToPixelMap[uChan];
157  else {
158  LOG(warning) << "CbmMcbm2018HodoPar::ChannelToPixel => Index out of bound, "
159  << "returning crazy value!";
160  return 0xFFFF;
161  } // else of if( uChan < kuNbChanPerAsic )
162 }
163 UInt_t CbmMcbm2018HodoPar::ChannelToAxis(UInt_t uChan) {
164  if (uChan < kuNbChanPerAsic)
165  return kuChannelToPlaneMap[uChan];
166  else {
167  LOG(warning) << "CbmMcbm2018HodoPar::ChannelToAxis => Index out of bound, "
168  << "returning crazy value!";
169  return 0xFFFF;
170  } // else of if( uChan < kuNbChanPerAsic )
171 }
172 // -------------------------------------------------------------------------
173 Bool_t CbmMcbm2018HodoPar::CheckModuleIndex(UInt_t uModuleIdx) {
174  if (uModuleIdx < fuNbModules)
175  return kTRUE;
176  else {
177  LOG(warning)
178  << "CbmMcbm2018HodoPar::CheckModuleIndex => Index out of bound!";
179  return kFALSE;
180  } // else of if( uModuleIdx < fuNbModules )
181 }
182 UInt_t CbmMcbm2018HodoPar::GetModuleAddress(UInt_t uModuleIdx) {
183  if (uModuleIdx < fuNbModules)
184  return fiModAddress[uModuleIdx];
185  else {
186  LOG(warning)
187  << "CbmMcbm2018HodoPar::GetModuleAddress => Index out of bound, "
188  << "returning crazy value!";
189  return 0xFFFFFFFF;
190  } // else of if( uModuleIdx < fuNbModules )
191 }
192 Double_t CbmMcbm2018HodoPar::GetModuleCenterPosX(UInt_t uModuleIdx) {
193  if (uModuleIdx < fuNbModules)
194  return fdModCenterPosX[uModuleIdx];
195  else {
196  LOG(warning)
197  << "CbmMcbm2018HodoPar::GetModuleCenterPosX => Index out of bound, "
198  << "returning crazy value!";
199  return 3.844e11; // Fly to the Moon!
200  } // else of if( uModuleIdx < fuNbModules )
201 }
202 Double_t CbmMcbm2018HodoPar::GetModuleCenterPosY(UInt_t uModuleIdx) {
203  if (uModuleIdx < fuNbModules)
204  return fdModCenterPosY[uModuleIdx];
205  else {
206  LOG(warning)
207  << "CbmMcbm2018HodoPar::GetModuleCenterPosY => Index out of bound, "
208  << "returning crazy value!";
209  return 3.844e11; // Fly to the Moon!
210  } // else of if( uModuleIdx < fuNbModules )
211 }
212 Bool_t CbmMcbm2018HodoPar::GetModuleSwapXY(UInt_t uModuleIdx) {
213  if (uModuleIdx < fuNbModules)
214  return fiModSwapXY[uModuleIdx];
215  else {
216  LOG(warning)
217  << "CbmMcbm2018HodoPar::GetModuleSwapXY => Index out of bound, "
218  << "returning false!";
219  return kFALSE; // Fly to the Moon!
220  } // else of if( uModuleIdx < fuNbModules )
221 }
222 Bool_t CbmMcbm2018HodoPar::GetModuleInvertX(UInt_t uModuleIdx) {
223  if (uModuleIdx < fuNbModules)
224  return fiModInvertX[uModuleIdx];
225  else {
226  LOG(warning)
227  << "CbmMcbm2018HodoPar::GetModuleInvertX => Index out of bound, "
228  << "returning false!";
229  return kFALSE; // Fly to the Moon!
230  } // else of if( uModuleIdx < fuNbModules )
231 }
232 Bool_t CbmMcbm2018HodoPar::GetModuleInvertY(UInt_t uModuleIdx) {
233  if (uModuleIdx < fuNbModules)
234  return fiModInvertY[uModuleIdx];
235  else {
236  LOG(warning)
237  << "CbmMcbm2018HodoPar::GetModuleInvertY => Index out of bound, "
238  << "returning false!";
239  return kFALSE; // Fly to the Moon!
240  } // else of if( uModuleIdx < fuNbModules )
241 }
242 // -------------------------------------------------------------------------
243 UInt_t CbmMcbm2018HodoPar::GetDpbId(UInt_t uDpbIdx) {
244  if (uDpbIdx < fuNrOfDpbs)
245  return fiDbpIdArray[uDpbIdx];
246  else {
247  LOG(warning) << "CbmMcbm2018HodoPar::GetDpbId => Index out of bound, "
248  << "returning crazy value!";
249  return 0xFFFFFFFF;
250  } // else of if( uDpbIdx < fuNrOfDpbs )
251 }
252 Bool_t CbmMcbm2018HodoPar::IsCrobActive(UInt_t uDpbIdx, UInt_t uCrobIdx) {
253  if (uDpbIdx < fuNrOfDpbs) {
254  if (uCrobIdx < kuNbCrobsPerDpb)
255  return 0 < fiCrobActiveFlag[uDpbIdx * kuNbCrobsPerDpb + uCrobIdx]
256  ? kTRUE
257  : kFALSE;
258  else {
259  LOG(warning)
260  << "CbmMcbm2018HodoPar::IsCrobActive => Crob Index out of bound, "
261  << "returning default inactive!";
262  return kFALSE;
263  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
264  } // if( uDpbIdx < fuNrOfDpbs )
265  else {
266  LOG(warning)
267  << "CbmMcbm2018HodoPar::IsCrobActive => Dpb Index out of bound, "
268  << "returning default inactive!";
269  return kFALSE;
270  } // else of if( uDpbIdx < fuNrOfDpbs )
271 }
272 Bool_t CbmMcbm2018HodoPar::IsFebActive(UInt_t uFebInSystIdx) {
273 
274  if (uFebInSystIdx < GetNrOfFebs()) {
275  return (-1 == fiFebModuleIdx[uFebInSystIdx] ? kFALSE : kTRUE);
276  } // if( uFebInSystIdx < GetNrOfFebs() )
277  else {
278  LOG(warning)
279  << "CbmMcbm2018HodoPar::IsFebActive => Feb Index out of bound, "
280  << "returning default inactive!";
281  return kFALSE;
282  } // else of if( uFebInSystIdx < GetNrOfFebs() )
283 }
284 Bool_t CbmMcbm2018HodoPar::IsFebActive(UInt_t uDpbIdx,
285  UInt_t uCrobIdx,
286  UInt_t uFebIdx) {
287  if (uDpbIdx < fuNrOfDpbs) {
288  if (uCrobIdx < kuNbCrobsPerDpb) {
289  if (uFebIdx < kuNbFebsPerCrob) {
290  UInt_t uIdx =
291  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
292  return IsFebActive(uIdx);
293  } // if( uFebIdx < kuNbFebsPerCrob )
294  else {
295  LOG(warning)
296  << "CbmMcbm2018HodoPar::IsFebActive => Feb Index out of bound, "
297  << "returning default inactive!";
298  return kFALSE;
299  } // else of if( uFebIdx < kuNbCrobsPerDpb )
300  } // if( uCrobIdx < kuNbCrobsPerDpb )
301  else {
302  LOG(warning)
303  << "CbmMcbm2018HodoPar::IsFebActive => Crob Index out of bound, "
304  << "returning default inactive!";
305  return kFALSE;
306  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
307  } // if( uDpbIdx < fuNrOfDpbs )
308  else {
309  LOG(warning)
310  << "CbmMcbm2018HodoPar::IsFebActive => Dpb Index out of bound, "
311  << "returning default inactive!";
312  return kFALSE;
313  } // else of if( uDpbIdx < fuNrOfDpbs )
314 }
315 Int_t CbmMcbm2018HodoPar::GetFebModuleIdx(UInt_t uDpbIdx,
316  UInt_t uCrobIdx,
317  UInt_t uFebIdx) {
318  if (uDpbIdx < fuNrOfDpbs) {
319  if (uCrobIdx < kuNbCrobsPerDpb) {
320  if (uFebIdx < kuNbFebsPerCrob) {
321  UInt_t uIdx =
322  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
323  return fiFebModuleIdx[uIdx];
324  } // if( uFebIdx < kuNbFebsPerCrob )
325  else {
326  LOG(warning)
327  << "CbmMcbm2018HodoPar::GetFebModuleIdx => Feb Index out of bound, "
328  << "returning default inactive!";
329  return -1;
330  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
331  } // if( uCrobIdx < kuNbCrobsPerDpb )
332  else {
333  LOG(warning)
334  << "CbmMcbm2018HodoPar::GetFebModuleIdx => Crob Index out of bound, "
335  << "returning default inactive!";
336  return -1;
337  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
338  } // if( uDpbIdx < fuNrOfDpbs )
339  else {
340  LOG(warning)
341  << "CbmMcbm2018HodoPar::GetFebModuleIdx => Dpb Index out of bound, "
342  << "returning default inactive!";
343  return -1;
344  } // else of if( uDpbIdx < fuNrOfDpbs )
345 }
346 Double_t CbmMcbm2018HodoPar::GetFebAdcGain(UInt_t uDpbIdx,
347  UInt_t uCrobIdx,
348  UInt_t uFebIdx) {
349  if (uDpbIdx < fuNrOfDpbs) {
350  if (uCrobIdx < kuNbCrobsPerDpb) {
351  if (uFebIdx < kuNbFebsPerCrob) {
352  UInt_t uIdx =
353  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
354  return fdFebAdcGain[uIdx];
355  } // if( uFebIdx < kuNbFebsPerCrob )
356  else {
357  LOG(warning)
358  << "CbmMcbm2018HodoPar::GetFebAdcGain => Feb Index out of bound, "
359  << "returning default value!";
360  return 0.0;
361  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
362  } // if( uCrobIdx < kuNbCrobsPerDpb )
363  else {
364  LOG(warning)
365  << "CbmMcbm2018HodoPar::GetFebAdcGain => Crob Index out of bound, "
366  << "returning default value!";
367  return 0.0;
368  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
369  } // if( uDpbIdx < fuNrOfDpbs )
370  else {
371  LOG(warning)
372  << "CbmMcbm2018HodoPar::GetFebAdcGain => Dpb Index out of bound, "
373  << "returning default value!";
374  return 0.0;
375  } // else of if( uDpbIdx < fuNrOfDpbs )
376 }
377 Double_t CbmMcbm2018HodoPar::GetFebAdcOffset(UInt_t uDpbIdx,
378  UInt_t uCrobIdx,
379  UInt_t uFebIdx) {
380  if (uDpbIdx < fuNrOfDpbs) {
381  if (uCrobIdx < kuNbCrobsPerDpb) {
382  if (uFebIdx < kuNbFebsPerCrob) {
383  UInt_t uIdx =
384  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
385  return (fdFebAdcBase[uIdx]
386  + fdFebAdcThrGain[uIdx] * fiFebAdcThrOffs[uIdx]);
387  } // if( uFebIdx < kuNbFebsPerCrob )
388  else {
389  LOG(warning)
390  << "CbmMcbm2018HodoPar::GetFebAdcOffset => Feb Index out of bound, "
391  << "returning default value!";
392  return 0.0;
393  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
394  } // if( uCrobIdx < kuNbCrobsPerDpb )
395  else {
396  LOG(warning)
397  << "CbmMcbm2018HodoPar::GetFebAdcOffset => Crob Index out of bound, "
398  << "returning default value!";
399  return 0.0;
400  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
401  } // if( uDpbIdx < fuNrOfDpbs )
402  else {
403  LOG(warning)
404  << "CbmMcbm2018HodoPar::GetFebAdcOffset => Dpb Index out of bound, "
405  << "returning default value!";
406  return 0.0;
407  } // else of if( uDpbIdx < fuNrOfDpbs )
408 }
409 Double_t CbmMcbm2018HodoPar::GetFebAdcBase(UInt_t uDpbIdx,
410  UInt_t uCrobIdx,
411  UInt_t uFebIdx) {
412  if (uDpbIdx < fuNrOfDpbs) {
413  if (uCrobIdx < kuNbCrobsPerDpb) {
414  if (uFebIdx < kuNbFebsPerCrob) {
415  UInt_t uIdx =
416  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
417  return fdFebAdcBase[uIdx];
418  } // if( uFebIdx < kuNbFebsPerCrob )
419  else {
420  LOG(warning)
421  << "CbmMcbm2018HodoPar::GetFebAdcBase => Feb Index out of bound, "
422  << "returning default value!";
423  return 0.0;
424  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
425  } // if( uCrobIdx < kuNbCrobsPerDpb )
426  else {
427  LOG(warning)
428  << "CbmMcbm2018HodoPar::GetFebAdcBase => Crob Index out of bound, "
429  << "returning default value!";
430  return 0.0;
431  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
432  } // if( uDpbIdx < fuNrOfDpbs )
433  else {
434  LOG(warning)
435  << "CbmMcbm2018HodoPar::GetFebAdcBase => Dpb Index out of bound, "
436  << "returning default value!";
437  return 0.0;
438  } // else of if( uDpbIdx < fuNrOfDpbs )
439 }
440 Double_t CbmMcbm2018HodoPar::GetFebAdcThrGain(UInt_t uDpbIdx,
441  UInt_t uCrobIdx,
442  UInt_t uFebIdx) {
443  if (uDpbIdx < fuNrOfDpbs) {
444  if (uCrobIdx < kuNbCrobsPerDpb) {
445  if (uFebIdx < kuNbFebsPerCrob) {
446  UInt_t uIdx =
447  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
448  return fdFebAdcThrGain[uIdx];
449  } // if( uFebIdx < kuNbFebsPerCrob )
450  else {
451  LOG(warning)
452  << "CbmMcbm2018HodoPar::GetFebAdcThrGain => Feb Index out of bound, "
453  << "returning default value!";
454  return 0.0;
455  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
456  } // if( uCrobIdx < kuNbCrobsPerDpb )
457  else {
458  LOG(warning)
459  << "CbmMcbm2018HodoPar::GetFebAdcThrGain => Crob Index out of bound, "
460  << "returning default value!";
461  return 0.0;
462  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
463  } // if( uDpbIdx < fuNrOfDpbs )
464  else {
465  LOG(warning)
466  << "CbmMcbm2018HodoPar::GetFebAdcThrGain => Dpb Index out of bound, "
467  << "returning default value!";
468  return 0.0;
469  } // else of if( uDpbIdx < fuNrOfDpbs )
470 }
471 Int_t CbmMcbm2018HodoPar::GetFebAdcThrOffs(UInt_t uDpbIdx,
472  UInt_t uCrobIdx,
473  UInt_t uFebIdx) {
474  if (uDpbIdx < fuNrOfDpbs) {
475  if (uCrobIdx < kuNbCrobsPerDpb) {
476  if (uFebIdx < kuNbFebsPerCrob) {
477  UInt_t uIdx =
478  (uDpbIdx * kuNbCrobsPerDpb + uCrobIdx) * kuNbFebsPerCrob + uFebIdx;
479  return fiFebAdcThrOffs[uIdx];
480  } // if( uFebIdx < kuNbFebsPerCrob )
481  else {
482  LOG(warning)
483  << "CbmMcbm2018HodoPar::GetFebAdcThrOffs => Feb Index out of bound, "
484  << "returning default value!";
485  return 0;
486  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
487  } // if( uCrobIdx < kuNbCrobsPerDpb )
488  else {
489  LOG(warning)
490  << "CbmMcbm2018HodoPar::GetFebAdcThrOffs => Crob Index out of bound, "
491  << "returning default value!";
492  return 0;
493  } // else of if( uCrobIdx < kuNbCrobsPerDpb )
494  } // if( uDpbIdx < fuNrOfDpbs )
495  else {
496  LOG(warning)
497  << "CbmMcbm2018HodoPar::GetFebAdcThrOffs => Dpb Index out of bound, "
498  << "returning default value!";
499  return 0;
500  } // else of if( uDpbIdx < fuNrOfDpbs )
501 }
502 // -------------------------------------------------------------------------
503 UInt_t CbmMcbm2018HodoPar::GetChannelInModule(UInt_t uModuleIdx, UInt_t uChan) {
504  if (uModuleIdx < fuNbModules || uChan < kuNbChanPerAsic) {
505  UInt_t uAxis = ChannelToAxis(uChan);
506  UInt_t uChanInAxis = ChannelToFiber(uChan);
507 
509  if (uAxis ? GetModuleInvertY(uModuleIdx) : GetModuleInvertX(uModuleIdx)) {
510  uChanInAxis = kuNbFiberPerAxis - uChanInAxis - 1;
511  } // if( uAxis ? GetModuleInvertY( uModuleIdx ) : GetModuleInvertX( uModuleIdx ) )
512 
514  if (GetModuleSwapXY(uModuleIdx)) {
515  uAxis = !uAxis;
516  } // if( GetModuleSwapXY( uModuleIdx ) )
517 
518  return uChanInAxis + uAxis * kuNbFiberPerAxis;
519  } // if( uModuleIdx < fuNbModules || uChan < kuNbChanPerAsic )
520  else {
521  LOG(warning)
522  << "CbmMcbm2018HodoPar::GetChannelInModule => Index out of bound, "
523  << "returning crazy value!";
524  return 0xFFFF;
525  } // else of if( uModuleIdx < fuNbModules || uChan < kuNbChanPerAsic )
526 }
527 // -------------------------------------------------------------------------
528 
529 ClassImp(CbmMcbm2018HodoPar)
CbmMcbm2018HodoPar::ChannelToAxis
UInt_t ChannelToAxis(UInt_t uChan)
Definition: CbmMcbm2018HodoPar.cxx:163
CbmMcbm2018HodoPar::fiModSwapXY
TArrayI fiModSwapXY
Definition: CbmMcbm2018HodoPar.h:168
CbmMcbm2018HodoPar::fdFebAdcGain
TArrayD fdFebAdcGain
Definition: CbmMcbm2018HodoPar.h:182
CbmMcbm2018HodoPar::GetFebAdcOffset
Double_t GetFebAdcOffset(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:377
CbmMcbm2018HodoPar::~CbmMcbm2018HodoPar
virtual ~CbmMcbm2018HodoPar()
Definition: CbmMcbm2018HodoPar.cxx:44
CbmMcbm2018HodoPar::CheckModuleIndex
Bool_t CheckModuleIndex(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:173
CbmMcbm2018HodoPar::GetFebModuleIdx
Int_t GetFebModuleIdx(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:315
CbmMcbm2018HodoPar.h
CbmMcbm2018HodoPar::GetFebAdcBase
Double_t GetFebAdcBase(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:409
CbmMcbm2018HodoPar::GetNrOfFebs
UInt_t GetNrOfFebs()
Definition: CbmMcbm2018HodoPar.h:77
CbmMcbm2018HodoPar::putParams
void putParams(FairParamList *)
Definition: CbmMcbm2018HodoPar.cxx:57
CbmMcbm2018HodoPar::ElinkIdxToFebIdx
Int_t ElinkIdxToFebIdx(UInt_t uElink)
Definition: CbmMcbm2018HodoPar.cxx:122
CbmMcbm2018HodoPar::kuCrobMapElinkFebMuch
const UInt_t kuCrobMapElinkFebMuch[kuNbElinksPerCrob]
Definition: CbmMcbm2018HodoPar.h:105
CbmMcbm2018HodoPar::kuNbCrobsPerDpb
static const UInt_t kuNbCrobsPerDpb
Constants.
Definition: CbmMcbm2018HodoPar.h:94
CbmMcbm2018HodoPar::fiFebModuleIdx
TArrayI fiFebModuleIdx
Definition: CbmMcbm2018HodoPar.h:180
CbmMcbm2018HodoPar::GetModuleCenterPosX
Double_t GetModuleCenterPosX(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:192
CbmMcbm2018HodoPar::fdModCenterPosX
TArrayD fdModCenterPosX
Definition: CbmMcbm2018HodoPar.h:164
CbmMcbm2018HodoPar::fiModInvertX
TArrayI fiModInvertX
Definition: CbmMcbm2018HodoPar.h:170
CbmMcbm2018HodoPar::GetFebAdcThrOffs
Int_t GetFebAdcThrOffs(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:471
CbmMcbm2018HodoPar::fiModAddress
TArrayI fiModAddress
Definition: CbmMcbm2018HodoPar.h:162
CbmMcbm2018HodoPar::GetModuleAddress
UInt_t GetModuleAddress(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:182
CbmMcbm2018HodoPar::kuChannelToPixelMap
const UInt_t kuChannelToPixelMap[kuNbChanPerAsic]
Map from channel index to Hodoscope Fiber.
Definition: CbmMcbm2018HodoPar.h:140
CbmMcbm2018HodoPar::fdFebAdcThrGain
TArrayD fdFebAdcThrGain
Definition: CbmMcbm2018HodoPar.h:186
CbmMcbm2018HodoPar::kiCrobMapElinkFebIdx
const Int_t kiCrobMapElinkFebIdx[kuNbElinksPerCrob]
Map from eLink index to ASIC index within CROB ( 0 to kuNbFebsPerCrob * kuNbAsicPerFeb )
Definition: CbmMcbm2018HodoPar.h:114
CbmMcbm2018HodoPar::clear
virtual void clear()
Definition: CbmMcbm2018HodoPar.cxx:49
CbmMcbm2018HodoPar::kuNbFiberPerAxis
static const UInt_t kuNbFiberPerAxis
Definition: CbmMcbm2018HodoPar.h:102
CbmMcbm2018HodoPar::fdFebAdcBase
TArrayD fdFebAdcBase
Definition: CbmMcbm2018HodoPar.h:184
CbmMcbm2018HodoPar::GetChannelInModule
UInt_t GetChannelInModule(UInt_t uModuleIdx, UInt_t uChan)
Definition: CbmMcbm2018HodoPar.cxx:503
CbmMcbm2018HodoPar::kuChannelToPlaneMap
const UInt_t kuChannelToPlaneMap[kuNbChanPerAsic]
Map from channel index to PMT pixel.
Definition: CbmMcbm2018HodoPar.h:151
CbmMcbm2018HodoPar::kuChannelToFiberMap
const UInt_t kuChannelToFiberMap[kuNbChanPerAsic]
Map from eLink index to ASIC index within CROB ( 0 to kuNbFebsPerCrob * kuNbAsicPerFeb )
Definition: CbmMcbm2018HodoPar.h:120
CbmMcbm2018HodoPar::fiDbpIdArray
TArrayI fiDbpIdArray
Definition: CbmMcbm2018HodoPar.h:176
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmMcbm2018HodoPar::CbmMcbm2018HodoPar
CbmMcbm2018HodoPar(const char *name="CbmMcbm2018HodoPar", const char *title="Much parameters", const char *context="Default")
Definition: CbmMcbm2018HodoPar.cxx:19
CbmMcbm2018HodoPar::fuNrOfDpbs
UInt_t fuNrOfDpbs
Definition: CbmMcbm2018HodoPar.h:174
CbmMcbm2018HodoPar::ElinkIdxToAsicIdxFebMuch
UInt_t ElinkIdxToAsicIdxFebMuch(UInt_t uElink)
Definition: CbmMcbm2018HodoPar.cxx:134
CbmMcbm2018HodoPar::GetFebAdcGain
Double_t GetFebAdcGain(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:346
CbmMcbm2018HodoPar::fiCrobActiveFlag
TArrayI fiCrobActiveFlag
Definition: CbmMcbm2018HodoPar.h:178
CbmMcbm2018HodoPar::kuNbFebsPerCrob
static const UInt_t kuNbFebsPerCrob
Definition: CbmMcbm2018HodoPar.h:97
CbmMcbm2018HodoPar::fdModCenterPosY
TArrayD fdModCenterPosY
Definition: CbmMcbm2018HodoPar.h:166
CbmMcbm2018HodoPar::GetModuleInvertX
Bool_t GetModuleInvertX(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:222
CbmMcbm2018HodoPar::GetModuleSwapXY
Bool_t GetModuleSwapXY(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:212
CbmMcbm2018HodoPar::kuNbElinksPerCrob
static const UInt_t kuNbElinksPerCrob
Definition: CbmMcbm2018HodoPar.h:95
CbmMcbm2018HodoPar::getParams
Bool_t getParams(FairParamList *)
Definition: CbmMcbm2018HodoPar.cxx:81
CbmMcbm2018HodoPar::fiModInvertY
TArrayI fiModInvertY
Definition: CbmMcbm2018HodoPar.h:172
CbmMcbm2018HodoPar::GetModuleInvertY
Bool_t GetModuleInvertY(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:232
CbmMcbm2018HodoPar::IsFebActive
Bool_t IsFebActive(UInt_t uFebInSystIdx)
Definition: CbmMcbm2018HodoPar.cxx:272
CbmMcbm2018HodoPar::GetModuleCenterPosY
Double_t GetModuleCenterPosY(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:202
CbmMcbm2018HodoPar::fuNbModules
UInt_t fuNbModules
Map from channel index to Hodoscope Axis (X or Y)
Definition: CbmMcbm2018HodoPar.h:161
CbmMcbm2018HodoPar::fiFebAdcThrOffs
TArrayI fiFebAdcThrOffs
Definition: CbmMcbm2018HodoPar.h:188
CbmMcbm2018HodoPar::IsCrobActive
Bool_t IsCrobActive(UInt_t uDpbIdx, UInt_t uCrobIdx)
Definition: CbmMcbm2018HodoPar.cxx:252
CbmMcbm2018HodoPar::GetFebAdcThrGain
Double_t GetFebAdcThrGain(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:440
CbmMcbm2018HodoPar::GetDpbId
UInt_t GetDpbId(UInt_t uDpbIdx)
Definition: CbmMcbm2018HodoPar.cxx:243
CbmMcbm2018HodoPar::ChannelToPixel
UInt_t ChannelToPixel(UInt_t uChan)
Definition: CbmMcbm2018HodoPar.cxx:154
CbmMcbm2018HodoPar::kuNbChanPerAsic
static const UInt_t kuNbChanPerAsic
Definition: CbmMcbm2018HodoPar.h:101
CbmMcbm2018HodoPar
Definition: CbmMcbm2018HodoPar.h:18
CbmMcbm2018HodoPar::ChannelToFiber
UInt_t ChannelToFiber(UInt_t uChan)
Definition: CbmMcbm2018HodoPar.cxx:145