BmnRoot
Loading...
Searching...
No Matches
BmnHistSiBT.cxx
Go to the documentation of this file.
1#include "BmnHistSiBT.h"
2
3#include "BmnRawDataDecoder.h"
4#include "BmnSiBTDigit.h"
5#include "BmnStripData.h"
6
7BmnHistSiBT::BmnHistSiBT(TString title, TString path, Int_t periodID)
8 : BmnHist(periodID)
9 , sibtStationSet(BmnSiBTStationSet::Create(periodID, fSetup))
10 , sumMods(0)
11 , maxLayers(0)
12 , maxMods(0)
13{
14 LOG(debug) << "INIT OF SiBTHist";
15 fTitle = title;
16 fName = title + "_cl";
17 refPath = path;
18 TString name;
19 numberOfChips = 2; // number of chips on each layer for run 8
20 const vector<Color_t> ChipColors{kRed + 2, kCyan + 2};
21 numberOfStations = sibtStationSet->GetNStations();
22 numberOfStrips = sibtStationSet->GetStation(0)->GetModule(0)->GetStripLayer(0).GetNStrips();
23 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
24 vector<vector<Double_t>> signalsInModule; // for correlation between 2 layers
25 vector<vector<TH1F*>> rowSiBT; // for stripNumber
26 vector<vector<vector<TH1F*>>> rowChipSignal; // for chip Signal
27 vector<TH2F*> rowSiBT2D; // for correlation between 2 layers
28 vector<vector<TH2F*>> firstStrip_Signal; // for strip_Signal data
29 vector<vector<TH1F*>> firstStrip_Noise; // for strip_noise data
30 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
31
32 sumMods += st->GetNModules();
33 if (maxMods < st->GetNModules())
34 maxMods = st->GetNModules();
35
36 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
37 vector<TH1F*> colSiBT; // for stripNumber
38 vector<vector<TH1F*>> colChipSignal; // for chip signal
39 vector<Double_t> signalsInLayers; // for correlation between 2 layers
40 vector<TH2F*> secondStripSignal; // for strip_Signal data
41 vector<TH1F*> secondStripNoise; // for strip_noise data
42
43 BmnSiBTModule* mod = st->GetModule(iModule);
44 if ((Int_t)maxLayers < mod->GetNStripLayers())
45 maxLayers = mod->GetNStripLayers();
46
47 for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
48 vector<TH1F*> layerChipSignal; // for chip signal
49 BmnSiBTLayer lay = mod->GetStripLayer(iLayer);
50 signalsInLayers.push_back(0);
51 name = Form(fTitle + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
52 TH1F* h = new TH1F(name, name, lay.GetNStrips(), 0, lay.GetNStrips());
53 h->GetXaxis()->SetTitle("Strip Number");
54 h->GetYaxis()->SetTitle("Activation Count");
55 h->SetLineWidth(2);
56 StripLayerType layer_type = lay.GetType();
57 if (layer_type == LowerStripLayer) {
58 h->SetLineColor(1); // black
59 } else {
60 h->SetLineColor(2);
61 } // red
62 BmnHist::SetHistStyleTH1(h);
63 colSiBT.push_back(h);
64
65 name = Form(fTitle + "StripVsSignal" + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
66 TH2F* hist = new TH2F(name, name, lay.GetNStrips(), 0, lay.GetNStrips(), 250, 0, 2500);
67 hist->GetXaxis()->SetTitle("Strip Number");
68 hist->GetYaxis()->SetTitle("Signal");
69 secondStripSignal.push_back(hist);
70
71 name = Form(fTitle + "StripVsNoise" + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
72 TH1F* stripNoise = new TH1F(name, name, lay.GetNStrips(), 0, lay.GetNStrips());
73 stripNoise->SetTitle(name);
74 stripNoise->GetXaxis()->SetTitle("Strip Number");
75 stripNoise->GetYaxis()->SetTitle("Noise");
76 stripNoise->SetLineWidth(2);
77 if (layer_type == LowerStripLayer) {
78 stripNoise->SetLineColor(1); // black
79 } else {
80 stripNoise->SetLineColor(2);
81 } // red
82 secondStripNoise.push_back(stripNoise);
83 for (Int_t iChip = 0; iChip < numberOfChips; ++iChip) {
84 name = Form(fTitle + "ChipSignal" + "_Station_%d_module_%d_layer_%d_chip_%d", iStation, iModule,
85 iLayer, iChip);
86 TH1F* chipSignal = new TH1F(name, name, 500, 0, 2500);
87 chipSignal->GetXaxis()->SetTitle("Signal");
88 chipSignal->GetYaxis()->SetTitle("Count");
89 chipSignal->SetLineColor(ChipColors[iChip]);
90 chipSignal->SetLineWidth(2);
91 layerChipSignal.push_back(chipSignal);
92 }
93 colChipSignal.push_back(layerChipSignal);
94 }
95 name = Form("Signal_Layer0_Layer1_st%d_mod%d", iStation, iModule);
96 TH2F* h = new TH2F(name, name, 250, 0, 2500, 250, 0, 2500);
97 h->GetXaxis()->SetTitle("Signal in layer 0");
98 h->GetYaxis()->SetTitle("Signal in layer 1");
99 rowSiBT2D.push_back(h);
100 signalsInModule.push_back(signalsInLayers);
101 rowSiBT.push_back(colSiBT);
102 rowChipSignal.push_back(colChipSignal);
103 firstStrip_Signal.push_back(secondStripSignal);
104 firstStrip_Noise.push_back(secondStripNoise);
105 }
106 signalSiBT.push_back(signalsInModule);
107 histSiBTStrip.push_back(rowSiBT);
108 histSiBTChipSignal.push_back(rowChipSignal);
109 histSiBTSignal2D.push_back(rowSiBT2D);
110 histSiBTStripSignal.push_back(firstStrip_Signal);
111 histSiBTStripNoise.push_back(firstStrip_Noise);
112 }
113
114 // Create canvas
115 name = fTitle + "Canvas";
116 canSiBTStrip = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
117 name = fTitle + "SignalCanvas";
118 canSiBTSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * maxMods);
119 name = fTitle + "StripSignalCanvas";
120 canSiBTStripSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
121 name = fTitle + "StripNoiseCanvas";
122 canSiBTStripNoise = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
123 name = fTitle + "ChipSignalCanvas";
124 canSiBTChipSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
125
126 const vector<TString> LayerNames{"p+", "n+"};
127
128 canSiBTStrip->Divide(maxMods, numberOfStations);
129 canSiBTSignal->Divide(numberOfStations, maxMods);
130 canSiBTStripSignal->Divide(maxLayers, sumMods);
131 canSiBTStripNoise->Divide(maxMods, numberOfStations);
132 canSiBTChipSignal->Divide(maxLayers, sumMods);
133
134 Int_t modCtr = 0; // filling SiBT Canvas' pads
135 canStripPads.resize(maxMods * numberOfStations);
136 canSignalPads.resize(maxMods * numberOfStations);
137 canStripSignalPads.resize(sumMods * maxLayers);
138 canStripNoisePads.resize(maxMods * numberOfStations);
139 canChipSignalPads.resize(sumMods * maxLayers);
140 NamesStrip.resize(maxMods * numberOfStations);
141 NamesSignal.resize(maxMods * numberOfStations);
142 NamesStripSignal.resize(sumMods * maxLayers);
143 NamesStripNoise.resize(maxMods * numberOfStations);
144 NamesChipSignal.resize(sumMods * maxLayers);
145
146 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
147 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
148 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
149 BmnSiBTModule* mod = st->GetModule(iModule);
150 PadInfo* p = new PadInfo();
151 p->opt = "";
152 Double_t l_x0 = 0.15;
153 Double_t l_y0 = 0.75;
154 Double_t l_w = 0.10;
155 Double_t l_h = 0.15;
156 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
157 legend->SetTextSize(0.03);
158 for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
159 legend->AddEntry(histSiBTStrip[iStation][iModule][iLayer], LayerNames[iLayer]);
160 p->aux.push_back(histSiBTStrip[iStation][iModule][iLayer]);
161 }
162 p->legend = legend;
163 Int_t iPad = modCtr * maxMods + iModule;
164 p->name = Form(fTitle + "Occupancy" + "_Station_%d_module_%d", iStation, iModule);
165 canStripPads[iPad] = p;
166 canSiBTStrip->GetPad(iPad + 1)->SetGrid();
167 NamesStrip[iPad] = canStripPads[iPad]->name;
168 canSiBTStrip->GetPad(iPad + 1)->SetTitle(NamesStripNoise[iPad]);
169 }
170 modCtr++;
171 }
172
173 modCtr = 0;
174
175 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
176 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
177 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
178 // BmnSiBTModule *mod = st->GetModule(iModule);
179 PadInfo* p = new PadInfo();
180 p->opt = "colz";
181 p->current = histSiBTSignal2D[iStation][iModule];
182 Int_t iPad = modCtr * maxMods + iModule;
183 canSignalPads[iPad] = p;
184 canSiBTSignal->GetPad(iPad + 1)->SetGrid();
185 NamesSignal[iPad] = canSignalPads[iPad]->current->GetName();
186 }
187 modCtr++;
188 }
189
190 modCtr = 0;
191
192 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
193 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
194 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
195 BmnSiBTModule* mod = st->GetModule(iModule);
196 for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
197 PadInfo* p = new PadInfo();
198 p->opt = "colz";
199 p->current = histSiBTStripSignal[iStation][iModule][iLayer];
200 Int_t iPad = modCtr * maxLayers + iLayer;
201 canStripSignalPads[iPad] = p;
202 canSiBTStripSignal->GetPad(iPad + 1)->SetGrid();
203 NamesStripSignal[iPad] = canStripSignalPads[iPad]->current->GetName();
204 }
205 modCtr++;
206 }
207 }
208 modCtr = 0;
209
210 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
211 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
212 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
213 BmnSiBTModule* mod = st->GetModule(iModule);
214 // for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
215 PadInfo* p = new PadInfo();
216 p->opt = "";
217 Double_t l_x0 = 0.15;
218 Double_t l_y0 = 0.75;
219 Double_t l_w = 0.10;
220 Double_t l_h = 0.15;
221 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
222 legend->SetTextSize(0.03);
223 for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
224 legend->AddEntry(histSiBTStripNoise[iStation][iModule][iLayer], LayerNames[iLayer]);
225 p->aux.push_back(histSiBTStripNoise[iStation][iModule][iLayer]);
226 }
227 p->legend = legend;
228 Int_t iPad = modCtr * maxMods + iModule;
229 p->name = Form(fTitle + "StripVsNoise" + "_Station_%d_module_%d", iStation, iModule);
230 canStripNoisePads[iPad] = p;
231 canSiBTStripNoise->GetPad(iPad + 1)->SetGrid();
232 NamesStripNoise[iPad] = canStripNoisePads[iPad]->name;
233 canSiBTStripNoise->GetPad(iPad + 1)->SetTitle(NamesStripNoise[iPad]);
234 // }
235 }
236 modCtr++;
237 }
238 modCtr = 0;
239
240 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
241 BmnSiBTStation* st = sibtStationSet->GetStation(iStation);
242 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
243 BmnSiBTModule* mod = st->GetModule(iModule);
244 for (Int_t iLayer = 0; iLayer < mod->GetNStripLayers(); iLayer++) {
245 PadInfo* p = new PadInfo();
246 p->opt = "";
247 Double_t l_x0 = 0.15;
248 Double_t l_y0 = 0.5;
249 Double_t l_w = 0.15;
250 Double_t l_h = 0.25;
251 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
252 legend->SetTextSize(0.04);
253 for (Int_t iChip = 0; iChip < numberOfChips; iChip++) {
254 legend->AddEntry(histSiBTChipSignal[iStation][iModule][iLayer][iChip], Form("ASIC# %d", iChip + 1));
255 p->aux.push_back(histSiBTChipSignal[iStation][iModule][iLayer][iChip]);
256 }
257 p->legend = legend;
258 Int_t iPad = modCtr * maxLayers + iLayer;
259 p->name = Form(fTitle + "ChipSignal" + "_Station_%d_module_%d", iStation, iModule);
260 canChipSignalPads[iPad] = p;
261 canSiBTChipSignal->GetPad(iPad + 1)->SetGrid();
262 NamesChipSignal[iPad] = canChipSignalPads[iPad]->name;
263 canSiBTChipSignal->GetPad(iPad + 1)->SetTitle(NamesChipSignal[iPad]);
264 }
265 modCtr++;
266 }
267 }
268 modCtr = 0;
269}
270
271BmnHistSiBT::~BmnHistSiBT()
272{
273 delete canSiBTStrip;
274 delete canSiBTSignal;
275 delete canSiBTStripSignal;
276 delete canSiBTStripNoise;
277 delete canSiBTChipSignal;
278
279 if (fDir)
280 return;
281 for (auto pad : canStripPads)
282 delete pad;
283
284 for (auto padSignal : canSignalPads)
285 delete padSignal;
286
287 for (auto padStripSignal : canStripSignalPads)
288 delete padStripSignal;
289
290 for (auto padStripNoise : canStripNoisePads)
291 delete padStripNoise;
292
293 for (auto padChipSignal : canChipSignalPads)
294 delete padChipSignal;
295
296 for (size_t iSt = 0; iSt < histSiBTStrip.size(); ++iSt) {
297 for (size_t iMod = 0; iMod < histSiBTStrip[iSt].size(); ++iMod) {
298 for (size_t iLayer = 0; iLayer < histSiBTStrip[iSt][iMod].size(); ++iLayer) {
299 delete histSiBTStrip[iSt][iMod][iLayer];
300 delete histSiBTStripSignal[iSt][iMod][iLayer];
301 delete histSiBTStripNoise[iSt][iMod][iLayer];
302 for (Int_t iChip = 0; iChip < numberOfChips; iChip++)
303 delete histSiBTChipSignal[iSt][iMod][iLayer][iChip];
304 }
305 delete histSiBTSignal2D[iSt][iMod];
306 }
307 }
308}
309
310void BmnHistSiBT::Register(THttpServer* serv)
311{
312 fServer = serv;
313 fServer->Register("/", this);
314 TString path = "/" + fTitle + "/";
315 fServer->Register(path, canSiBTStrip);
316 fServer->Register(path, canSiBTSignal);
317 fServer->Register(path, canSiBTStripSignal);
318 fServer->Register(path, canSiBTStripNoise);
319 fServer->Register(path, canSiBTChipSignal);
320 fServer->SetItemField(path, "_monitoring", "2000");
321 fServer->SetItemField(path, "_layout", "grid3x3");
322 TString cmd = "/" + fName + "/->Reset()";
323 TString cmdTitle = path + "Reset";
324 fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
325 fServer->Restrict(cmdTitle.Data(), "visible=shift");
326 fServer->Restrict(cmdTitle.Data(), "allow=shift");
327 fServer->Restrict(cmdTitle.Data(), "deny=guest");
328 cmd = "/" + fName + "/->SetRefRun(%arg1%)";
329 cmdTitle = path + "SetRefRun";
330 fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
331 // fServer->Restrict(cmdTitle.Data(), "deny=guest");
332}
333
334void BmnHistSiBT::SetDir(TFile* outFile, TTree* recoTree)
335{
336 frecoTree = recoTree;
337 fDir = NULL;
338 if (outFile != NULL)
339 fDir = outFile->mkdir(fTitle + "_hists");
340 for (auto row : histSiBTStrip)
341 for (auto col : row)
342 for (auto el : col)
343 el->SetDirectory(fDir);
344
345 for (auto rowSig : histSiBTSignal2D)
346 for (auto colSig : rowSig)
347 colSig->SetDirectory(fDir);
348
349 for (auto row : histSiBTStripSignal)
350 for (auto col : row)
351 for (auto el : col)
352 el->SetDirectory(fDir);
353
354 for (auto row : histSiBTStripNoise)
355 for (auto col : row)
356 for (auto el : col)
357 el->SetDirectory(fDir);
358
359 for (auto row : histSiBTChipSignal)
360 for (auto col : row)
361 for (auto array : col)
362 for (auto el : array)
363 el->SetDirectory(fDir);
364}
365
366void BmnHistSiBT::DrawBoth()
367{
368 BmnHist::DrawRef(canSiBTStrip, &canStripPads);
369 BmnHist::DrawRef(canSiBTSignal, &canSignalPads);
370 BmnHist::DrawRef(canSiBTStripSignal, &canStripSignalPads);
371 BmnHist::DrawRef(canSiBTStripNoise, &canStripNoisePads);
372 BmnHist::DrawRef(canSiBTChipSignal, &canChipSignalPads);
373 return;
374}
375
376void BmnHistSiBT::FillFromDigi(DigiArrays* fDigiArrays)
377{
378 TClonesArray* SiBTDigits = fDigiArrays->sibt;
379 if (!SiBTDigits)
380 return;
381 for (Int_t digIndex = 0; digIndex < SiBTDigits->GetEntriesFast(); digIndex++) {
382 BmnSiBTDigit* gs = static_cast<BmnSiBTDigit*>(SiBTDigits->At(digIndex));
383 Int_t module = gs->GetModule();
384 Int_t station = gs->GetStation();
385 Int_t layer = gs->GetStripLayer();
386 Int_t SiBTStrip = gs->GetStripNumber();
387 histSiBTStrip[station][module][layer]->Fill(SiBTStrip);
388 histSiBTStripSignal[station][module][layer]->Fill(SiBTStrip, gs->GetStripSignal());
389 histSiBTStripNoise[station][module][layer]->SetBinContent(SiBTStrip, gs->GetStripNoise());
390 signalSiBT[station][module][layer] = gs->GetStripSignal();
391 histSiBTChipSignal[station][module][layer][Int_t(SiBTStrip / (numberOfStrips / numberOfChips))]->Fill(
392 gs->GetStripSignal());
393 }
394
395 for (size_t iStation = 0; iStation < signalSiBT.size(); ++iStation)
396 for (size_t iModule = 0; iModule < signalSiBT[iStation].size(); ++iModule)
397 if (signalSiBT[iStation][iModule][0] && signalSiBT[iStation][iModule][1]) {
398 histSiBTSignal2D[iStation][iModule]->Fill(signalSiBT[iStation][iModule][0],
399 signalSiBT[iStation][iModule][1]);
400 }
401}
402
403BmnStatus BmnHistSiBT::SetRefRun(Int_t id)
404{
405 if (refID != id) {
406 TString FileName = Form("bmn_run%04d_hist.root", id);
407 printf("SetRefRun: %s\n", FileName.Data());
408 refRunName = FileName;
409 refID = id;
410 BmnHist::LoadRefRun(refID, refPath + FileName, fTitle, canStripPads, NamesStrip);
411 // BmnHist::LoadRefRun(refID, refPath + FileName, fTitle, canSignalPads, NamesSignal);
412 // BmnHist::LoadRefRun(refID, refPath + FileName, fTitle, canStripSignalPads, NamesStripSignal);
413 DrawBoth();
414 }
415
416 return kBMNSUCCESS;
417}
418
419void BmnHistSiBT::ClearRefRun()
420{
421 printf("BmnHistSiBT : ClearRefRun\n");
422 for (auto pad : canStripPads) {
423 if (pad->ref)
424 delete pad->ref;
425 pad->ref = NULL;
426 }
427
428 for (auto padSignal : canSignalPads) {
429 if (padSignal->ref)
430 delete padSignal->ref;
431 padSignal->ref = NULL;
432 }
433
434 for (auto padStripSignal : canStripSignalPads) {
435 if (padStripSignal->ref)
436 delete padStripSignal->ref;
437 padStripSignal->ref = NULL;
438 }
439
440 for (auto padStripNoise : canStripNoisePads) {
441 if (padStripNoise->ref)
442 delete padStripNoise->ref;
443 padStripNoise->ref = NULL;
444 }
445
446 for (auto padChipSignal : canChipSignalPads) {
447 if (padChipSignal->ref)
448 delete padChipSignal->ref;
449 padChipSignal->ref = NULL;
450 }
451
452 refID = 0;
453}
454
455void BmnHistSiBT::Reset()
456{
457 printf("BmnHistSiBT : Reset histos\n");
458
459 for (auto rowStripSignal : histSiBTStrip)
460 for (auto colStripSignal : rowStripSignal)
461 for (auto elStripSignal : colStripSignal)
462 elStripSignal->Reset();
463
464 for (auto row : histSiBTSignal2D)
465 for (auto col : row)
466 col->Reset();
467
468 for (auto rowStripSignal : histSiBTStripSignal)
469 for (auto colStripSignal : rowStripSignal)
470 for (auto elStripSignal : colStripSignal)
471 elStripSignal->Reset();
472
473 for (auto rowStripNoise : histSiBTStripNoise)
474 for (auto colStripNoise : rowStripNoise)
475 for (auto elStripNoise : colStripNoise)
476 elStripNoise->Reset();
477
478 for (auto rowChipSignal : histSiBTChipSignal)
479 for (auto colChipSignal : rowChipSignal)
480 for (auto arrayChipSignal : colChipSignal)
481 for (auto elChipSignal : arrayChipSignal)
482 elChipSignal->Reset();
483}
PAD_WIDTH
#define PAD_WIDTH
Definition BmnAdcQA.cxx:3
PAD_HEIGHT
#define PAD_HEIGHT
Definition BmnAdcQA.cxx:4
BmnStatus
BmnStatus
Definition BmnEnums.h:24
kBMNSUCCESS
@ kBMNSUCCESS
Definition BmnEnums.h:25
StripLayerType
StripLayerType
Definition BmnStripData.h:11
LowerStripLayer
@ LowerStripLayer
Definition BmnStripData.h:12
BmnHistSiBT::SetDir
void SetDir(TFile *outFile=NULL, TTree *recoTree=NULL)
Definition BmnHistSiBT.cxx:334
BmnHistSiBT::ClearRefRun
void ClearRefRun()
Definition BmnHistSiBT.cxx:419
BmnHistSiBT::Register
void Register(THttpServer *serv)
Definition BmnHistSiBT.cxx:310
BmnHistSiBT::BmnHistSiBT
BmnHistSiBT(TString title, TString path="", Int_t periodID=8)
Definition BmnHistSiBT.cxx:7
BmnHistSiBT::FillFromDigi
void FillFromDigi(DigiArrays *fDigiArrays)
Definition BmnHistSiBT.cxx:376
BmnHistSiBT::SetRefRun
BmnStatus SetRefRun(Int_t id)
Definition BmnHistSiBT.cxx:403
BmnHistSiBT::~BmnHistSiBT
virtual ~BmnHistSiBT()
Definition BmnHistSiBT.cxx:271
BmnHist::frecoTree
TTree * frecoTree
Definition BmnHist.h:88
BmnHist::refID
Int_t refID
Definition BmnHist.h:92
BmnHist::refPath
TString refPath
Definition BmnHist.h:90
BmnHist::fDir
TDirectory * fDir
Definition BmnHist.h:89
BmnHist::DrawRef
static void DrawRef(unique_ptr< TCanvas > &canGemStrip, vector< PadInfo * > *canGemStripPads)
Definition BmnHist.cxx:15
BmnHist::SetHistStyleTH1
static void SetHistStyleTH1(TH1 *h)
Definition BmnHist.cxx:195
BmnHist::refRunName
TString refRunName
Definition BmnHist.h:91
BmnHist::LoadRefRun
static BmnStatus LoadRefRun(Int_t refID, TString FullName, TString fTitle, vector< PadInfo * > canPads, vector< TString > Names)
Definition BmnHist.cxx:100
BmnHist::fServer
THttpServer * fServer
Definition BmnHist.h:87
BmnSiBTLayer::GetNStrips
Int_t GetNStrips()
Definition BmnSiBTLayer.cxx:88
BmnSiBTLayer::GetType
StripLayerType GetType()
Definition BmnSiBTLayer.h:46
BmnSiBTModule::GetNStripLayers
Int_t GetNStripLayers()
Definition BmnSiBTModule.h:55
BmnSiBTModule::GetStripLayer
BmnSiBTLayer & GetStripLayer(Int_t num)
Definition BmnSiBTModule.h:56
BmnSiBTStation::GetModule
BmnSiBTModule * GetModule(Int_t module_num)
Definition BmnSiBTStation.cxx:132
BmnStripDigit::GetStripNoise
Double_t GetStripNoise()
Definition BmnStripDigit.h:31
BmnStripDigit::GetStripNumber
Int_t GetStripNumber()
Definition BmnStripDigit.h:29
BmnStripDigit::GetStripLayer
Int_t GetStripLayer()
Definition BmnStripDigit.h:28
BmnStripDigit::GetStation
Int_t GetStation()
Definition BmnStripDigit.h:26
BmnStripDigit::GetStripSignal
Double_t GetStripSignal()
Definition BmnStripDigit.h:30
DigiArrays::sibt
TClonesArray * sibt
Definition DigiArrays.h:141
PadInfo
Storage for pad content and it's options.
Definition PadInfo.h:20
PadInfo::name
string name
Definition PadInfo.h:89
PadInfo::opt
string opt
Definition PadInfo.h:88
PadInfo::aux
vector< TH1 * > aux
Definition PadInfo.h:80
PadInfo::legend
TLegend * legend
Definition PadInfo.h:82
PadInfo::current
TH1 * current
Definition PadInfo.h:78