CbmRoot
CbmMuchClustering.cxx
Go to the documentation of this file.
1 /*
2  * CbmMuchClustering.cxx
3  *
4  * Created on: Mar 5, 2012
5  * Author: kozlov
6  */
7 
8 #include "CbmMuchClustering.h"
9 #include "CbmClusteringA1.h"
10 #include "CbmClusteringGeometry.h"
11 #include "CbmClusteringSL.h"
12 #include "CbmClusteringWard.h"
13 #include "CbmDigiManager.h"
14 #include "CbmMCTrack.h"
15 #include "CbmMuchAddress.h"
16 #include "CbmMuchCluster.h"
17 #include "CbmMuchDigi.h"
18 #include "CbmMuchDigiMatch.h"
19 #include "CbmMuchGeoScheme.h"
20 #include "CbmMuchModule.h"
21 #include "CbmMuchModuleGem.h"
22 #include "CbmMuchModuleGemRadial.h"
23 #include "CbmMuchPad.h"
24 #include "CbmMuchPadRadial.h"
25 #include "CbmMuchPixelHit.h"
26 #include "CbmMuchPoint.h"
27 #include "CbmMuchStation.h"
28 #include "FairRootManager.h"
29 #include "TStopwatch.h"
30 
31 #include "TClonesArray.h"
32 #include "TMath.h"
33 
34 #include "TCanvas.h"
35 #include "TH1F.h"
36 #include "draw/CbmDrawHist.h"
37 #include <TFile.h>
38 
39 #include <cassert>
40 #include <iomanip>
41 #include <iostream>
42 #include <map>
43 #include <vector>
44 
45 using std::cout;
46 using std::endl;
47 using std::vector;
48 
49 CbmMuchClustering::CbmMuchClustering(const char* digiFileName)
50  : FairTask()
51  , fModulesGeometryArray()
52  , fDigiFile(digiFileName)
53  , fScheme(CbmMuchGeoScheme::Instance())
54  , fCluster()
55  , fHit()
56  , fNofClusters() {
57  fAlgorithmVersion = 2;
58  fNofModules = 0;
59  fNofEvents = 0;
60 }
61 
62 CbmMuchClustering::~CbmMuchClustering() {
63  if (fHit) {
64  fHit->Delete();
65  delete fHit;
66  }
67  if (fCluster) {
68  fCluster->Delete();
69  delete fCluster;
70  }
71 }
72 
73 InitStatus CbmMuchClustering::Init() {
74  std::cout << "CbmMuchClustering::Init" << std::endl;
75 
76  // Initialize GeoScheme
77  TFile* oldfile = gFile;
78  TFile* file = new TFile(fDigiFile);
79  TObjArray* stations = (TObjArray*) file->Get("stations");
80  file->Close();
81  file->Delete();
82  gFile = oldfile;
83  fScheme->Init(stations, 0);
84  // Initialize arrays of objects
85  ReadDataBranches();
86  // Create special geometry for every module
87  CreateModulesGeometryArray();
88 
89  return kSUCCESS;
90 }
91 
92 void CbmMuchClustering::Exec(Option_t* /*opt*/) {
93  //static Int_t eventNo = 0;
94  TStopwatch timer;
95  timer.Start();
96  //std::cout << "CbmMuchClustering::Exec: event No=" << fNofEvents << std::endl;
97  fNofEvents++;
98  if (fDigiMan->GetNofDigis(ECbmModuleId::kMuch) < 1) {
99  cout << "-I- " << GetName() << "::Exec: No digis found, event skipped. "
100  << endl;
101  fNofEvents--;
102  return;
103  }
104  fNofClusters = 0;
105  // Clear output array
106  if (fHit) fHit->Clear();
107  if (fCluster) fCluster->Delete();
108  // Initialize digi charges for special geometry in one event
109  SetDigiCharges();
110  // Find clusters and hits
111  ClusteringMainFunction();
112  // Clear digi charges array
113  ClearDigiCharges();
114  timer.Stop();
115  std::cout << "CbmMuchClustering: time " << timer.RealTime()
116  << "; clusters: " << fNofClusters << "\n";
117 }
118 
119 void CbmMuchClustering::Finish() {
120  std::cout << "CbmMuchClustering::Finish" << std::endl;
121 }
122 
123 void CbmMuchClustering::ReadDataBranches() {
124  FairRootManager* ioman = FairRootManager::Instance();
125  assert(ioman != NULL);
126  fDigiMan = CbmDigiManager::Instance();
127  fDigiMan->Init();
128  fCluster = new TClonesArray("CbmMuchCluster", 1000);
129  ioman->Register("MuchCluster",
130  "Cluster in MUCH",
131  fCluster,
132  IsOutputBranchPersistent("MuchCluster"));
133  fHit = new TClonesArray("CbmMuchPixelHit", 1000);
134  ioman->Register("MuchPixelHit",
135  "Hit in MUCH",
136  fHit,
137  IsOutputBranchPersistent("MuchPixelHit"));
138 }
139 
140 void CbmMuchClustering::CreateModulesGeometryArray() {
141  fNofModules = 0;
142  fModulesGeometryArray.clear();
143  Int_t iModule = 0;
144  Int_t nModules = 0;
145  // Create special geometry for all modules
146  for (Int_t iSt = 0; iSt < fScheme->GetNStations(); iSt++) {
147  CbmMuchStation* station = (CbmMuchStation*) fScheme->GetStation(iSt);
148  Int_t nLayers = station->GetNLayers();
149  for (Int_t iL = 0; iL < nLayers; iL++) {
150  CbmMuchLayer* layer = (CbmMuchLayer*) station->GetLayer(iL);
151  CbmMuchLayerSide* lside = (CbmMuchLayerSide*) layer->GetSideF();
152  nModules = lside->GetNModules();
153  fNofModules += nModules;
154  for (Int_t iMod = 0; iMod < nModules; iMod++) {
155  // Add special module geometry in array
156  fModulesGeometryArray.push_back(
157  new CbmClusteringGeometry(iSt, iL, 0, iMod, fScheme));
158  // Add module index in map
159  fModulesByDetId[fModulesGeometryArray[iModule]->GetDetId()] = iModule;
160  iModule++;
161  }
162  lside = (CbmMuchLayerSide*) layer->GetSideB();
163  nModules = lside->GetNModules();
164  fNofModules += nModules;
165  for (Int_t iMod = 0; iMod < nModules; iMod++) {
166  // Add special module geometry in array
167  fModulesGeometryArray.push_back(
168  new CbmClusteringGeometry(iSt, iL, 1, iMod, fScheme));
169  // Add module index in map
170  fModulesByDetId[fModulesGeometryArray[iModule]->GetDetId()] = iModule;
171  iModule++;
172  }
173  std::cout << "Layer " << iL << " geometry created successful.\n";
174  }
175  std::cout << "Station " << iSt << " geometry created successful.\n";
176  }
177 }
178 
179 void CbmMuchClustering::SetDigiCharges() {
180  for (Int_t iDigi = 0; iDigi < fDigiMan->GetNofDigis(ECbmModuleId::kMuch);
181  iDigi++) {
182  const CbmMuchDigi* muchDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
183  Long64_t chId = muchDigi->GetAddress();
184  Int_t detID = CbmMuchAddress::GetElementAddress(chId, kMuchModule);
185  Int_t iPad =
186  fModulesGeometryArray[fModulesByDetId[detID]]->GetPadByChannelId(chId);
187  fModulesGeometryArray[fModulesByDetId[detID]]->SetPadCharge(
188  iPad, muchDigi->GetAdc());
189  fModulesGeometryArray[fModulesByDetId[detID]]->SetDigiNum(iPad, iDigi);
190  fModulesGeometryArray[fModulesByDetId[detID]]->SetAPadsPlusOne();
191  }
192 }
193 
194 void CbmMuchClustering::ClearDigiCharges() {
195  for (Int_t iDigi = 0; iDigi < fDigiMan->GetNofDigis(ECbmModuleId::kMuch);
196  iDigi++) {
197  const CbmMuchDigi* muchDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
198  Long64_t chId = muchDigi->GetChannelId();
199  Int_t detID = CbmMuchAddress::GetElementAddress(chId, kMuchModule);
200  Int_t iPad =
201  fModulesGeometryArray[fModulesByDetId[detID]]->GetPadByChannelId(chId);
202  fModulesGeometryArray[fModulesByDetId[detID]]->SetPadCharge(iPad, 0);
203  fModulesGeometryArray[fModulesByDetId[detID]]->SetDigiNum(iPad, 0);
204  fModulesGeometryArray[fModulesByDetId[detID]]->SetAPadsNom(0);
205  }
206 }
207 
208 void CbmMuchClustering::ClusteringMainFunction() {
209  for (Int_t iMod = 0; iMod < fNofModules; iMod++) {
210  CbmMuchModuleGem* module = (CbmMuchModuleGem*) fScheme->GetModuleByDetId(
211  fModulesGeometryArray[iMod]->GetDetId());
212  // Switching clustering algorithm by function SetAlgorithmVersion
213  switch (fAlgorithmVersion) {
214  case 1: { // 1 - Developed algorithm, using all neighbors
215  ClusteringA1(fModulesGeometryArray[iMod], module, 1);
216  break;
217  }
218  case 2: { // 2 - Developed algorithm, do not using diagonal neighbors
219  ClusteringA1(fModulesGeometryArray[iMod], module, 2);
220  break;
221  }
222  case 3: { // 3 - Simple Single Linkage method, using all neighbors
223  ClusteringSL(fModulesGeometryArray[iMod], module, 1);
224  break;
225  }
226  case 4: { // 4 - Simple Single Linkage method, do not using diagonal neighbors;
227  ClusteringSL(fModulesGeometryArray[iMod], module, 2);
228  break;
229  }
230  case 5: { // 5 - Ward's method (!) not tested
231  //ClusteringWard(fModulesGeometryArray[iMod], module);
232  std::cout << "CbmMuchClustering: Error! Algorithm not tested\n";
233  break;
234  }
235  default:
236  std::cout
237  << "CbmMuchClustering: Error! Wrong version of the algorithm.\n";
238  break;
239  }
240  }
241 }
242 
243 void CbmMuchClustering::ClusteringA1(CbmClusteringGeometry* m1,
244  CbmMuchModuleGem* m2,
245  Int_t Ver) {
246  // Create developed algorithm class for module m1
247  CbmClusteringA1* clustersA1 = new CbmClusteringA1(m1);
248  // Start algorithm
249  clustersA1->MainClusteringA1(m1, Ver);
250  // Increase number of clusters
251  fNofClusters += clustersA1->GetNofClusters();
252  // Write Clusters and Hits in output arrays
253  vector<Int_t> digiIndices;
254  for (Int_t iCl = 0; iCl < clustersA1->GetNofClusters(); iCl++) {
255  digiIndices.clear();
256  Double_t sumq = 0, sumx = 0, sumy = 0, sumt = 0, sumdx2 = 0, sumdy2 = 0,
257  sumdxy2 = 0, sumdt2 = 0;
258  Double_t q = 0, x = 0, y = 0, t = 0, z = 0, dx = 0, dy = 0, dxy = 0, dt = 0;
259  Double_t tmin = -1;
260  x = clustersA1->GetX0(iCl);
261  y = clustersA1->GetY0(iCl);
262  z = m2->GetPosition()[2];
263  CbmMuchPad* pad = NULL;
264  Int_t address = 0;
265  Int_t planeId = 0;
266  for (Int_t iPad = 0; iPad < clustersA1->GetNofPads(iCl); iPad++) {
267  Int_t iDigi = clustersA1->GetPadInCluster(iCl, iPad);
268  const CbmMuchDigi* muchDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
269  if (iPad == 0) {
270  address = CbmMuchAddress::GetElementAddress(muchDigi->GetAddress(),
271  kMuchModule);
272  planeId = fScheme->GetLayerSideNr(address);
273  }
274  digiIndices.push_back(iDigi);
275  Long64_t channelId = muchDigi->GetChannelId();
276  pad = m2->GetPad(channelId);
277  t = muchDigi->GetTime();
278  if (tmin < 0) tmin = t;
279  if (tmin < t) tmin = t;
280  q = muchDigi->GetAdc();
281  dx = pad->GetDx();
282  dy = pad->GetDy();
283  dxy = pad->GetDxy();
284  dt = muchDigi->GetDTime();
285  sumq += q;
286  sumt += q * t;
287  sumdx2 += q * q * dx * dx;
288  sumdy2 += q * q * dy * dy;
289  sumdxy2 += q * q * dxy * dxy;
290  sumdt2 += q * q * dt * dt;
291  }
292  t = tmin;
293  dx = sqrt(sumdx2 / 12) / sumq;
294  dy = sqrt(sumdy2 / 12) / sumq;
295  dxy = sqrt(sumdxy2 / 12) / sumq;
296  dt = sqrt(sumdt2) / sumq;
297  Int_t nCluster = fCluster->GetEntriesFast();
298  CbmMuchCluster* cluster = new ((*fCluster)[nCluster]) CbmMuchCluster();
299  cluster->AddDigis(digiIndices);
300  Int_t nHit = fHit->GetEntriesFast();
301  new ((*fHit)[nHit]) CbmMuchPixelHit(
302  address, x, y, z, dx, dy, 0, dxy, nCluster, planeId, t, dt);
303  }
304  delete clustersA1;
305 }
306 
307 void CbmMuchClustering::ClusteringSL(CbmClusteringGeometry* m1,
308  CbmMuchModuleGem* m2,
309  Int_t Ver) {
310  // Create SL algorithm class for module m1
311  CbmClusteringSL* clustersSL = new CbmClusteringSL(m1);
312  // Start algorithm
313  clustersSL->MainClusteringSL(m1, Ver);
314  // Increase number of clusters
315  fNofClusters += clustersSL->GetNofClusters();
316  // Write Clusters and Hits in output arrays
317  vector<Int_t> digiIndices;
318  for (Int_t iCl = 0; iCl < clustersSL->GetNofClusters(); iCl++) {
319  digiIndices.clear();
320  Double_t sumq = 0, sumx = 0, sumy = 0, sumt = 0, sumdx2 = 0, sumdy2 = 0,
321  sumdxy2 = 0, sumdt2 = 0;
322  Double_t q = 0, x = 0, y = 0, t = 0, z = 0, dx = 0, dy = 0, dxy = 0, dt = 0;
323  Double_t tmin = -1;
324  x = clustersSL->GetX0(iCl);
325  y = clustersSL->GetY0(iCl);
326  z = m2->GetPosition()[2];
327  CbmMuchPad* pad = NULL;
328  Int_t address = 0;
329  Int_t planeId = 0;
330  for (Int_t iPad = 0; iPad < clustersSL->GetNofPads(iCl); iPad++) {
331  Int_t iDigi = clustersSL->GetPadInCluster(iCl, iPad);
332  const CbmMuchDigi* muchDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
333  if (iPad == 0) {
334  address = CbmMuchAddress::GetElementAddress(muchDigi->GetAddress(),
335  kMuchModule);
336  planeId = fScheme->GetLayerSideNr(address);
337  }
338  digiIndices.push_back(iDigi);
339  Long64_t channelId = muchDigi->GetChannelId();
340  pad = m2->GetPad(channelId);
341  t = muchDigi->GetTime();
342  if (tmin < 0) tmin = t;
343  if (tmin < t) tmin = t;
344  q = muchDigi->GetAdc();
345  dx = pad->GetDx();
346  dy = pad->GetDy();
347  dxy = pad->GetDxy();
348  dt = muchDigi->GetDTime();
349  sumq += q;
350  sumt += q * t;
351  sumdx2 += q * q * dx * dx;
352  sumdy2 += q * q * dy * dy;
353  sumdxy2 += q * q * dxy * dxy;
354  sumdt2 += q * q * dt * dt;
355  }
356  t = tmin;
357  dx = sqrt(sumdx2 / 12) / sumq;
358  dy = sqrt(sumdy2 / 12) / sumq;
359  dxy = sqrt(sumdxy2 / 12) / sumq;
360  dt = sqrt(sumdt2) / sumq;
361  Int_t nCluster = fCluster->GetEntriesFast();
362  CbmMuchCluster* cluster = new ((*fCluster)[nCluster]) CbmMuchCluster();
363  cluster->AddDigis(digiIndices);
364  Int_t nHit = fHit->GetEntriesFast();
365  new ((*fHit)[nHit]) CbmMuchPixelHit(
366  address, x, y, z, dx, dy, 0, dxy, nCluster, planeId, t, dt);
367  }
368  delete clustersSL;
369 }
370 
371 void CbmMuchClustering::ClusteringWard(CbmClusteringGeometry* m1,
372  CbmMuchModuleGem* m2) {
373  CbmClusteringWard* clustersWard = new CbmClusteringWard(m1, 1000);
374  clustersWard->WardMainFunction(m1, 100000);
375  fNofClusters += clustersWard->GetNofClusters();
376  for (Int_t iCl = 0; iCl < clustersWard->GetNofClusters(); iCl++) {
377  // std::cout<<">Start "<<iCl<<"\n";
378  vector<Int_t> digiIndices;
379  //---
380  //std::cout<<"=>Cluster "<<iCl<<"\n";
381  Int_t detId = m2->GetDetectorId();
382  Double_t sumq = 0, sumx = 0, sumy = 0, sumt = 0, sumdx2 = 0, sumdy2 = 0,
383  sumdxy2 = 0, sumdt2 = 0;
384  Double_t q = 0, x = 0, y = 0, t = 0, z = 0, dx = 0, dy = 0, dxy = 0, dt = 0;
385  // std::cout<<">Values created\n";
386  x = clustersWard->GetX0(iCl);
387  y = clustersWard->GetY0(iCl);
388  z = m2->GetPosition()[2];
389  // std::cout<<">Center - ok; x: "<<x<<"; y: "<<y<<"; z: "<<z<<"\n";
390  CbmMuchPad* pad = NULL;
391  // std::cout<<">Start calculations... \n";
392  for (Int_t iPad = 0; iPad < clustersWard->GetNofPads(iCl); iPad++) {
393  Int_t iDigi = clustersWard->GetPadInCluster(iCl, iPad);
394  // std::cout<<">>iDigi: "<<iDigi;
395  const CbmMuchDigi* muchDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
396  // std::cout<<" - ok";
397  digiIndices.push_back(iDigi);
398  // std::cout<<" - ok\n";
399  Long64_t channelId = muchDigi->GetChannelId();
400  // std::cout<<">>channelId: "<<channelId<<"\n";
401  pad = m2->GetPad(channelId);
402  // std::cout<<">>Pad - ok\n";
403  t = muchDigi->GetTime();
404  q = muchDigi->GetADCCharge();
405  // std::cout<<">>t, q - ok\n";
406  dx = 1; //pad->GetDx();
407  // std::cout<<">>dx - ok\n";
408  dy = 1; //pad->GetDy();
409  // std::cout<<">>dy - ok\n";
410  dxy = pad->GetDxy();
411  // std::cout<<">>dxy - ok\n";
412  dt = muchDigi->GetDTime();
413  // std::cout<<">>dt - ok\n";
414  sumq += q;
415  sumt += q * t;
416  sumdx2 += q * q * dx * dx;
417  sumdy2 += q * q * dy * dy;
418  sumdxy2 += q * q * dxy * dxy;
419  sumdt2 += q * q * dt * dt;
420  // std::cout<<">>sum - ok\n";
421  }
422  // std::cout<<" ...finished\n";
423  t = sumt / sumq;
424  dx = sqrt(sumdx2 / 12) / sumq;
425  dy = sqrt(sumdy2 / 12) / sumq;
426  dxy = sqrt(sumdxy2 / 12) / sumq;
427  dt = sqrt(sumdt2) / sumq;
428  // std::cout<<"-----Data calculated for Cl "<<iCl<<"\n";
429  Int_t nCluster = fCluster->GetEntriesFast();
430  // std::cout<<"-------Add cluster "<<nCluster<<"; nDigis: "<<digiIndices.size();
431  CbmMuchCluster* cluster = new ((*fCluster)[nCluster]) CbmMuchCluster();
432  cluster->AddDigis(digiIndices);
433  // std::cout<<" - ok\n";
434  //---
435  Int_t planeId = fScheme->GetLayerSideNr(detId);
436  Int_t nHit = fHit->GetEntriesFast();
437  std::cout << "\nCluster: " << nHit << "; detId: " << detId
438  << "; NofPads: " << clustersWard->GetNofPads(iCl) << "\n";
439  std::cout << "x: " << x << "; y: " << y << "; z: " << z << "\n";
440  std::cout << "dx: " << dx << "; dy: " << dy << "; dxy: " << dxy << "\n";
441  std::cout << "planeId: " << planeId << "; t: " << t << "; dt: " << dt
442  << "\n";
443  std::cout << "-------\n";
444  // std::cout<<"-------Add Hit "<<nHit;
445  new ((*fHit)[nHit])
446  CbmMuchPixelHit(detId, x, y, z, dx, dy, 0, dxy, nCluster, planeId, t, dt);
447  // std::cout<<" - ok\n";
448  }
449  delete clustersWard;
450 }
451 ClassImp(CbmMuchClustering);
CbmClusteringWard.h
CbmMuchModule.h
CbmMuchDigi.h
CbmClusteringA1::GetX0
Float_t GetX0(Int_t iCluster)
Definition: CbmClusteringA1.cxx:188
CbmMuchGeoScheme
Definition: CbmMuchGeoScheme.h:43
CbmClusteringSL::GetX0
Float_t GetX0(Int_t iCluster)
Definition: CbmClusteringSL.cxx:167
CbmMuchStation::GetLayer
CbmMuchLayer * GetLayer(Int_t iLayer) const
Definition: CbmMuchStation.h:58
CbmMuchDigi::GetTime
virtual Double_t GetTime() const
Definition: CbmMuchDigi.h:78
CbmMuchStation
Definition: CbmMuchStation.h:22
CbmMuchClustering::fNofModules
Int_t fNofModules
Definition: CbmMuchClustering.h:56
CbmClusteringGeometry.h
CbmMuchClustering::ClusteringWard
void ClusteringWard(CbmClusteringGeometry *m1, CbmMuchModuleGem *m2)
Definition: CbmMuchClustering.cxx:371
CbmMuchDigi::GetChannelId
Int_t GetChannelId() const
Definition: CbmMuchDigi.h:91
CbmClusteringA1.h
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:41
CbmMuchClustering::fModulesByDetId
std::map< Int_t, Int_t > fModulesByDetId
Definition: CbmMuchClustering.h:63
CbmMuchClustering::SetDigiCharges
void SetDigiCharges()
Definition: CbmMuchClustering.cxx:179
CbmClusteringSL::GetY0
Float_t GetY0(Int_t iCluster)
Definition: CbmClusteringSL.cxx:170
CbmDigiManager::Init
InitStatus Init()
Initialisation.
Definition: CbmDigiManager.cxx:71
CbmMuchCluster
Data container for MUCH clusters.
Definition: CbmMuchCluster.h:20
CbmMuchDigi::GetAdc
UShort_t GetAdc() const
Definition: CbmMuchDigi.h:74
CbmMuchClustering::ClusteringMainFunction
void ClusteringMainFunction()
Definition: CbmMuchClustering.cxx:208
CbmClusteringA1::GetNofClusters
Int_t GetNofClusters() const
Definition: CbmClusteringA1.h:30
CbmMuchPad::GetDy
Double_t GetDy() const
Definition: CbmMuchPad.h:31
CbmDigiManager::GetNofDigis
static Int_t GetNofDigis(ECbmModuleId systemId)
Definition: CbmDigiManager.cxx:62
CbmMuchGeoScheme::Init
void Init(TObjArray *stations, Int_t flag)
Definition: CbmMuchGeoScheme.cxx:121
CbmClusteringA1::GetPadInCluster
Int_t GetPadInCluster(Int_t iCluster, Int_t iPad)
Definition: CbmClusteringA1.cxx:200
CbmDrawHist.h
Helper functions for drawing 1D and 2D histograms and graphs.
CbmClusteringSL.h
CbmClusteringA1::MainClusteringA1
void MainClusteringA1(CbmClusteringGeometry *moduleGeo, Int_t algVersion)
Definition: CbmClusteringA1.cxx:70
CbmMuchClustering::fDigiFile
TString fDigiFile
Definition: CbmMuchClustering.h:60
CbmMuchPad::GetDx
Double_t GetDx() const
Definition: CbmMuchPad.h:30
CbmMuchModuleGemRadial.h
CbmDigiManager::Instance
static CbmDigiManager * Instance()
Static instance.
Definition: CbmDigiManager.h:93
CbmMuchClustering::fModulesGeometryArray
std::vector< CbmClusteringGeometry * > fModulesGeometryArray
Definition: CbmMuchClustering.h:62
CbmMuchClustering::Init
virtual InitStatus Init()
Definition: CbmMuchClustering.cxx:73
CbmMuchModule::GetPosition
TVector3 GetPosition() const
Definition: CbmMuchModule.h:51
CbmMuchCluster.h
Data container for MUCH clusters.
CbmMuchClustering::fDigiMan
CbmDigiManager * fDigiMan
Definition: CbmMuchClustering.h:65
CbmClusteringSL::GetPadInCluster
Int_t GetPadInCluster(Int_t iCluster, Int_t iPad)
Definition: CbmClusteringSL.cxx:179
CbmClusteringSL::MainClusteringSL
void MainClusteringSL(CbmClusteringGeometry *moduleGeo, Int_t algVersion)
Definition: CbmClusteringSL.cxx:94
CbmMuchClustering::ClusteringA1
void ClusteringA1(CbmClusteringGeometry *m1, CbmMuchModuleGem *m2, Int_t Ver)
Definition: CbmMuchClustering.cxx:243
CbmMuchGeoScheme::GetNStations
Int_t GetNStations() const
Definition: CbmMuchGeoScheme.h:79
CbmMuchPad::GetDxy
Double_t GetDxy() const
Definition: CbmMuchPad.h:32
CbmMuchPoint.h
CbmMuchClustering::fNofEvents
Int_t fNofEvents
Definition: CbmMuchClustering.h:68
CbmMuchClustering::Exec
virtual void Exec(Option_t *opt)
Definition: CbmMuchClustering.cxx:92
CbmDigiManager::Get
const Digi * Get(Int_t index) const
Get a digi object.
Definition: CbmDigiManager.h:52
CbmMuchModuleGem
Definition: CbmMuchModuleGem.h:24
CbmClusteringSL::GetNofClusters
Int_t GetNofClusters() const
Definition: CbmClusteringSL.h:31
CbmMuchClustering::fAlgorithmVersion
Int_t fAlgorithmVersion
Definition: CbmMuchClustering.h:55
CbmMuchClustering::fHit
TClonesArray * fHit
Definition: CbmMuchClustering.h:67
CbmMuchLayerSide
Definition: CbmMuchLayerSide.h:22
CbmMuchDigi::GetAddress
virtual Int_t GetAddress() const
Definition: CbmMuchDigi.h:77
CbmMuchClustering::~CbmMuchClustering
virtual ~CbmMuchClustering()
Definition: CbmMuchClustering.cxx:62
CbmClusteringA1::GetY0
Float_t GetY0(Int_t iCluster)
Definition: CbmClusteringA1.cxx:191
CbmClusteringA1
Definition: CbmClusteringA1.h:16
ClassImp
ClassImp(CbmMuchClustering)
CbmClusteringSL
Definition: CbmClusteringSL.h:16
CbmClusteringWard::WardMainFunction
void WardMainFunction(CbmClusteringGeometry *moduleGeo, Float_t maxDistance)
Definition: CbmClusteringWard.cxx:717
CbmMuchModule::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchModule.h:48
CbmClusteringWard::GetNofClusters
Int_t GetNofClusters() const
Definition: CbmClusteringWard.h:51
CbmMuchDigi::GetDTime
Int_t GetDTime() const
Definition: CbmMuchDigi.h:93
CbmMuchClustering.h
CbmMuchPad.h
CbmMuchDigi
Definition: CbmMuchDigi.h:31
CbmMuchPad
Definition: CbmMuchPad.h:21
CbmClusteringWard::GetPadInCluster
Int_t GetPadInCluster(Int_t iCluster, Int_t iPad)
Definition: CbmClusteringWard.cxx:754
CbmClusteringWard::GetNofPads
Int_t GetNofPads() const
Definition: CbmClusteringWard.h:53
CbmMuchAddress::GetElementAddress
static Int_t GetElementAddress(Int_t address, Int_t level)
Definition: CbmMuchAddress.h:122
CbmClusteringWard
Definition: CbmClusteringWard.h:20
CbmMCTrack.h
CbmMuchClustering::ClearDigiCharges
void ClearDigiCharges()
Definition: CbmMuchClustering.cxx:194
CbmMuchAddress.h
CbmDigiManager.h
CbmMuchPadRadial.h
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMuchClustering::fNofClusters
Int_t fNofClusters
Definition: CbmMuchClustering.h:57
CbmMuchPixelHit.h
Class for pixel hits in MUCH detector.
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmClusteringWard::GetX0
Float_t GetX0(Int_t iCluster)
Definition: CbmClusteringWard.cxx:742
CbmMuchClustering::CreateModulesGeometryArray
void CreateModulesGeometryArray()
Definition: CbmMuchClustering.cxx:140
CbmMuchGeoScheme::GetStation
CbmMuchStation * GetStation(Int_t iStation) const
Definition: CbmMuchGeoScheme.cxx:209
CbmMuchClustering::fScheme
CbmMuchGeoScheme * fScheme
Definition: CbmMuchClustering.h:59
CbmMuchStation::GetNLayers
Int_t GetNLayers() const
Definition: CbmMuchStation.h:50
CbmMuchClustering::ReadDataBranches
void ReadDataBranches()
Definition: CbmMuchClustering.cxx:123
ECbmModuleId::kMuch
@ kMuch
Muon detection system.
kMuchModule
@ kMuchModule
Module.
Definition: CbmMuchAddress.h:20
CbmMuchDigiMatch.h
CbmMuchPixelHit
Definition: CbmMuchPixelHit.h:17
CbmClusteringGeometry
Definition: CbmClusteringGeometry.h:17
CbmMuchClustering::CbmMuchClustering
CbmMuchClustering(const char *digiFileName)
Definition: CbmMuchClustering.cxx:49
CbmMuchGeoScheme.h
CbmMuchLayer::GetSideF
CbmMuchLayerSide * GetSideF()
Definition: CbmMuchLayer.h:47
CbmCluster::AddDigis
void AddDigis(const std::vector< Int_t > &indices)
Add array of digi to cluster.
Definition: CbmCluster.h:53
CbmMuchLayer
Definition: CbmMuchLayer.h:21
CbmMuchLayer::GetSideB
CbmMuchLayerSide * GetSideB()
Definition: CbmMuchLayer.h:48
CbmMuchClustering::fCluster
TClonesArray * fCluster
Interface to digi data.
Definition: CbmMuchClustering.h:66
CbmMuchGeoScheme::GetModuleByDetId
CbmMuchModule * GetModuleByDetId(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:278
CbmMuchStation.h
CbmMuchModuleGem::GetPad
CbmMuchPad * GetPad(Int_t address)
Definition: CbmMuchModuleGem.cxx:79
CbmMuchDigi::GetADCCharge
Int_t GetADCCharge() const
Definition: CbmMuchDigi.h:92
CbmClusteringSL::GetNofPads
Int_t GetNofPads() const
Definition: CbmClusteringSL.h:32
CbmMuchClustering::Finish
virtual void Finish()
Definition: CbmMuchClustering.cxx:119
CbmMuchModuleGem.h
CbmMuchClustering::ClusteringSL
void ClusteringSL(CbmClusteringGeometry *m1, CbmMuchModuleGem *m2, Int_t Ver)
Definition: CbmMuchClustering.cxx:307
CbmClusteringWard::GetY0
Float_t GetY0(Int_t iCluster)
Definition: CbmClusteringWard.cxx:745
CbmMuchGeoScheme::GetLayerSideNr
Int_t GetLayerSideNr(Int_t detId) const
Definition: CbmMuchGeoScheme.cxx:403
CbmMuchClustering
Definition: CbmMuchClustering.h:28
CbmMuchLayerSide::GetNModules
Int_t GetNModules() const
Definition: CbmMuchLayerSide.h:47
CbmClusteringA1::GetNofPads
Int_t GetNofPads() const
Definition: CbmClusteringA1.h:31