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