CbmRoot
CbmClusteringGeometry.cxx
Go to the documentation of this file.
1 /*
2  * CbmClusteringGeometry.cxx
3  *
4  * Created on: Feb 22, 2012
5  * Author: kozlov
6  */
7 
8 #include "CbmClusteringGeometry.h"
9 #include "CbmMCTrack.h"
10 #include "CbmMuchAddress.h"
11 #include "CbmMuchDigi.h"
12 #include "CbmMuchGeoScheme.h"
13 #include "CbmMuchLayer.h"
14 #include "CbmMuchLayerSide.h"
15 #include "CbmMuchModuleGem.h"
16 #include "CbmMuchModuleGemRadial.h"
17 #include "CbmMuchPad.h"
18 #include "CbmMuchPadRadial.h"
19 #include "CbmMuchPadRectangular.h"
20 #include "CbmMuchPixelHit.h"
21 #include "CbmMuchPoint.h"
22 #include "CbmMuchSectorRadial.h"
23 #include "CbmMuchSectorRectangular.h"
24 #include "CbmMuchStation.h"
25 #include "CbmStsHit.h"
26 #include "CbmStsPoint.h"
27 
28 #include "FairRootManager.h"
29 
30 #include "TClonesArray.h"
31 
32 #include <cassert>
33 #include <iostream>
34 
35 using std::cout;
36 using std::endl;
37 using std::vector;
38 
39 CbmClusteringGeometry::CbmClusteringGeometry() : fDetId(), fPadList() {
40  fNofPads = 0;
41  fNofActivePads = 0;
42 }
43 
44 CbmClusteringGeometry::CbmClusteringGeometry(Int_t nStation,
45  Int_t nLayer,
46  Bool_t nSide,
47  Int_t nModule,
48  CbmMuchGeoScheme* scheme) {
49  SetMuchModuleGeometryRadialFast(nStation, nLayer, nSide, nModule, scheme);
50  // switch(geoVersion){
51  // case 1:
52  // {
53  // SetMuchModuleGeometryRectangular(nStation, nLayer, nSide, nModule, scheme); //For old rectangular geometry
54  // break;
55  // }
56  // case 2:
57  // {
58  // SetMuchModuleGeometryRadial(nStation, nLayer, nSide, nModule, scheme); //For new radial geometry
59  // break;
60  // }
61  // default:
62  // {
63  // std::cout<<"CbmClusteringGeometry: Error! Wrong detector geometry.\n";
64  // break;
65  // }
66  // }
67 }
68 
69 //Addition of a single pad
70 void CbmClusteringGeometry::CbmClusteringSetPad(Int_t nPad,
71  Float_t x,
72  Float_t y,
73  Float_t dx,
74  Float_t dy,
75  Double_t phi1,
76  Double_t phi2,
77  Float_t r1,
78  Float_t r2,
79  Int_t digiNum,
80  UInt_t charge,
81  Long64_t chID) {
82  fPadList[nPad].fDigiNum = digiNum;
83  fPadList[nPad].fCharge = charge;
84  fPadList[nPad].fX = x;
85  fPadList[nPad].fY = y;
86  fPadList[nPad].fDx = dx;
87  fPadList[nPad].fDy = dy;
88  fPadList[nPad].fPhi1 = phi1;
89  fPadList[nPad].fPhi2 = phi2;
90  fPadList[nPad].fR1 = r1;
91  fPadList[nPad].fR2 = r2;
92  fPadList[nPad].channelID = chID;
93  fPadList[nPad].fNeighbors.clear();
94  fPadList[nPad].fNofNeighbors = 0;
95  fPadList[nPad].fNofGoodNeighbors = 0;
96 }
97 
98 CbmClusteringGeometry::~CbmClusteringGeometry() { delete[] fPadList; }
99 
100 /*void CbmClusteringGeometry::SetMuchModuleGeometryRectangular(Int_t nStation, Int_t nLayer, Bool_t nSide, Int_t nModule, CbmMuchGeoScheme* scheme)
101 {
102  CbmMuchModuleGem* module = (CbmMuchModuleGem*) scheme->GetModule(nStation, nLayer, nSide, nModule);
103  fNofPads = module->GetNPads();
104  fDetId = CbmMuchAddress::GetAddress(nStation, nLayer, nSide, nModule);
105  fPadList = new PadInformation[fNofPads];
106  fNofActivePads = 0;
107  Int_t nofSectors = module->GetNSectors();
108  Int_t padIterator = 0;
109  for(Int_t iSector = 0; iSector < nofSectors; iSector++)
110  {
111  CbmMuchSectorRectangular* sector = (CbmMuchSectorRectangular*) module->GetSector(iSector); //???
112  Int_t nofPadsInSector = sector->GetNChannels();//(sector->GetNCols())*(sector->GetNRows());
113  Int_t padNx = sector->GetPadNx();
114  Int_t padNy = sector->GetPadNy();
115  for(Int_t iPad = 0; iPad < nofPadsInSector; iPad++)
116  {
117  CbmMuchPadRectangular* pad = (CbmMuchPadRectangular*) sector->GetPadByChannelIndex(iPad); //!!!
118  fPadList[padIterator].fDigiNum = 0;
119  fPadList[padIterator].fCharge = 0;
120  fPadList[padIterator].fX = pad->GetX();
121  fPadList[padIterator].fY = pad->GetY();
122  fPadList[padIterator].fDx = sector->GetPadDx();
123  fPadList[padIterator].fDy = sector->GetPadDy();
124  fPadList[padIterator].fNeighbors.clear();
125  fPadList[padIterator].channelID = CbmMuchAddress::GetElementAddress(pad->GetAddress() ,kMuchChannel);
126  fPadByChannelId[CbmMuchAddress::GetElementAddress(pad->GetAddress() ,kMuchChannel)] = padIterator;
127  padIterator++;
128  }
129  }
130  padIterator = 0;
131  for(Int_t iPadMain = 0; iPadMain < fNofPads; iPadMain++)
132  {
133  //padIterator = 0;
134  //Int_t padIterator2 = 0;
135  fPadList[iPadMain].fNofNeighbors = 0;
136  fPadList[iPadMain].fNofGoodNeighbors = 0;
137  Float_t xLeft_1 = fPadList[iPadMain].fX - (fPadList[iPadMain].fDx / 2);
138  Float_t xRight_1 = fPadList[iPadMain].fX + (fPadList[iPadMain].fDx / 2);
139  Float_t yDown_1 = fPadList[iPadMain].fY - (fPadList[iPadMain].fDy / 2);
140  Float_t yUp_1 = fPadList[iPadMain].fY + (fPadList[iPadMain].fDy / 2);
141  for(Int_t iPadNeighbor = 0; iPadNeighbor < fNofPads; iPadNeighbor++)
142  {
143  if((fabs(fPadList[iPadMain].fX - fPadList[iPadNeighbor].fX) < (fPadList[iPadMain].fDx * 3)) &&
144  (fabs(fPadList[iPadMain].fY - fPadList[iPadNeighbor].fY) < (fPadList[iPadNeighbor].fDy * 3))){
145  Float_t xLeft_2 = fPadList[iPadNeighbor].fX - (fPadList[iPadNeighbor].fDx / 2);
146  Float_t xRight_2 = fPadList[iPadNeighbor].fX + (fPadList[iPadNeighbor].fDx / 2);
147  Float_t yDown_2 = fPadList[iPadNeighbor].fY - (fPadList[iPadNeighbor].fDy / 2);
148  Float_t yUp_2 = fPadList[iPadNeighbor].fY + (fPadList[iPadNeighbor].fDy / 2);
149  Float_t dX = fabs(xLeft_1 - xRight_1) * 0.1;
150  Float_t dY = fabs(yDown_1 - yUp_1) * 0.1;
151  if((((SubEqual(xLeft_1, xRight_2, dX) ||
152  SubEqual(xRight_1, xLeft_2, dX)) &&
153  (((GetMax(yDown_2, yUp_2) - dY) >
154  (GetMin(yDown_1, yUp_1) + dY)) &&
155  ((GetMin(yDown_2, yUp_2) + dY) <
156  (GetMax(yDown_1, yUp_1) - dY)))) ||
157  ((SubEqual(yDown_1, yUp_2, dY) ||
158  SubEqual(yUp_1, yDown_2, dY)) &&
159  (((GetMax(xLeft_2, xRight_2) - dX) >
160  (GetMin(xLeft_1, xRight_1) + dX)) &&
161  ((GetMin(xLeft_2, xRight_2) + dX) <
162  (GetMax(xLeft_1, xRight_1) - dX))))) &&
163  (iPadMain != iPadNeighbor))
164  {
165  fPadList[iPadMain].fNeighbors.push_back(iPadNeighbor);
166  fPadList[iPadMain].fNofGoodNeighbors++;
167  }
168  }}
169  }
170 }*/
171 
172 void CbmClusteringGeometry::SetMuchModuleGeometryRadial(
173  Int_t nStation,
174  Int_t nLayer,
175  Bool_t nSide,
176  Int_t nModule,
177  CbmMuchGeoScheme* scheme) {
178  CbmMuchModuleGemRadial* module = (CbmMuchModuleGemRadial*) scheme->GetModule(
179  nStation, nLayer, nSide, nModule);
180  fNofPads = module->GetNPads();
181  fDetId = module->GetDetectorId();
182  fPadList = new PadInformation[fNofPads];
183  fNofActivePads = 0;
184  Int_t nofSectors = module->GetNSectors();
185  Int_t padIterator = 0;
186  for (Int_t iSector = 0; iSector < nofSectors; iSector++) {
187  CbmMuchSectorRadial* sector =
188  (CbmMuchSectorRadial*) module->GetSectorByIndex(iSector);
189  Int_t nofPadsInSector = sector->GetNChannels();
190  for (Int_t iPad = 0; iPad < nofPadsInSector; iPad++) {
191  CbmMuchPadRadial* pad =
192  (CbmMuchPadRadial*) sector->GetPadByChannelIndex(iPad);
193  fPadList[padIterator].fDigiNum = 0;
194  fPadList[padIterator].fCharge = 0;
195  fPadList[padIterator].fPhi1 = pad->GetPhi1();
196  fPadList[padIterator].fPhi2 = pad->GetPhi2();
197  fPadList[padIterator].fR1 = pad->GetR1();
198  fPadList[padIterator].fR2 = pad->GetR2();
199  Float_t r = (fPadList[padIterator].fR1 + fPadList[padIterator].fR2) / 2;
200  Double_t phi =
201  (fPadList[padIterator].fPhi1 + fPadList[padIterator].fPhi2) / 2;
202  fPadList[padIterator].fX = r * cos(phi);
203  fPadList[padIterator].fY = r * sin(phi);
204  fPadList[padIterator].fNeighbors.clear();
205  fPadList[padIterator].channelID =
206  CbmMuchAddress::GetElementAddress(pad->GetAddress(), kMuchChannel);
207  fPadByChannelId[pad->GetAddress()] = padIterator;
208  fPadList[padIterator].nSector = iSector;
209  padIterator++;
210  }
211  }
212  padIterator = 0;
213  vector<UInt_t> diagonalNeighbors;
214  diagonalNeighbors.clear();
215  for (Int_t iPadMain = 0; iPadMain < fNofPads; iPadMain++) {
216  fPadList[iPadMain].fNofNeighbors = 0;
217  fPadList[iPadMain].fNofGoodNeighbors = 0;
218  Double_t Left_1 =
219  GetMin(fPadList[iPadMain].fPhi1, fPadList[iPadMain].fPhi2);
220  Double_t Right_1 =
221  GetMax(fPadList[iPadMain].fPhi1, fPadList[iPadMain].fPhi2);
222  Float_t Down_1 = GetMin(fPadList[iPadMain].fR1, fPadList[iPadMain].fR2);
223  Float_t Up_1 = GetMax(fPadList[iPadMain].fR1, fPadList[iPadMain].fR2);
224  Double_t dPhi =
225  fabs(fPadList[iPadMain].fPhi1 - fPadList[iPadMain].fPhi2) * 0.1;
226  Float_t dR = fabs(fPadList[iPadMain].fR1 - fPadList[iPadMain].fR2) * 0.1;
227  Double_t lPhi = (Left_1 - Right_1) * 0.01;
228  Float_t lR = (Down_1 - Up_1) * 0.01;
229  for (Int_t iPadNeighbor = 0; iPadNeighbor < fNofPads; iPadNeighbor++) {
230  if (iPadMain == iPadNeighbor) continue;
231  Double_t Left_2 =
232  GetMin(fPadList[iPadNeighbor].fPhi1, fPadList[iPadNeighbor].fPhi2);
233  Double_t Right_2 =
234  GetMax(fPadList[iPadNeighbor].fPhi1, fPadList[iPadNeighbor].fPhi2);
235  Float_t Down_2 =
236  GetMin(fPadList[iPadNeighbor].fR1, fPadList[iPadNeighbor].fR2);
237  Float_t Up_2 =
238  GetMax(fPadList[iPadNeighbor].fR1, fPadList[iPadNeighbor].fR2);
239  if ((Left_1 == Right_2) || (Right_1 == Left_2)) {
240  if (((Down_1 - lR) < Up_2) && ((Up_1 + lR) > Down_2)) {
241  fPadList[iPadMain].fNeighbors.push_back(iPadNeighbor);
242  fPadList[iPadMain].fNofGoodNeighbors++;
243  }
244  }
245  if ((Up_1 == Down_2) || (Down_1 == Up_2)) {
246  if (((Left_1 - lPhi) < Right_2) && ((Right_1 + lPhi) > Left_2)) {
247  fPadList[iPadMain].fNeighbors.push_back(iPadNeighbor);
248  fPadList[iPadMain].fNofGoodNeighbors++;
249  }
250  }
251  fPadList[iPadMain].fNofNeighbors = fPadList[iPadMain].fNofGoodNeighbors;
252  if (((Left_1 == Right_2) && (Up_1 == Down_2))
253  || ((Left_1 == Right_2) && (Up_2 == Down_1))
254  || ((Left_2 == Right_1) && (Up_1 == Down_2))
255  || ((Left_2 == Right_1) && (Up_2 == Down_1))) {
256  diagonalNeighbors.push_back(iPadNeighbor);
257  }
258  }
259  for (Int_t iNeighbor = 0; iNeighbor < diagonalNeighbors.size();
260  iNeighbor++) {
261  fPadList[iPadMain].fNeighbors.push_back(diagonalNeighbors[iNeighbor]);
262  fPadList[iPadMain].fNofNeighbors++;
263  }
264  diagonalNeighbors.clear();
265  }
266 }
267 
268 void CbmClusteringGeometry::SetMuchModuleGeometryRadialFast(
269  Int_t nStation,
270  Int_t nLayer,
271  Bool_t nSide,
272  Int_t nModule,
273  CbmMuchGeoScheme* scheme) {
274  CbmMuchModuleGemRadial* module = (CbmMuchModuleGemRadial*) scheme->GetModule(
275  nStation, nLayer, nSide, nModule);
276  fNofPads = module->GetNPads();
277  fDetId = module->GetDetectorId();
278  fPadList = new PadInformation[fNofPads];
279  fNofActivePads = 0;
280  Int_t nofSectors = module->GetNSectors();
281  Int_t padIterator = 0;
282  for (Int_t iSector = 0; iSector < nofSectors; iSector++) {
283  CbmMuchSectorRadial* sector =
284  (CbmMuchSectorRadial*) module->GetSectorByIndex(iSector);
285  Int_t nofPadsInSector = sector->GetNChannels();
286  for (Int_t iPad = 0; iPad < nofPadsInSector; iPad++) {
287  CbmMuchPadRadial* pad =
288  (CbmMuchPadRadial*) sector->GetPadByChannelIndex(iPad);
289  fPadList[padIterator].fDigiNum = 0;
290  fPadList[padIterator].fCharge = 0;
291  fPadList[padIterator].fPhi1 = pad->GetPhi1();
292  fPadList[padIterator].fPhi2 = pad->GetPhi2();
293  fPadList[padIterator].fR1 = pad->GetR1();
294  fPadList[padIterator].fR2 = pad->GetR2();
295  Float_t r = (fPadList[padIterator].fR1 + fPadList[padIterator].fR2) / 2;
296  Double_t phi =
297  (fPadList[padIterator].fPhi1 + fPadList[padIterator].fPhi2) / 2;
298  fPadList[padIterator].fX = r * cos(phi);
299  fPadList[padIterator].fY = r * sin(phi);
300  fPadList[padIterator].fNeighbors.clear();
301  fPadList[padIterator].fNofNeighbors = 0;
302  fPadList[padIterator].fNofGoodNeighbors = 0;
303  fPadList[padIterator].channelID =
304  CbmMuchAddress::GetElementAddress(pad->GetAddress(), kMuchChannel);
305  fPadByChannelId[pad->GetAddress()] = padIterator;
306  fPadList[padIterator].nSector = iSector;
307  padIterator++;
308  }
309  }
310  padIterator = 0;
311  vector<UInt_t> diagonalNeighbors;
312  diagonalNeighbors.clear();
313  for (Int_t iSector = 0; iSector < nofSectors; iSector++) {
314  CbmMuchSectorRadial* sector =
315  (CbmMuchSectorRadial*) module->GetSectorByIndex(iSector);
316  Int_t nofPadsInSector = sector->GetNChannels();
317  for (Int_t iPad = 0; iPad < nofPadsInSector; iPad++) {
318  Double_t dPhi = fabs(fPadList[iPad].fPhi1 - fPadList[iPad].fPhi2) * 0.1;
319  Float_t dR = fabs(fPadList[iPad].fR1 - fPadList[iPad].fR2) * 0.1;
320  CbmMuchPadRadial* pad =
321  (CbmMuchPadRadial*) sector->GetPadByChannelIndex(iPad);
322  vector<CbmMuchPad*> neighborsVector = pad->GetNeighbours();
323  for (Int_t iNeighbor = 0; iNeighbor < neighborsVector.size();
324  iNeighbor++) {
325  Int_t padNeighbor =
326  fPadByChannelId[neighborsVector.at(iNeighbor)->GetAddress()];
327  if ((SubEqual(
328  fPadList[padIterator].fPhi1, fPadList[padNeighbor].fPhi2, dPhi)
329  && SubEqual(
330  fPadList[padIterator].fR1, fPadList[padNeighbor].fR2, dR))
331  || (SubEqual(fPadList[padIterator].fPhi1,
332  fPadList[padNeighbor].fPhi2,
333  dPhi)
334  && SubEqual(
335  fPadList[padIterator].fR2, fPadList[padNeighbor].fR1, dR))
336  || (SubEqual(fPadList[padIterator].fPhi2,
337  fPadList[padNeighbor].fPhi1,
338  dPhi)
339  && SubEqual(
340  fPadList[padIterator].fR1, fPadList[padNeighbor].fR2, dR))
341  || (SubEqual(fPadList[padIterator].fPhi2,
342  fPadList[padNeighbor].fPhi1,
343  dPhi)
344  && SubEqual(
345  fPadList[padIterator].fR2, fPadList[padNeighbor].fR1, dR))) {
346  diagonalNeighbors.push_back(padNeighbor);
347  } else {
348  fPadList[padIterator].fNeighbors.push_back(padNeighbor);
349  fPadList[padIterator].fNofGoodNeighbors++;
350  fPadList[padIterator].fNofNeighbors++;
351  }
352  }
353  for (Int_t iNeighbor = 0; iNeighbor < diagonalNeighbors.size();
354  iNeighbor++) {
355  fPadList[padIterator].fNeighbors.push_back(
356  diagonalNeighbors.at(iNeighbor));
357  fPadList[padIterator].fNofNeighbors++;
358  }
359  diagonalNeighbors.clear();
360  padIterator++;
361  }
362  }
363 }
364 
365 Float_t CbmClusteringGeometry::GetX0(Int_t iPad) { return fPadList[iPad].fX; }
366 
367 Float_t CbmClusteringGeometry::GetDx(Int_t iPad) { return fPadList[iPad].fDx; }
368 
369 Float_t CbmClusteringGeometry::GetDy(Int_t iPad) { return fPadList[iPad].fDy; }
370 
371 Float_t CbmClusteringGeometry::GetY0(Int_t iPad) { return fPadList[iPad].fY; }
372 
373 Int_t CbmClusteringGeometry::GetDigiNum(Int_t iPad) {
374  return fPadList[iPad].fDigiNum;
375 }
376 
377 void CbmClusteringGeometry::SetDigiNum(Int_t iPad, Int_t iDigi) {
378  fPadList[iPad].fDigiNum = iDigi;
379 }
380 
381 Int_t CbmClusteringGeometry::GetNeighborsNum(Int_t iPad) {
382  return fPadList[iPad].fNofNeighbors;
383 }
384 
385 Int_t CbmClusteringGeometry::GetGoodNeighborsNum(Int_t iPad) {
386  return fPadList[iPad].fNofGoodNeighbors;
387 }
388 
389 Int_t CbmClusteringGeometry::GetNeighbor(Int_t iPad, Int_t iNeighbor) {
390  return fPadList[iPad].fNeighbors[iNeighbor];
391 }
392 
393 Long64_t CbmClusteringGeometry::GetPadID(Int_t iPad) {
394  return fPadList[iPad].channelID;
395 }
396 
397 UInt_t CbmClusteringGeometry::GetPadCharge(Int_t iPad) {
398  return fPadList[iPad].fCharge;
399 }
400 
401 void CbmClusteringGeometry::SetPadCharge(Int_t iPad, UInt_t iCharge) {
402  fPadList[iPad].fCharge = iCharge;
403 }
404 
405 void CbmClusteringGeometry::SetAPadsNom(Int_t nPads) { fNofActivePads = nPads; }
406 
407 void CbmClusteringGeometry::SetAPadsPlusOne() { fNofActivePads++; }
408 
409 template<typename T1>
410 T1 CbmClusteringGeometry::GetMin(T1& a, T1& b) {
411  if (a > b) {
412  return b;
413  } else {
414  return a;
415  }
416 }
417 
418 template<typename T2>
419 T2 CbmClusteringGeometry::GetMax(T2& a, T2& b) {
420  if (a < b) {
421  return b;
422  } else {
423  return a;
424  }
425 }
426 
427 Bool_t CbmClusteringGeometry::SubEqual(Double_t x1, Double_t x2, Double_t l) {
428  //l = l * 0.1;
429  if ((x1 < (x2 + l)) && (x1 > (x2 - l))) {
430  return 1;
431  } else {
432  return 0;
433  }
434 }
435 
436 Int_t CbmClusteringGeometry::GetPadByChannelId(Long64_t chId) {
437  return fPadByChannelId[chId];
438 }
439 
440 Double_t CbmClusteringGeometry::GetPhi1(Int_t iPad) {
441  return fPadList[iPad].fPhi1;
442 }
443 
444 Double_t CbmClusteringGeometry::GetPhi2(Int_t iPad) {
445  return fPadList[iPad].fPhi2;
446 }
447 
448 Float_t CbmClusteringGeometry::GetR1(Int_t iPad) { return fPadList[iPad].fR1; }
449 
450 Float_t CbmClusteringGeometry::GetR2(Int_t iPad) { return fPadList[iPad].fR2; }
451 
452 vector<Int_t> CbmClusteringGeometry::GetNeighbors(Int_t iPad) {
453  return fPadList[iPad].fNeighbors;
454 }
455 
456 Long64_t CbmClusteringGeometry::GetChannelID(Int_t iPad) {
457  return fPadList[iPad].channelID;
458 }
CbmClusteringGeometry::SetPadCharge
void SetPadCharge(Int_t iPad, UInt_t iCharge)
Definition: CbmClusteringGeometry.cxx:401
CbmMuchLayerSide.h
CbmMuchPad::GetNeighbours
std::vector< CbmMuchPad * > GetNeighbours() const
Definition: CbmMuchPad.h:38
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:136
CbmClusteringGeometry::PadInformation::fY
Float_t fY
Definition: CbmClusteringGeometry.h:91
CbmMuchDigi.h
CbmClusteringGeometry::PadInformation::fDigiNum
Int_t fDigiNum
Definition: CbmClusteringGeometry.h:95
CbmMuchGeoScheme
Definition: CbmMuchGeoScheme.h:43
CbmMuchGeoScheme::GetModule
CbmMuchModule * GetModule(Int_t iStation, Int_t iLayer, Bool_t iSide, Int_t iModule) const
Definition: CbmMuchGeoScheme.cxx:238
kMuchChannel
@ kMuchChannel
Channel.
Definition: CbmMuchAddress.h:22
CbmMuchSectorRadial
Definition: CbmMuchSectorRadial.h:19
CbmClusteringGeometry::PadInformation::fCharge
UInt_t fCharge
Definition: CbmClusteringGeometry.h:96
CbmClusteringGeometry::GetPhi1
Double_t GetPhi1(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:440
CbmClusteringGeometry::fNofPads
Long64_t fNofPads
Definition: CbmClusteringGeometry.h:85
CbmClusteringGeometry.h
CbmClusteringGeometry::GetX0
Float_t GetX0(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:365
CbmMuchPadRadial::GetPhi2
Double_t GetPhi2() const
Definition: CbmMuchPadRadial.h:36
CbmClusteringGeometry::fNofActivePads
Int_t fNofActivePads
Definition: CbmClusteringGeometry.h:87
CbmClusteringGeometry::PadInformation::fPhi2
Double_t fPhi2
Definition: CbmClusteringGeometry.h:93
CbmClusteringGeometry::GetR1
Float_t GetR1(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:448
CbmClusteringGeometry::GetGoodNeighborsNum
Int_t GetGoodNeighborsNum(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:385
CbmClusteringGeometry::GetNeighbor
Int_t GetNeighbor(Int_t iPad, Int_t iNeighbor)
Definition: CbmClusteringGeometry.cxx:389
CbmMuchSector::GetNChannels
Int_t GetNChannels() const
Definition: CbmMuchSector.h:31
CbmClusteringGeometry::GetR2
Float_t GetR2(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:450
CbmClusteringGeometry::PadInformation::fNofGoodNeighbors
Int_t fNofGoodNeighbors
Definition: CbmClusteringGeometry.h:98
CbmClusteringGeometry::SetDigiNum
void SetDigiNum(Int_t iPad, Int_t iDigi)
Definition: CbmClusteringGeometry.cxx:377
CbmMuchModuleGemRadial.h
CbmClusteringGeometry::CbmClusteringGeometry
CbmClusteringGeometry()
Definition: CbmClusteringGeometry.cxx:39
CbmMuchPadRadial
Definition: CbmMuchPadRadial.h:17
CbmClusteringGeometry::PadInformation::fX
Float_t fX
Definition: CbmClusteringGeometry.h:91
CbmClusteringGeometry::PadInformation::fDx
Float_t fDx
Definition: CbmClusteringGeometry.h:92
CbmMuchSectorRectangular.h
CbmClusteringGeometry::GetNeighborsNum
Int_t GetNeighborsNum(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:381
CbmClusteringGeometry::PadInformation::fR1
Float_t fR1
Definition: CbmClusteringGeometry.h:94
CbmMuchModuleGemRadial
Definition: CbmMuchModuleGemRadial.h:21
CbmMuchPoint.h
CbmClusteringGeometry::SetAPadsNom
void SetAPadsNom(Int_t nPads)
Definition: CbmClusteringGeometry.cxx:405
CbmClusteringGeometry::PadInformation::fPhi1
Double_t fPhi1
Definition: CbmClusteringGeometry.h:93
CbmMuchModuleGem::GetNPads
Int_t GetNPads()
Definition: CbmMuchModuleGem.cxx:58
CbmMuchPadRadial::GetPhi1
Double_t GetPhi1() const
Definition: CbmMuchPadRadial.h:35
CbmMuchPad::GetAddress
Int_t GetAddress() const
Definition: CbmMuchPad.h:27
CbmClusteringGeometry::GetPhi2
Double_t GetPhi2(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:444
CbmClusteringGeometry::GetChannelID
Long64_t GetChannelID(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:456
CbmClusteringGeometry::fDetId
Int_t fDetId
Definition: CbmClusteringGeometry.h:86
CbmClusteringGeometry::PadInformation::fR2
Float_t fR2
Definition: CbmClusteringGeometry.h:94
CbmMuchSector::GetPadByChannelIndex
CbmMuchPad * GetPadByChannelIndex(Int_t iChannel) const
Definition: CbmMuchSector.cxx:22
CbmClusteringGeometry::SetMuchModuleGeometryRadial
void SetMuchModuleGeometryRadial(Int_t nStation, Int_t nLayer, Bool_t nSide, Int_t nModule, CbmMuchGeoScheme *scheme)
Definition: CbmClusteringGeometry.cxx:172
CbmMuchSectorRadial.h
CbmMuchLayer.h
CbmClusteringGeometry::GetPadCharge
UInt_t GetPadCharge(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:397
CbmMuchModule::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchModule.h:48
CbmClusteringGeometry::GetMin
T1 GetMin(T1 &a, T1 &b)
Definition: CbmClusteringGeometry.cxx:410
CbmClusteringGeometry::~CbmClusteringGeometry
virtual ~CbmClusteringGeometry()
Definition: CbmClusteringGeometry.cxx:98
CbmClusteringGeometry::PadInformation::fNeighbors
std::vector< Int_t > fNeighbors
Definition: CbmClusteringGeometry.h:99
CbmMuchPad.h
CbmClusteringGeometry::PadInformation::fDy
Float_t fDy
Definition: CbmClusteringGeometry.h:92
CbmClusteringGeometry::GetMax
T2 GetMax(T2 &a, T2 &b)
Definition: CbmClusteringGeometry.cxx:419
CbmMuchAddress::GetElementAddress
static Int_t GetElementAddress(Int_t address, Int_t level)
Definition: CbmMuchAddress.h:122
CbmMuchPadRectangular.h
CbmStsPoint.h
CbmMCTrack.h
CbmMuchAddress.h
CbmClusteringGeometry::GetDx
Float_t GetDx(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:367
CbmMuchPadRadial.h
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:60
CbmClusteringGeometry::GetDy
Float_t GetDy(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:369
CbmClusteringGeometry::GetY0
Float_t GetY0(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:371
CbmClusteringGeometry::GetNeighbors
std::vector< Int_t > GetNeighbors(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:452
CbmMuchPixelHit.h
Class for pixel hits in MUCH detector.
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmClusteringGeometry::GetDigiNum
Int_t GetDigiNum(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:373
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:137
CbmClusteringGeometry::GetPadID
Long64_t GetPadID(Int_t iPad)
Definition: CbmClusteringGeometry.cxx:393
CbmClusteringGeometry::PadInformation::fNofNeighbors
Int_t fNofNeighbors
Definition: CbmClusteringGeometry.h:97
CbmClusteringGeometry::fPadList
PadInformation * fPadList
Definition: CbmClusteringGeometry.h:103
CbmClusteringGeometry::SetAPadsPlusOne
void SetAPadsPlusOne()
Definition: CbmClusteringGeometry.cxx:407
CbmMuchGeoScheme.h
CbmClusteringGeometry::GetPadByChannelId
Int_t GetPadByChannelId(Long64_t chId)
Definition: CbmClusteringGeometry.cxx:436
CbmClusteringGeometry::PadInformation::nSector
Int_t nSector
Definition: CbmClusteringGeometry.h:101
CbmClusteringGeometry::SetMuchModuleGeometryRadialFast
void SetMuchModuleGeometryRadialFast(Int_t nStation, Int_t nLayer, Bool_t nSide, Int_t nModule, CbmMuchGeoScheme *scheme)
Definition: CbmClusteringGeometry.cxx:268
CbmClusteringGeometry::PadInformation::channelID
Long64_t channelID
Definition: CbmClusteringGeometry.h:100
CbmMuchStation.h
CbmMuchModuleGem::GetSectorByIndex
CbmMuchSector * GetSectorByIndex(Int_t iSector)
Definition: CbmMuchModuleGem.h:54
CbmClusteringGeometry::fPadByChannelId
std::map< Long64_t, Int_t > fPadByChannelId
Definition: CbmClusteringGeometry.h:89
CbmClusteringGeometry::SubEqual
Bool_t SubEqual(Double_t x1, Double_t x2, Double_t l)
Definition: CbmClusteringGeometry.cxx:427
CbmMuchModuleGem::GetNSectors
Int_t GetNSectors() const
Definition: CbmMuchModuleGem.h:57
CbmClusteringGeometry::PadInformation
Definition: CbmClusteringGeometry.h:90
CbmMuchModuleGem.h
CbmStsHit.h
Data class for a reconstructed hit in the STS.
CbmClusteringGeometry::CbmClusteringSetPad
void CbmClusteringSetPad(Int_t nPad, Float_t x, Float_t y, Float_t dx, Float_t dy, Double_t phi1, Double_t phi2, Float_t r1, Float_t r2, Int_t digiNum, UInt_t charge, Long64_t chID)
Definition: CbmClusteringGeometry.cxx:70