BmnRoot 26.10.0-210-gc52d34b0
Software framework of the BM@N experiment
Loading...
Searching...
No Matches
CbmStsRealClusterFinder.cxx
Go to the documentation of this file.
1//* $Id: */
2
3// -------------------------------------------------------------------------
4// ----- CbmStsRealClusterFinder source fil -----
5// ----- Created 26/06/2008 by R. Karabowicz -----
6// -------------------------------------------------------------------------
7// -------------------------------------------------------------------------
8#include "CbmStsRealClusterFinder.h"
9
10#include "CbmGeoStsPar.h"
11#include "CbmStsCluster.h"
12#include "CbmStsDigi.h"
13#include "CbmStsDigiPar.h"
14#include "CbmStsDigiScheme.h"
15#include "CbmStsHit.h"
16#include "CbmStsSector.h"
17#include "CbmStsStation.h"
18#include "FairRootManager.h"
19#include "FairRunAna.h"
20#include "FairRuntimeDb.h"
21#include "TClonesArray.h"
22#include "TH1S.h"
23#include "TMath.h"
24
25#include <iomanip>
26
27using std::cerr;
28using std::cout;
29using std::endl;
30using std::fixed;
31using std::flush;
32using std::left;
33using std::map;
34using std::right;
35using std::set;
36using std::setprecision;
37using std::setw;
38
39// ----- Default constructor ------------------------------------------
40CbmStsRealClusterFinder::CbmStsRealClusterFinder()
41 : FairTask("STS Cluster Finder", 1)
42{
43 fGeoPar = NULL;
44 fDigiPar = NULL;
45 fDigis = NULL;
46 fClusters = NULL;
47 fDigiScheme = new CbmStsDigiScheme();
48}
49// -------------------------------------------------------------------------
50
51// ----- Standard constructor ------------------------------------------
52CbmStsRealClusterFinder::CbmStsRealClusterFinder(Int_t iVerbose)
53 : FairTask("STSClusterFinder", iVerbose)
54{
55 fGeoPar = NULL;
56 fDigiPar = NULL;
57 fDigis = NULL;
58 fClusters = NULL;
59 fDigiScheme = new CbmStsDigiScheme();
60}
61// -------------------------------------------------------------------------
62
63// ----- Constructor with name -----------------------------------------
64CbmStsRealClusterFinder::CbmStsRealClusterFinder(const char* name, Int_t iVerbose)
65 : FairTask(name, iVerbose)
66{
67 fGeoPar = NULL;
68 fDigiPar = NULL;
69 fDigis = NULL;
70 fClusters = NULL;
71 fDigiScheme = new CbmStsDigiScheme();
72}
73// -------------------------------------------------------------------------
74
75// ----- Destructor ----------------------------------------------------
76CbmStsRealClusterFinder::~CbmStsRealClusterFinder()
77{
78 if (fClusters) {
79 fClusters->Delete();
80 delete fClusters;
81 }
82}
83// -------------------------------------------------------------------------
84
85// ----- Public method Exec --------------------------------------------
86void CbmStsRealClusterFinder::Exec(Option_t* opt)
87{
88
89 fTimer.Start();
90 Bool_t warn = kFALSE;
91
92 if (fVerbose) {
93 cout << endl << "-I- " << fName << ": executing event with " << fDigis->GetEntriesFast() << " digis." << endl;
94 cout << "----------------------------------------------" << endl;
95 }
96
97 // Check for digi scheme
98 if (!fDigiScheme) {
99 cerr << "-E- " << fName << "::Exec: No digi scheme!" << endl;
100 return;
101 }
102
103 // Clear output array
104 // cout << "before clear: " << fClusters->GetEntriesFast() << endl;
105 fNofClusters = 0;
106 // fClusters->Clear();
107 fClusters->Delete();
108 // cout << " after clear: " << fClusters->GetEntriesFast() << endl;
109
110 // Sort STS digis with respect to sectors
111 SortDigis();
112
113 // Find hits in sectors
114 Int_t nDigisF = 0;
115 Int_t nDigisB = 0;
116 Int_t nStations = fDigiScheme->GetNStations();
117 CbmStsStation* station = NULL;
118 for (Int_t iStation = 0; iStation < nStations; iStation++) {
119 station = fDigiScheme->GetStation(iStation);
120 Int_t nDigisFInStation = 0;
121 Int_t nDigisBInStation = 0;
122 Int_t nSectors = station->GetNSectors();
123
124 for (Int_t iSector = 0; iSector < nSectors; iSector++) {
125 CbmStsSector* sector = station->GetSector(iSector);
126 // cout << "=============================================================================" << endl;
127 // cout << "station " << iStation+1 << " sector " << iSector+1 << " " << endl;
128 set<Int_t> fSet, bSet;
129 if (fDigiMapF.find(sector) == fDigiMapF.end()) {
130 cout << "-E- " << fName << "::Exec: sector " << sector->GetSectorNr() << " of station "
131 << station->GetStationNr() << "not found in front map!" << endl;
132 warn = kTRUE;
133 continue;
134 }
135 fSet = fDigiMapF[sector];
136 FindClusters(iStation + 1, iSector + 1, 0, fSet);
137 if (sector->GetType() == 2 || sector->GetType() == 3) {
138 if (fDigiMapB.find(sector) == fDigiMapB.end()) {
139 cout << "-E- " << fName << "::Exec: sector " << sector->GetSectorNr() << " of station "
140 << station->GetStationNr() << "not found in back map!" << endl;
141 warn = kTRUE;
142 continue;
143 }
144 }
145 bSet = fDigiMapB[sector];
146 FindClusters(iStation + 1, iSector + 1, 1, bSet);
147 Int_t nDigisFInSector = fSet.size();
148 Int_t nDigisBInSector = bSet.size();
149 nDigisFInStation += nDigisFInSector;
150 nDigisBInStation += nDigisBInSector;
151 } // Sector loop
152
153 nDigisF += nDigisFInStation;
154 nDigisB += nDigisBInStation;
155
156 } // Station loop
157
158 // analyze clusters...
159 AnalyzeClusters();
160
161 fTimer.Stop();
162 if (fVerbose) {
163 cout << endl;
164 cout << "-I- " << fName << ":Event summary" << endl;
165 cout << " Active channels front side: " << nDigisF << endl;
166 cout << " Active channels back side : " << nDigisB << endl;
167 cout << " Real time : " << fTimer.RealTime() << endl;
168 } else {
169 if (warn)
170 cout << "- ";
171 else
172 cout << "+ ";
173 cout << setw(15) << left << fName << ": " << setprecision(4) << setw(8) << fixed << right << fTimer.RealTime()
174 << " s, " << fNofClusters << "(" << fNofClustersGood << "+" << fNofClustersWP
175 << ") clusters, longest till now " << fLongestCluster << endl;
176 // cout << fDigis->GetEntriesFast() << " vs " << fClusters->GetEntriesFast() << endl;
177 }
178}
179// -------------------------------------------------------------------------
180
181// ----- Private method SetParContainers -------------------------------
182void CbmStsRealClusterFinder::SetParContainers()
183{
184
185 // Get run and runtime database
186 FairRunAna* run = FairRunAna::Instance();
187 if (!run)
188 Fatal("SetParContainers", "No analysis run");
189
190 FairRuntimeDb* db = run->GetRuntimeDb();
191 if (!db)
192 Fatal("SetParContainers", "No runtime database");
193
194 // Get STS geometry parameter container
195 fGeoPar = (CbmGeoStsPar*)db->getContainer("CbmGeoStsPar");
196
197 // Get STS digitisation parameter container
198 fDigiPar = (CbmStsDigiPar*)db->getContainer("CbmStsDigiPar");
199}
200// -------------------------------------------------------------------------
201
202// ----- Private method Init -------------------------------------------
203InitStatus CbmStsRealClusterFinder::Init()
204{
205
206 // Get input array
207 FairRootManager* ioman = FairRootManager::Instance();
208 if (!ioman)
209 Fatal("Init", "No FairRootManager");
210 fDigis = (TClonesArray*)ioman->GetObject("StsDigi");
211
212 fClusters = new TClonesArray("CbmStsCluster", 1000);
213 ioman->Register("StsCluster", "Cluster in STS", fClusters, kTRUE);
214
215 // Build digitisation scheme
216 Bool_t success = fDigiScheme->Init(fGeoPar, fDigiPar);
217 if (!success)
218 return kERROR;
219
220 // Create sectorwise digi sets
221 MakeSets();
222
223 // Control output
224 if (fVerbose == 1 || fVerbose == 2)
225 fDigiScheme->Print(kFALSE);
226 else if (fVerbose > 2)
227 fDigiScheme->Print(kTRUE);
228 cout << "-I- " << fName << "::Init: "
229 << "STS digitisation scheme succesfully initialised" << endl;
230 cout << " Stations: " << fDigiScheme->GetNStations() << ", Sectors: " << fDigiScheme->GetNSectors()
231 << ", Channels: " << fDigiScheme->GetNChannels() << endl;
232
233 fNofClusters = 0;
234 fNofClustersGood = 0;
235 fNofClustersWP = 0;
236 fNofClustersWM = 0;
237
238 fLongestCluster = 0;
239 fLongestGoodCluster = 0;
240
241 return kSUCCESS;
242}
243// -------------------------------------------------------------------------
244
245// ----- Private method ReInit -----------------------------------------
246InitStatus CbmStsRealClusterFinder::ReInit()
247{
248
249 // Clear digitisation scheme
250 fDigiScheme->Clear();
251
252 // Build new digitisation scheme
253 Bool_t success = fDigiScheme->Init(fGeoPar, fDigiPar);
254 if (!success)
255 return kERROR;
256
257 // Create sectorwise digi sets
258 MakeSets();
259
260 // Control output
261 if (fVerbose == 1 || fVerbose == 2)
262 fDigiScheme->Print(kFALSE);
263 else if (fVerbose > 2)
264 fDigiScheme->Print(kTRUE);
265 cout << "-I- " << fName << "::Init: "
266 << "STS digitisation scheme succesfully reinitialised" << endl;
267 cout << " Stations: " << fDigiScheme->GetNStations() << ", Sectors: " << fDigiScheme->GetNSectors()
268 << ", Channels: " << fDigiScheme->GetNChannels() << endl;
269
270 fNofClusters = 0;
271 fNofClustersGood = 0;
272 fNofClustersWP = 0;
273 fNofClustersWM = 0;
274
275 fLongestCluster = 0;
276 fLongestGoodCluster = 0;
277
278 return kSUCCESS;
279}
280// -------------------------------------------------------------------------
281
282// ----- Private method MakeSets ---------------------------------------
283void CbmStsRealClusterFinder::MakeSets()
284{
285
286 fDigiMapF.clear();
287 fDigiMapB.clear();
288 Int_t nStations = fDigiScheme->GetNStations();
289 for (Int_t iStation = 0; iStation < nStations; iStation++) {
290 CbmStsStation* station = fDigiScheme->GetStation(iStation);
291 Int_t nSectors = station->GetNSectors();
292 for (Int_t iSector = 0; iSector < nSectors; iSector++) {
293 CbmStsSector* sector = station->GetSector(iSector);
294 set<Int_t> a;
295 fDigiMapF[sector] = a;
296 if (sector->GetType() == 2 || sector->GetType() == 3) {
297 set<Int_t> b;
298 fDigiMapB[sector] = b;
299 }
300 }
301 }
302}
303// -------------------------------------------------------------------------
304
305// ----- Private method SortDigis --------------------------------------
306void CbmStsRealClusterFinder::SortDigis()
307{
308
309 // Check input array
310 if (!fDigis) {
311 cout << "-E- " << fName << "::SortDigis: No input array!" << endl;
312 return;
313 }
314
315 CbmStsDigi* digi = NULL;
316 const Int_t nDigis = fDigis->GetEntriesFast();
317
318 // Clear sector digi sets
319 map<CbmStsSector*, set<Int_t>>::iterator mapIt;
320 for (mapIt = fDigiMapF.begin(); mapIt != fDigiMapF.end(); mapIt++)
321 ((*mapIt).second).clear();
322 for (mapIt = fDigiMapB.begin(); mapIt != fDigiMapB.end(); mapIt++)
323 ((*mapIt).second).clear();
324
325 // Fill digis into sets
326 CbmStsSector* sector = NULL;
327 Int_t stationNr = -1;
328 Int_t sectorNr = -1;
329 Int_t iSide = -1;
330 Int_t channelNr = -1;
331
332 for (Int_t iDigi = 0; iDigi < nDigis; iDigi++) {
333 digi = (CbmStsDigi*)fDigis->At(iDigi);
334
335 stationNr = digi->GetStationNr();
336 sectorNr = digi->GetSectorNr();
337 iSide = digi->GetSide();
338 sector = fDigiScheme->GetSector(stationNr, sectorNr);
339 if (iSide == 0) {
340 if (fDigiMapF.find(sector) == fDigiMapF.end()) {
341 cerr << "-E- " << fName << "::SortDigits:: sector " << sectorNr << " of station " << stationNr
342 << " not found in digi scheme (F)!" << endl;
343 continue;
344 }
345 fDigiMapF[sector].insert(iDigi);
346 } else if (iSide == 1) {
347 if (fDigiMapB.find(sector) == fDigiMapB.end()) {
348 cerr << "-E- " << fName << "::SortDigits:: sector " << sectorNr << " of station " << stationNr
349 << " not found in digi scheme (B)!" << endl;
350 continue;
351 }
352 fDigiMapB[sector].insert(iDigi);
353 }
354 }
355}
356// -------------------------------------------------------------------------
357
358// ----- Private method RealisticResponse ------------------------------
359Int_t CbmStsRealClusterFinder::FindClusters(Int_t stationNr, Int_t sectorNr, Int_t iSide, set<Int_t>& digiSet)
360{
361
362 set<Int_t>::iterator it1;
363
364 Int_t iDigi = -1;
365 CbmStsDigi* digi = NULL;
366 CbmStsCluster* cluster = NULL;
367
368 Int_t digiPos = -1;
369 Double_t digiSig = -1.;
370 Int_t lastDigiNr = -1;
371 Int_t lastDigiPos = -1;
372 Double_t lastDigiSig = 100000.;
373 Int_t clusterMaxNr = -1;
374 Int_t clusterMaxPos = -1;
375 Double_t clusterMaxSig = -1.;
376 Bool_t clusterHasMinimum = kFALSE;
377 Bool_t clusterHasPlateau = kFALSE;
378 Int_t clusterBeginPos = 0;
379 Int_t clusterWidth = 0;
380 // cout << "====================================================================" << digiSet.size() << endl;
381 // cout << " cluster " << flush;
382 // if ( fNofClusters != fNofClustersGood+fNofClustersWP ) cout << fNofClusters-(fNofClustersGood+fNofClustersWP)
383 // << " -> " << fNofClusters <<"!="<< fNofClustersGood<<"+"<<fNofClustersWP<<endl;
384 for (it1 = digiSet.begin(); it1 != digiSet.end(); it1++) {
385 iDigi = (*it1);
386 digi = (CbmStsDigi*)fDigis->At(iDigi);
387
388 digiPos = digi->GetChannelNr();
389 digiSig = digi->GetADC();
390
391 if (lastDigiPos == -1) {
392 cluster = new ((*fClusters)[fNofClusters++]) CbmStsCluster(iDigi, stationNr, sectorNr, iSide);
393 // cout << "first cluster ADC " << digiSig << endl;
394 clusterBeginPos = digiPos;
395 }
396
397 if (digiPos == lastDigiPos + 1) {
398
399 if (digiSig == lastDigiSig) {
400 cluster->SetMeanError(digiSig);
401 clusterHasPlateau = kTRUE;
402 }
403
404 // if the signal is larger that last one and the previous one is smaller than maximum
405 if (digiSig > lastDigiSig && lastDigiSig < clusterMaxSig) {
406 cluster->SetMean(clusterMaxNr);
407 // cluster->SetMeanError(clusterMaxSig);
408 cluster = new ((*fClusters)[fNofClusters++]) CbmStsCluster(iDigi, stationNr, sectorNr, iSide);
409
410 cluster->AddDigi(lastDigiNr);
411 // cout << " +end cluster " << lastDigiPos << endl;
412
413 // cout << "+new cluster " << digiPos << endl;
414 clusterWidth = lastDigiPos - clusterBeginPos + 1;
415 if (clusterWidth > fLongestCluster)
416 fLongestCluster = clusterWidth;
417 if (clusterHasPlateau) {
418 fNofClustersWP++;
419 }
420 if (!clusterHasMinimum && !clusterHasPlateau) {
421 fNofClustersGood++;
422 if (clusterWidth > fLongestGoodCluster)
423 fLongestGoodCluster = clusterWidth;
424 }
425
426 clusterHasPlateau = kFALSE;
427 clusterMaxPos = -1;
428 clusterMaxSig = -1.;
429 clusterBeginPos = digiPos;
430 }
431 } else if (lastDigiPos >= 0) {
432 cluster->SetMean(clusterMaxNr);
433 // cluster->SetMeanError(clusterMaxSig);
434 cluster = new ((*fClusters)[fNofClusters++]) CbmStsCluster(iDigi, stationNr, sectorNr, iSide);
435 // cout << " end cluster " << lastDigiPos << endl;
436
437 // cout << "new cluster " << digiPos << endl;
438 clusterWidth = lastDigiPos - clusterBeginPos + 1;
439 if (clusterWidth > fLongestCluster)
440 fLongestCluster = clusterWidth;
441 if (clusterHasPlateau) {
442 fNofClustersWP++;
443 }
444 if (!clusterHasMinimum && !clusterHasPlateau) {
445 fNofClustersGood++;
446 if (clusterWidth > fLongestGoodCluster)
447 fLongestGoodCluster = clusterWidth;
448 }
449
450 clusterHasPlateau = kFALSE;
451 clusterMaxPos = -1;
452 clusterMaxSig = -1.;
453 clusterBeginPos = digiPos;
454 }
455 if (digiSig > clusterMaxSig) {
456 clusterMaxNr = iDigi;
457 clusterMaxPos = digiPos;
458 clusterMaxSig = digiSig;
459 }
460
461 clusterWidth = lastDigiPos - clusterBeginPos + 1;
462 if (clusterWidth < 90)
463 cluster->AddDigi(iDigi);
464 else {
465 // return 1;
466 cluster->SetMean(clusterMaxNr);
467 // cluster->SetMeanError(clusterMaxSig);
468
469 cluster = new ((*fClusters)[fNofClusters++]) CbmStsCluster(iDigi, stationNr, sectorNr, iSide);
470 cluster->AddDigi(iDigi);
471
472 clusterWidth = lastDigiPos - clusterBeginPos + 1;
473 if (clusterWidth > fLongestCluster)
474 fLongestCluster = clusterWidth;
475 if (clusterHasPlateau) {
476 fNofClustersWP++;
477 }
478 if (!clusterHasMinimum && !clusterHasPlateau) {
479 fNofClustersGood++;
480 if (clusterWidth > fLongestGoodCluster)
481 fLongestGoodCluster = clusterWidth;
482 }
483
484 clusterHasPlateau = kFALSE;
485 clusterMaxPos = -1;
486 clusterMaxSig = -1.;
487 clusterBeginPos = digiPos;
488 }
489
490 lastDigiNr = iDigi;
491 lastDigiPos = digiPos;
492 lastDigiSig = digiSig;
493 }
494 if (digiSig > 0.) {
495 cluster->SetMean(clusterMaxNr);
496
497 // cout << " last cluster " << lastDigiPos << endl;
498 clusterWidth = lastDigiPos - clusterBeginPos + 1;
499 if (clusterWidth > fLongestCluster)
500 fLongestCluster = clusterWidth;
501 if (clusterHasPlateau) {
502 fNofClustersWP++;
503 }
504 if (lastDigiPos && !clusterHasPlateau) {
505 fNofClustersGood++;
506 if (clusterWidth > fLongestGoodCluster)
507 fLongestGoodCluster = clusterWidth;
508 }
509 }
510
511 return 1;
512
513 map<Int_t, Int_t> channelSorted;
514 for (it1 = digiSet.begin(); it1 != digiSet.end(); it1++) {
515 iDigi = (*it1);
516 digi = (CbmStsDigi*)fDigis->At(iDigi);
517 cout << digi->GetChannelNr() << " " << flush;
518 channelSorted[digi->GetChannelNr()] = iDigi + 1;
519 }
520 cout << endl;
521 // print channels/signals
522 Int_t iFS = 0;
523 for (Int_t iter = 0; iter < 1100; iter++) {
524 iDigi = channelSorted[iter];
525 if (iDigi == 0)
526 continue;
527 iFS++;
528 digi = (CbmStsDigi*)fDigis->At(iDigi - 1);
529 if (iFS >= channelSorted.size())
530 break;
531 }
532 // cout << endl;
533
534 // cout << "size = " << channelSorted.size() << endl;
535 /* Int_t iFS = 0;
536 Float_t lastSignal = 0.;
537 for (Int_t iter=0; iter<1100; iter++) {
538 iDigi = channelSorted[iter];
539 if ( iDigi == 0 ) {lastSignal=0.;continue;}
540 iFS++;
541 digi = (CbmStsDigi*) fDigis->At(iDigi-1);
542 Float_t signal = digi->GetADC();
543 if ( signal <= lastSignal ) { lastSignal = signal; continue; }
544
545 if ( iFS >= channelSorted.size() ) break;
546
547
548 }*/
549 // cout << endl << "=============================================" << endl;
550}
551// -------------------------------------------------------------------------
552
553// ----- Method AnalyzeClusters ----------------------------------------
554void CbmStsRealClusterFinder::AnalyzeClusters()
555{
556 for (Int_t iclus = 0; iclus < fNofClusters; iclus++) {
557 AnalyzeCluster(iclus);
558 }
559}
560// -------------------------------------------------------------------------
561
562// ----- Method AnalyzeClusters ----------------------------------------
563void CbmStsRealClusterFinder::AnalyzeCluster(Int_t iCluster)
564{
565
566 CbmStsCluster* cluster = (CbmStsCluster*)fClusters->At(iCluster);
567 Int_t maxDigiNr = (Int_t)cluster->GetMean();
568 Double_t plateau = cluster->GetMeanError();
569 Double_t maxDigiSig = 0.;
570 CbmStsDigi* digi = NULL;
571 digi = (CbmStsDigi*)fDigis->At(maxDigiNr);
572 Int_t maxDigiPos = digi->GetChannelNr();
573 maxDigiSig = digi->GetADC() - plateau;
574 if (plateau) {
575 if (TMath::Abs(plateau - maxDigiSig) < 0.0001)
576 plateau = 0.;
577 // cout << "PLATEAU, but maxdigisig = " << maxDigiSig << " at " << maxDigiNr << " -> plateau = " << plateau
578 // << endl;
579 }
580
581 // cout << "Cluster " << iCluster+1 << " has " << cluster->GetNDigis() << " digis, max at " << maxDigiNr << endl;
582 Double_t chanNr = 0;
583 Double_t chanADC = 0.;
584 Double_t sumW = 0;
585 Double_t sumWX = 0;
586 for (Int_t itemp = 0; itemp < cluster->GetNDigis(); itemp++) {
587 digi = (CbmStsDigi*)fDigis->At(cluster->GetDigi(itemp));
588 chanNr = (Double_t)digi->GetChannelNr();
589 chanADC = digi->GetADC();
590 chanADC = (chanADC < plateau ? 0 : chanADC - plateau);
591 sumW += chanADC;
592 sumWX += chanNr * chanADC;
593 // cout << chanADC << " + " << flush;
594 // cout << "channel " << digi->GetChannelNr() << " with signal = " << digi->GetADC() << " (" << sumWX << "/"
595 // << sumW << ") - plateau = " << plateau << endl;
596 }
597 // cout << " mean at = " << sumWX/sumW << endl;
598 cluster->SetMean(sumWX / sumW);
599 cluster->SetMeanError(sumW / maxDigiSig);
600 if (sumW < maxDigiSig) {
601 cout << " MAX DIGI = " << maxDigiSig << ", while SUMW = " << sumW << endl;
602 for (Int_t itemp = 0; itemp < cluster->GetNDigis(); itemp++) {
603 digi = (CbmStsDigi*)fDigis->At(cluster->GetDigi(itemp));
604 cout << "digi ADC = " << digi->GetADC() << " at channel# " << digi->GetChannelNr() << endl;
605 }
606 }
607 // cout << sumWE/sumW << " mean at " << endl;
608 // cout << "error = " << sumW/maxDigiSig << endl;
609}
610// -------------------------------------------------------------------------
611
612// ----- Virtual method Finish -----------------------------------------
613void CbmStsRealClusterFinder::Finish()
614{
615 fNofClusters = fNofClustersGood + fNofClustersWP;
616 cout << endl;
617 cout << "============================================================" << endl;
618 cout << "===== " << fName << ": Run summary " << endl;
619 cout << "===== " << endl;
620 cout << "===== Number of clusters : " << setw(8) << setprecision(2) << fNofClusters << endl;
621 cout << "===== Number of good clusters : " << setw(8) << setprecision(2) << fNofClustersGood << " ("
622 << setw(8) << setprecision(2) << 100. * fNofClustersGood / fNofClusters << "%)" << endl;
623 cout << "===== Number of plateau clusters : " << setw(8) << setprecision(2) << fNofClustersWP << " ("
624 << setw(8) << setprecision(2) << 100. * fNofClustersWP / fNofClusters << "%)" << endl;
625 cout << "===== Number of minimum clusters : " << setw(8) << setprecision(2) << fNofClustersWM << " ("
626 << setw(8) << setprecision(2) << 100. * fNofClustersWM / fNofClusters << "%)" << endl;
627 cout << "===== Longest cluster : " << setw(8) << setprecision(2) << fLongestCluster << endl;
628 cout << "===== Longest good cluster : " << setw(8) << setprecision(2) << fLongestGoodCluster << endl;
629 cout << "============================================================" << endl;
630}
631// -------------------------------------------------------------------------
Bool_t
bool Bool_t
Int_t
int Int_t
kFALSE
constexpr Bool_t kFALSE
Double_t
double Double_t
kTRUE
constexpr Bool_t kTRUE
Option_t
const char Option_t
Fatal
void Fatal(const char *location, const char *msgfmt,...)
CbmStsCluster
CbmStsCluster.h.
Definition CbmStsCluster.h:32
CbmStsCluster::SetMeanError
void SetMeanError(Double_t err)
Definition CbmStsCluster.h:54
CbmStsCluster::SetMean
void SetMean(Double_t chan)
Definition CbmStsCluster.h:53
CbmStsCluster::GetMean
Double_t GetMean() const
Definition CbmStsCluster.h:68
CbmStsCluster::GetNDigis
Int_t GetNDigis() const
Definition CbmStsCluster.h:66
CbmStsCluster::GetMeanError
Double_t GetMeanError() const
Definition CbmStsCluster.h:69
CbmStsCluster::GetDigi
Int_t GetDigi(Int_t inum)
Definition CbmStsCluster.h:67
CbmStsCluster::AddDigi
void AddDigi(Int_t idigi)
Definition CbmStsCluster.h:49
CbmStsDigi
CbmStsDigi.h.
Definition CbmStsDigi.h:32
CbmStsDigi::GetSide
Int_t GetSide() const
Side ( 0 = front, 1 = back ).
Definition CbmStsDigi.h:73
CbmStsDigi::GetSectorNr
Int_t GetSectorNr() const
Sector number.
Definition CbmStsDigi.h:70
CbmStsDigi::GetChannelNr
Int_t GetChannelNr() const
Channel number.
Definition CbmStsDigi.h:76
CbmStsDigi::GetStationNr
Int_t GetStationNr() const
Station number.
Definition CbmStsDigi.h:67
CbmStsRealClusterFinder::MakeSets
void MakeSets()
Make sectorwise sets for sigis.
Definition CbmStsRealClusterFinder.cxx:283
CbmStsRealClusterFinder::SetParContainers
virtual void SetParContainers()
Get parameter containers.
Definition CbmStsRealClusterFinder.cxx:182
CbmStsRealClusterFinder::fDigiMapB
map< CbmStsSector *, set< Int_t > > fDigiMapB
sector digis (front)
Definition CbmStsRealClusterFinder.h:68
CbmStsRealClusterFinder::fTimer
TStopwatch fTimer
sector digis (back)
Definition CbmStsRealClusterFinder.h:69
CbmStsRealClusterFinder::FindClusters
Int_t FindClusters(Int_t stationNr, Int_t sectorNr, Int_t iSide, set< Int_t > &digiSet)
Find hits in one sector.
Definition CbmStsRealClusterFinder.cxx:359
CbmStsRealClusterFinder::SortDigis
void SortDigis()
Sort digis sectorwise.
Definition CbmStsRealClusterFinder.cxx:306
CbmStsRealClusterFinder::fClusters
TClonesArray * fClusters
Input array of CbmStsDigi.
Definition CbmStsRealClusterFinder.h:65
CbmStsRealClusterFinder::fDigiPar
CbmStsDigiPar * fDigiPar
Geometry parameters.
Definition CbmStsRealClusterFinder.h:62
CbmStsRealClusterFinder::fDigiScheme
CbmStsDigiScheme * fDigiScheme
Digitisation parameters.
Definition CbmStsRealClusterFinder.h:63
CbmStsRealClusterFinder::Exec
virtual void Exec(Option_t *opt)
Execution.
Definition CbmStsRealClusterFinder.cxx:86
CbmStsRealClusterFinder::ReInit
virtual InitStatus ReInit()
Reinitialisation.
Definition CbmStsRealClusterFinder.cxx:246
CbmStsRealClusterFinder::~CbmStsRealClusterFinder
virtual ~CbmStsRealClusterFinder()
Destructor.
Definition CbmStsRealClusterFinder.cxx:76
CbmStsRealClusterFinder::fDigis
TClonesArray * fDigis
Digitisation scheme.
Definition CbmStsRealClusterFinder.h:64
CbmStsRealClusterFinder::CbmStsRealClusterFinder
CbmStsRealClusterFinder()
Default constructor.
Definition CbmStsRealClusterFinder.cxx:40
CbmStsRealClusterFinder::fDigiMapF
map< CbmStsSector *, set< Int_t > > fDigiMapF
Definition CbmStsRealClusterFinder.h:67
CbmStsRealClusterFinder::Init
virtual InitStatus Init()
Intialisation.
Definition CbmStsRealClusterFinder.cxx:203
CbmStsRealClusterFinder::Finish
virtual void Finish()
Virtual method Finish.
Definition CbmStsRealClusterFinder.cxx:613
CbmStsSector::GetType
Int_t GetType() const
Definition CbmStsSector.h:81
CbmStsSector::GetSectorNr
Int_t GetSectorNr() const
Definition CbmStsSector.h:63
CbmStsStation::GetNSectors
Int_t GetNSectors() const
Definition CbmStsStation.h:62
CbmStsStation::GetStationNr
Int_t GetStationNr() const
Definition CbmStsStation.h:56
CbmStsStation::GetSector
CbmStsSector * GetSector(Int_t iSector)
Definition CbmStsStation.h:65
TMath::Abs
Double_t Abs(Double_t d)