BmnRoot
Loading...
Searching...
No Matches
BmnHistSilicon.cxx
Go to the documentation of this file.
1#include "BmnHistSilicon.h"
2
3#include "BmnStripData.h"
4
5BmnHistSilicon::BmnHistSilicon(TString title, TString path, Int_t PeriodID, BmnSetup setup)
6 : BmnHist(PeriodID, setup)
7 , stationSet(BmnSiliconStationSet::Create(fPeriodID, fSetup))
8 , sumMods(0)
9 , maxLayers(0)
10 , maxMods(0)
11 , fStation(-1)
12{
13 fTitle = title;
14 fName = title + "_cl";
15 refPath = path;
16 TString name;
17 numberOfChips = 5; // number of chips on each layer for run 8
18
19 const vector<Color_t> ChipColors{kBlue, kYellow + 3, kGreen + 2, kRed, kMagenta - 1};
20
21 numberOfStrips = stationSet->GetSiliconStation(0)->GetModule(0)->GetStripLayer(0).GetNStrips();
22 Int_t numberOfStations = stationSet->GetNStations();
23 nStations = numberOfStations;
24 canStripPads.resize(nStations);
25 canSignalPads.resize(nStations);
26 canStripSignalPads.resize(nStations);
27 canStripNoisePads.resize(nStations);
28 canChipSignalPads.resize(nStations);
29
30 NamesStrip.resize(nStations);
31 NamesSignal.resize(nStations);
32 NamesStripSignal.resize(nStations);
33 NamesStripNoise.resize(nStations);
34 NamesChipSignal.resize(nStations);
35
36 for (Int_t iStation = 0; iStation < nStations; iStation++) {
37
38 vector<vector<TH1I*>> rowSilicon; // for stripNumber
39 vector<vector<Double_t>> signalsInModule; // for correlation between 2 layers
40 vector<TH2F*> rowSilicon2D; // for correlation between 2 layers
41 vector<vector<TH2F*>> firstStrip_Signal; // for strip_Signal data
42 vector<vector<TH1F*>> firstStrip_Noise; // for strip_noise data
43 vector<vector<vector<TH1F*>>> rowChipSignal; // for chip Signal
44 BmnSiliconStation* st = stationSet->GetSiliconStation(iStation);
45
46 sumMods += st->GetNModules();
47 if ((Int_t)maxMods < st->GetNModules())
48 maxMods = st->GetNModules();
49
50 for (Int_t iModule = 0; iModule < st->GetNModules(); iModule++) {
51 vector<TH1I*> colSilicon; // for stripNumber
52 vector<Double_t> signalsInLayers; // for correlation between 2 layers
53 vector<TH2F*> secondStripSignal; // for strip_Signal data
54 vector<TH1F*> secondStripNoise; // for strip_noise data
55 vector<vector<TH1F*>> colChipSignal; // for chip signal
56
57 BmnSiliconModule* mod = st->GetModule(iModule);
58 if ((Int_t)maxLayers < mod->GetNStripLayers())
59 maxLayers = mod->GetNStripLayers();
60 for (Int_t iLayer = 0; iLayer < 2 /*mod->GetNStripLayers()*/; iLayer++) {
61 vector<TH1F*> layerChipSignal; // for chip signal
62 BmnSiliconLayer lay = mod->GetStripLayer(iLayer);
63 signalsInLayers.push_back(0);
64 name = Form(fTitle + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
65 TH1I* h = new TH1I(name, name, lay.GetNStrips(), 0, lay.GetNStrips());
66 h->GetXaxis()->SetTitle("Strip Number");
67 h->GetYaxis()->SetTitle("Activation Count");
68 if (iLayer == 0) {
69 h->SetLineColor(1); // black
70 } else {
71 h->SetLineColor(2);
72 } // red
73 BmnHist::SetHistStyleTH1(h);
74 colSilicon.push_back(h);
75
76 name = Form(fTitle + "StripVsSignal" + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
77 TH2F* hist = new TH2F(name, name, lay.GetNStrips(), 0, lay.GetNStrips(), 250, 0, 2500);
78 hist->GetXaxis()->SetTitle("Strip Number");
79 hist->GetYaxis()->SetTitle("Signal");
80 BmnHist::SetHistStyleTH1(hist);
81 secondStripSignal.push_back(hist);
82
83 name = Form(fTitle + "StripVsNoise" + "_Station_%d_module_%d_layer_%d", iStation, iModule, iLayer);
84 TH1F* stripNoise = new TH1F(name, name, lay.GetNStrips(), 0, lay.GetNStrips());
85 stripNoise->SetTitle(name);
86 stripNoise->GetXaxis()->SetTitle("Strip Number");
87 stripNoise->GetYaxis()->SetTitle("Noise");
88 stripNoise->SetLineWidth(2);
89 if (iLayer == 0) {
90 stripNoise->SetLineColor(1); // black
91 } else {
92 stripNoise->SetLineColor(2);
93 } // red
94 BmnHist::SetHistStyleTH1(stripNoise);
95 secondStripNoise.push_back(stripNoise);
96
97 for (UInt_t iChip = 0; iChip < numberOfChips; ++iChip) {
98 name = Form(fTitle + "ChipSignal" + "_Station_%d_module_%d_layer_%d_chip_%d", iStation, iModule,
99 iLayer, iChip);
100 TH1F* chipSignal = new TH1F(name, name, 500, 0, 2500);
101 chipSignal->GetXaxis()->SetTitle("Signal");
102 chipSignal->GetYaxis()->SetTitle("Count");
103 chipSignal->SetLineColor(ChipColors[iChip]);
104 chipSignal->SetLineWidth(2);
105 BmnHist::SetHistStyleTH1(chipSignal);
106 layerChipSignal.push_back(chipSignal);
107 }
108 colChipSignal.push_back(layerChipSignal);
109 }
110 name = Form("Signal_Layer0_Layer1_st%d_mod%d", iStation, iModule);
111 TH2F* h = new TH2F(name, name, 250, 0, 2500, 250, 0, 2500);
112 h->GetXaxis()->SetTitle("Signal in layer 0");
113 h->GetYaxis()->SetTitle("Signal in layer 1");
114 BmnHist::SetHistStyleTH1(h);
115 rowSilicon2D.push_back(h);
116 signalsInModule.push_back(signalsInLayers);
117 firstStrip_Signal.push_back(secondStripSignal);
118 firstStrip_Noise.push_back(secondStripNoise);
119 rowSilicon.push_back(colSilicon);
120 rowChipSignal.push_back(colChipSignal);
121 }
122 histSiliconStrip.push_back(rowSilicon);
123 signalSilicon.push_back(signalsInModule);
124 histSiliconSignal2D.push_back(rowSilicon2D);
125 histSiliconStripSignal.push_back(firstStrip_Signal);
126 histSiliconStripNoise.push_back(firstStrip_Noise);
127 histSiliconChipSignal.push_back(rowChipSignal);
128 }
129 maxLayers = 2;
130 // Create canvas
131 name = fTitle + "Canvas";
132 canSiliconStrip = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
133 name = fTitle + "SignalCanvas";
134 canSiliconSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
135 name = fTitle + "StripSignalCanvas";
136 canSiliconStripSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
137 name = fTitle + "StripNoiseCanvas";
138 canSiliconStripNoise = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
139 name = fTitle + "ChipSignalCanvas";
140 canSiliconChipSignal = new TCanvas(name, name, PAD_WIDTH * maxLayers, PAD_HEIGHT * sumMods);
141
142 for (Int_t iStation = 0; iStation < numberOfStations; iStation++) {
143 BmnSiliconStation* st = stationSet->GetSiliconStation(iStation);
144 Int_t numberOfModules = st->GetNModules();
145 canStripPads[iStation].resize(numberOfModules * 1);
146 canSignalPads[iStation].resize(numberOfModules * 1);
147 canStripSignalPads[iStation].resize(numberOfModules * maxLayers);
148 canStripNoisePads[iStation].resize(numberOfModules * 1);
149 canChipSignalPads[iStation].resize(numberOfModules * maxLayers);
150 NamesStrip[iStation].resize(numberOfModules * 1);
151 NamesSignal[iStation].resize(numberOfModules * 1);
152 NamesStripSignal[iStation].resize(numberOfModules * maxLayers);
153 NamesStripNoise[iStation].resize(numberOfModules * 1);
154 NamesChipSignal[iStation].resize(numberOfModules * maxLayers);
155 }
156
157 // CREATE DEFAULT CANVASES FOR SILICON PLANE 0
158 ChangeStation(0);
159}
160
161void BmnHistSilicon::ChangeStation(Int_t stationNumber)
162{
163 if (fStation == stationNumber)
164 return;
165 ;
166 BmnSiliconStation* st = stationSet->GetSiliconStation(stationNumber);
167 Int_t numberOfModules = st->GetNModules();
168
169 ResetCanvases(numberOfModules);
170 fStation = stationNumber;
171 // canStrip->Divide(maxLayers, sumMods, 0.0, 0.0);
172 Int_t modCtr = 0; // filling GEM Canvas' pads
173
174 for (auto& pad : canStripPads[fStation])
175 if (pad)
176 pad = nullptr;
177
178 for (auto& pad : canSignalPads[fStation])
179 if (pad)
180 pad = nullptr;
181
182 for (auto& pad : canStripSignalPads[fStation])
183 if (pad)
184 pad = nullptr;
185
186 for (auto& pad : canSignalPads[fStation])
187 if (pad)
188 pad = nullptr;
189
190 for (auto& pad : canChipSignalPads[fStation])
191 if (pad)
192 pad = nullptr;
193
194 const vector<TString> LayerNames{"p+", "n+"};
195 for (Int_t iModule = 0; iModule < numberOfModules; iModule++) {
196 // BmnSiliconModule *mod = st->GetModule(iModule);
197 Int_t iPad = iModule;
198 PadInfo* p = new PadInfo();
199 Double_t l_x0 = 0.15;
200 Double_t l_y0 = 0.75;
201 Double_t l_w = 0.10;
202 Double_t l_h = 0.15;
203 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
204 legend->SetTextSize(0.03);
205 for (Int_t iLayer = 0; iLayer < 2 /*mod->GetNStripLayers()*/; iLayer++) {
206 legend->AddEntry(histSiliconStrip[fStation][iModule][iLayer], LayerNames[iLayer]);
207 p->aux.push_back(histSiliconStrip[fStation][iModule][iLayer]);
208 }
209 p->legend = legend;
210 canStripPads[fStation][iPad] = p;
211 canSiliconStrip->GetPad(iPad + 1)->SetGrid();
212 NamesStrip[fStation][iPad] = canStripPads[fStation][iPad]->name;
213 modCtr++;
214 }
215 modCtr = 0;
216 for (Int_t iModule = 0; iModule < numberOfModules; iModule++) {
217 PadInfo* p = new PadInfo();
218 p->opt = "colz";
219 p->current = histSiliconSignal2D[fStation][iModule];
220 Int_t iPad = iModule;
221 canSignalPads[fStation][iPad] = p;
222 canSiliconSignal->GetPad(iPad + 1)->SetGrid();
223 NamesSignal[fStation][iPad] = canSignalPads[fStation][iPad]->current->GetName();
224 }
225
226 modCtr = 0;
227
228 for (Int_t iModule = 0; iModule < numberOfModules; iModule++) {
229 for (Int_t iLayer = 0; iLayer < 2 /*mod->GetNStripLayers()*/; iLayer++) {
230 PadInfo* p = new PadInfo();
231 p->opt = "colz";
232 p->current = histSiliconStripSignal[fStation][iModule][iLayer];
233 Int_t iPad = modCtr * maxLayers + iLayer;
234 canStripSignalPads[fStation][iPad] = p;
235 canSiliconStripSignal->GetPad(iPad + 1)->SetGrid();
236 NamesStripSignal[fStation][iPad] = canStripSignalPads[fStation][iPad]->current->GetName();
237 }
238 modCtr++;
239 }
240 modCtr = 0;
241
242 for (Int_t iModule = 0; iModule < numberOfModules; iModule++) {
243 PadInfo* p = new PadInfo();
244 p->opt = "";
245 Double_t l_x0 = 0.15;
246 Double_t l_y0 = 0.75;
247 Double_t l_w = 0.10;
248 Double_t l_h = 0.15;
249 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
250 legend->SetTextSize(0.03);
251 for (Int_t iLayer = 0; iLayer < 2 /*mod->GetNStripLayers()*/; iLayer++) {
252 legend->AddEntry(histSiliconStripNoise[fStation][iModule][iLayer], LayerNames[iLayer]);
253 p->aux.push_back(histSiliconStripNoise[fStation][iModule][iLayer]);
254 }
255 p->legend = legend;
256 Int_t iPad = iModule;
257 p->name = Form(fTitle + "StripVsNoise" + "_Station_%d_module_%d", fStation, iModule);
258 canStripNoisePads[fStation][iPad] = p;
259 canSiliconStripNoise->GetPad(iPad + 1)->SetGrid();
260 NamesStripNoise[stationNumber][iPad] = canStripNoisePads[stationNumber][iPad]->name;
261 }
262 modCtr = 0;
263
264 for (Int_t iModule = 0; iModule < numberOfModules; iModule++) {
265 for (Int_t iLayer = 0; iLayer < 2; iLayer++) {
266 PadInfo* p = new PadInfo();
267 p->opt = "";
268 Double_t l_x0 = 0.75;
269 Double_t l_y0 = 0.5;
270 Double_t l_w = 0.10;
271 Double_t l_h = 0.20;
272 TLegend* legend = new TLegend(l_x0, l_y0, l_x0 + l_w, l_y0 + l_h);
273 legend->SetTextSize(0.04);
274 for (UInt_t iChip = 0; iChip < numberOfChips; iChip++) {
275 legend->AddEntry(histSiliconChipSignal[fStation][iModule][iLayer][iChip], Form("ASIC# %d", iChip + 1));
276 p->aux.push_back(histSiliconChipSignal[fStation][iModule][iLayer][iChip]);
277 }
278 p->legend = legend;
279 Int_t iPad = modCtr * maxLayers + iLayer;
280 p->name = Form(fTitle + "ChipSignal" + "_Station_%d_module_%d", fStation, iModule);
281 canChipSignalPads[fStation][iPad] = p;
282 canSiliconChipSignal->GetPad(iPad + 1)->SetGrid();
283 NamesChipSignal[fStation][iPad] = canChipSignalPads[fStation][iPad]->name;
284 canSiliconChipSignal->GetPad(iPad + 1)->SetTitle(NamesChipSignal[fStation][iPad]);
285 }
286 modCtr++;
287 }
288 modCtr = 0;
289
290 canSiliconStrip->UpdateAsync();
291 canSiliconSignal->UpdateAsync();
292 canSiliconStripSignal->UpdateAsync();
293 canSiliconStripNoise->UpdateAsync();
294 canSiliconChipSignal->UpdateAsync();
295
296 canSiliconStrip->Modified();
297 canSiliconSignal->Modified();
298 canSiliconStripSignal->Modified();
299 canSiliconStripNoise->Modified();
300 canSiliconChipSignal->Modified();
301
302 DrawBoth();
303}
304
305void BmnHistSilicon::ResetCanvases(Int_t numberOfModules)
306{
307 // for (auto& pad : canStripPads[fStation])
308 // if (pad)
309 // pad = nullptr;
310
311 // for (auto& pad : canSignalPads[fStation])
312 // if (pad)
313 // pad = nullptr;
314
315 // for (auto& pad : canStripSignalPads[fStation])
316 // if (pad)
317 // pad = nullptr;
318
319 // for (auto& pad : canSignalPads[fStation])
320 // if (pad)
321 // pad = nullptr;
322
323 // for (auto& pad : canChipSignalPads[fStation])
324 // if (pad)
325 // pad = nullptr;
326
327 canSiliconChipSignal->Clear();
328 canSiliconStrip->Clear();
329 canSiliconSignal->Clear();
330 canSiliconStripSignal->Clear();
331 canSiliconStripNoise->Clear();
332
333 canSiliconStrip->SetWindowSize(PAD_WIDTH * maxLayers, 400 * numberOfModules);
334 canSiliconSignal->SetWindowSize(PAD_WIDTH * maxLayers, 400 * numberOfModules);
335 canSiliconStripSignal->SetWindowSize(PAD_WIDTH * maxLayers, 400 * numberOfModules);
336 canSiliconStripNoise->SetWindowSize(PAD_WIDTH * maxLayers, 400 * numberOfModules);
337 canSiliconChipSignal->SetWindowSize(PAD_WIDTH * maxLayers, 400 * numberOfModules);
338
339 canSiliconStrip->Divide(1, numberOfModules, 0.01, 0.01 / numberOfModules);
340 canSiliconSignal->Divide(1, numberOfModules, 0.01, 0.01 / numberOfModules);
341 canSiliconStripSignal->Divide(maxLayers, numberOfModules, 0.01 / maxLayers, 0.01 / numberOfModules);
342 canSiliconStripNoise->Divide(1, numberOfModules, 0.01, 0.01 / numberOfModules);
343 canSiliconChipSignal->Divide(maxLayers, numberOfModules, 0.01 / maxLayers, 0.01 / numberOfModules);
344}
345
346BmnHistSilicon::~BmnHistSilicon()
347{
348 // delete gemStationSet;
349 delete canSiliconStrip;
350 delete canSiliconSignal;
351 delete canSiliconStripSignal;
352 delete canSiliconStripNoise;
353 if (fDir)
354 return;
355 for (Int_t iStation = 0; iStation < nStations; ++iStation) {
356 for (auto pad : canStripPads[iStation])
357 if (pad)
358 delete pad;
359
360 for (auto padSignal : canSignalPads[iStation])
361 if (padSignal)
362 delete padSignal;
363
364 for (auto padStripSignal : canStripSignalPads[iStation])
365 if (padStripSignal)
366 delete padStripSignal;
367
368 for (auto padStripNoise : canStripNoisePads[iStation])
369 if (padStripNoise)
370 delete padStripNoise;
371
372 for (auto padChipSignal : canChipSignalPads[iStation])
373 if (padChipSignal)
374 delete padChipSignal;
375 }
376 for (size_t iSt = 0; iSt < histSiliconStrip.size(); ++iSt) {
377 for (size_t iMod = 0; iMod < histSiliconStrip[iSt].size(); ++iMod) {
378 for (size_t iLayer = 0; iLayer < histSiliconStrip[iSt][iMod].size(); ++iLayer) {
379 delete histSiliconStrip[iSt][iMod][iLayer];
380 delete histSiliconStripSignal[iSt][iMod][iLayer];
381 delete histSiliconStripNoise[iSt][iMod][iLayer];
382 for (UInt_t iChip = 0; iChip < numberOfChips; iChip++)
383 delete histSiliconChipSignal[iSt][iMod][iLayer][iChip];
384 }
385 delete histSiliconSignal2D[iSt][iMod];
386 }
387 }
388}
389
390void BmnHistSilicon::Register(THttpServer* serv)
391{
392 fServer = serv;
393 fServer->Register("/", this);
394 TString path = "/" + fTitle + "/";
395 fServer->Register(path, canSiliconStrip);
396 fServer->Register(path, canSiliconSignal);
397 fServer->Register(path, canSiliconStripSignal);
398 fServer->Register(path, canSiliconStripNoise);
399 fServer->Register(path, canSiliconChipSignal);
400 fServer->SetItemField(path, "_monitoring", "2000");
401 fServer->SetItemField(path, "_layout", "grid3x3");
402 TString cmd = "/" + fName + "/->Reset()";
403 TString cmdTitle = path + "Reset";
404 // fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
405 fServer->Restrict(cmdTitle.Data(), "visible=shift");
406 fServer->Restrict(cmdTitle.Data(), "allow=shift");
407 fServer->Restrict(cmdTitle.Data(), "deny=guest");
408 cmd = "/" + fName + "/->SetRefRun(%arg1%)";
409 cmdTitle = path + "SetRefRun";
410 fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
411 cmd = "/" + fName + "/->ChangeStation(%arg1%)";
412 cmdTitle = path + "ChangeStation";
413 fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
414}
415
416void BmnHistSilicon::SetDir(TFile* outFile, TTree* recoTree)
417{
418 frecoTree = recoTree;
419 fDir = NULL;
420 if (outFile != NULL)
421 fDir = outFile->mkdir(fTitle + "_hists");
422 for (auto row : histSiliconStrip)
423 for (auto col : row)
424 for (auto el : col)
425 el->SetDirectory(fDir);
426
427 for (auto rowSig : histSiliconSignal2D)
428 for (auto colSig : rowSig)
429 colSig->SetDirectory(fDir);
430
431 for (auto row : histSiliconStripSignal)
432 for (auto col : row)
433 for (auto el : col)
434 el->SetDirectory(fDir);
435
436 for (auto row : histSiliconStripNoise)
437 for (auto col : row)
438 for (auto el : col)
439 el->SetDirectory(fDir);
440
441 for (auto row : histSiliconChipSignal)
442 for (auto col : row)
443 for (auto array : col)
444 for (auto el : array)
445 el->SetDirectory(fDir);
446}
447
448void BmnHistSilicon::DrawBoth()
449{
450 BmnHist::DrawRef(canSiliconStrip, &canStripPads[fStation]);
451 BmnHist::DrawRef(canSiliconSignal, &canSignalPads[fStation]);
452 BmnHist::DrawRef(canSiliconStripSignal, &canStripSignalPads[fStation]);
453 BmnHist::DrawRef(canSiliconStripNoise, &canStripNoisePads[fStation]);
454 BmnHist::DrawRef(canSiliconChipSignal, &canChipSignalPads[fStation]);
455 return;
456}
457
458void BmnHistSilicon::FillFromDigi(DigiArrays* fDigiArrays)
459{
460 TClonesArray* siliconDigits = fDigiArrays->silicon;
461 if (!siliconDigits)
462 return;
463 for (Int_t digIndex = 0; digIndex < siliconDigits->GetEntriesFast(); digIndex++) {
464 BmnSiliconDigit* gs = static_cast<BmnSiliconDigit*>(siliconDigits->At(digIndex));
465 Int_t module = gs->GetModule();
466 Int_t station = gs->GetStation();
467 Int_t layer = gs->GetStripLayer();
468 Int_t siliconStrip = gs->GetStripNumber();
469 histSiliconStrip[station][module][layer]->Fill(siliconStrip);
470 histSiliconStripSignal[station][module][layer]->Fill(siliconStrip, gs->GetStripSignal());
471 histSiliconStripNoise[station][module][layer]->SetBinContent(siliconStrip, gs->GetStripNoise());
472 signalSilicon[station][module][layer] = gs->GetStripSignal();
473 histSiliconChipSignal[station][module][layer][Int_t(siliconStrip / (numberOfStrips / numberOfChips))]->Fill(
474 gs->GetStripSignal());
475 }
476
477 for (size_t iStation = 0; iStation < signalSilicon.size(); ++iStation)
478 for (size_t iModule = 0; iModule < signalSilicon[iStation].size(); ++iModule)
479 if (signalSilicon[iStation][iModule][0] && signalSilicon[iStation][iModule][1]) {
480 histSiliconSignal2D[iStation][iModule]->Fill(signalSilicon[iStation][iModule][0],
481 signalSilicon[iStation][iModule][1]);
482 }
483}
484
485BmnStatus BmnHistSilicon::SetRefRun(Int_t id)
486{
487 // ONLY FOR STATION 0
488 if (refID != id) {
489 TString FileName = Form("bmn_run%04d_hist.root", id);
490 printf("SetRefRun: %s\n", FileName.Data());
491 refRunName = FileName;
492 refID = id;
493 for (Int_t iStation = 0; iStation < nStations; ++iStation)
494 BmnHist::LoadRefRun(refID, refPath + FileName, fTitle, canStripPads[iStation], NamesStrip[iStation]);
495 DrawBoth();
496 }
497
498 return kBMNSUCCESS;
499}
500
501void BmnHistSilicon::ClearRefRun()
502{
503 for (Int_t iStation = 0; iStation < nStations; ++iStation) {
504 for (auto& pad : canStripPads[iStation]) {
505 if (pad) {
506 if (pad->ref)
507 delete pad->ref;
508 pad->ref = NULL;
509 }
510 }
511 for (auto& padSignal : canSignalPads[iStation]) {
512 if (padSignal) {
513 if (padSignal->ref)
514 delete padSignal->ref;
515 padSignal->ref = NULL;
516 }
517 }
518 for (auto& padStripSignal : canStripSignalPads[iStation]) {
519 if (padStripSignal) {
520 if (padStripSignal->ref)
521 delete padStripSignal->ref;
522 padStripSignal->ref = NULL;
523 }
524 }
525 for (auto& padStripNoise : canStripNoisePads[iStation]) {
526 if (padStripNoise) {
527 if (padStripNoise->ref)
528 delete padStripNoise->ref;
529 padStripNoise->ref = NULL;
530 }
531 }
532 for (auto padChipSignal : canChipSignalPads[iStation]) {
533 if (padChipSignal) {
534 if (padChipSignal->ref)
535 delete padChipSignal->ref;
536 padChipSignal->ref = NULL;
537 }
538 }
539 }
540 refID = 0;
541}
542
543void BmnHistSilicon::Reset()
544{
545 printf("BmnHistSilicon : Reset histos\n");
546
547 for (auto& rowStripSignal : histSiliconStrip)
548 for (auto colStripSignal : rowStripSignal)
549 for (auto elStripSignal : colStripSignal)
550 elStripSignal->Reset();
551
552 for (auto& row : histSiliconSignal2D)
553 for (auto col : row)
554 col->Reset();
555
556 for (auto& rowStripSignal : histSiliconStripSignal)
557 for (auto colStripSignal : rowStripSignal)
558 for (auto elStripSignal : colStripSignal)
559 elStripSignal->Reset();
560
561 for (auto& rowStripNoise : histSiliconStripNoise)
562 for (auto colStripNoise : rowStripNoise)
563 for (auto elStripNoise : colStripNoise)
564 elStripNoise->Reset();
565
566 for (auto rowChipSignal : histSiliconChipSignal)
567 for (auto colChipSignal : rowChipSignal)
568 for (auto arrayChipSignal : colChipSignal)
569 for (auto elChipSignal : arrayChipSignal)
570 elChipSignal->Reset();
571}
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
BmnSetup
BmnSetup
Definition BmnEnums.h:89
BmnHistSilicon::ChangeStation
void ChangeStation(Int_t stationNumber)
Definition BmnHistSilicon.cxx:161
BmnHistSilicon::FillFromDigi
void FillFromDigi(DigiArrays *fDigiArrays)
Definition BmnHistSilicon.cxx:458
BmnHistSilicon::ResetCanvases
void ResetCanvases(Int_t numberOfModules)
Definition BmnHistSilicon.cxx:305
BmnHistSilicon::Register
void Register(THttpServer *serv)
Definition BmnHistSilicon.cxx:390
BmnHistSilicon::SetRefRun
BmnStatus SetRefRun(Int_t id)
Definition BmnHistSilicon.cxx:485
BmnHistSilicon::SetDir
void SetDir(TFile *outFile=NULL, TTree *recoTree=NULL)
Definition BmnHistSilicon.cxx:416
BmnHistSilicon::BmnHistSilicon
BmnHistSilicon(TString title, TString path="", Int_t periodID=7, BmnSetup setup=kBMNSETUP)
Definition BmnHistSilicon.cxx:5
BmnHistSilicon::~BmnHistSilicon
virtual ~BmnHistSilicon()
Definition BmnHistSilicon.cxx:346
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
BmnSiliconModule::GetStripLayer
BmnSiliconLayer & GetStripLayer(Int_t num)
Definition BmnSiliconModule.h:76
BmnSiliconStation::GetModule
BmnSiliconModule * GetModule(Int_t module_num)
Definition BmnSiliconStation.cxx:95
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::silicon
TClonesArray * silicon
Definition DigiArrays.h:125
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
setup
Definition setup.py:1