CbmRoot
Loading...
Searching...
No Matches
CbmMcbm2018MonitorTaskMuchLite.cxx
Go to the documentation of this file.
1/* Copyright (C) 2021 Variable Energy Cyclotron Centre, Kolkata
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Vikas Singhal [committer] */
4
5#include "CbmMcbm2018MonitorTaskMuchLite.h"
6
7#include "CbmMcbm2018MonitorAlgoMuchLite.h"
8#include "CbmMcbm2018MuchPar.h"
9#include "FairParGenericSet.h"
10#include "FairRootManager.h"
11#include "FairRun.h"
12#include "FairRunOnline.h"
13#include "FairRuntimeDb.h"
14#include "Logger.h"
15#include "TCanvas.h"
16#include "THttpServer.h"
17#include "TList.h"
18#include "TROOT.h"
19#include "TString.h"
20
21#include <TFile.h>
22
23#include <chrono>
24#include <cstdint>
25#include <fstream>
26#include <iomanip>
27#include <iostream>
28
29Bool_t bMcbm2018ResetTaskMuchLite = kFALSE;
30Bool_t bMcbm2018WriteTaskMuchLite = kFALSE;
31Bool_t bMcbm2018ScanNoisyTaskMuchLite = kFALSE;
32
45
46CbmMcbm2018MonitorTaskMuchLite::~CbmMcbm2018MonitorTaskMuchLite() { delete fMonitorAlgo; }
47
48Bool_t CbmMcbm2018MonitorTaskMuchLite::Init()
49{
50 LOG(info) << "CbmMcbm2018MonitorTaskMuchLite::Init";
51 LOG(info) << "Initializing Much 2019 Monitor";
52
53 return kTRUE;
54}
55
56void CbmMcbm2018MonitorTaskMuchLite::SetParContainers()
57{
58 LOG(info) << "Setting parameter containers for " << GetName();
59
60 TList* parCList = fMonitorAlgo->GetParList();
61
62 for (Int_t iparC = 0; iparC < parCList->GetEntries(); ++iparC) {
63 FairParGenericSet* tempObj = (FairParGenericSet*) (parCList->At(iparC));
64 parCList->Remove(tempObj);
65
66 std::string sParamName {tempObj->GetName()};
67 FairParGenericSet* newObj =
68 dynamic_cast<FairParGenericSet*>(FairRun::Instance()->GetRuntimeDb()->getContainer(sParamName.data()));
69
70 if (nullptr == newObj) {
71 LOG(error) << "Failed to obtain parameter container " << sParamName << ", for parameter index " << iparC;
72 return;
73 } // if( nullptr == newObj )
74
75 parCList->AddAt(newObj, iparC);
76 // delete tempObj;
77 } // for( Int_t iparC = 0; iparC < parCList->GetEntries(); ++iparC )
78
79 /*fUnpackParMuch =
80 (CbmMcbm2018MuchPar*) (FairRun::Instance()->GetRuntimeDb()->getContainer(
81 "CbmMcbm2018MuchPar")); */
82}
83
84Bool_t CbmMcbm2018MonitorTaskMuchLite::InitContainers()
85{
86 LOG(info) << "Init parameter containers for " << GetName();
87
89 CbmMcbm2018MuchPar* pUnpackPar =
90 dynamic_cast<CbmMcbm2018MuchPar*>(FairRun::Instance()->GetRuntimeDb()->getContainer("CbmMcbm2018MuchPar"));
91 if (nullptr == pUnpackPar) {
92 LOG(error) << "Failed to obtain parameter container CbmMcbm2018MuchPar";
93 return kFALSE;
94 } // if( nullptr == pUnpackPar )
95 /*
96 fbMonitorMode = pUnpackPar->GetMonitorMode();
97 LOG(info) << "Monitor mode: "
98 << ( fbMonitorMode ? "ON" : "OFF" );
99
100 fbDebugMonitorMode = pUnpackPar->GetDebugMonitorMode();
101 LOG(info) << "Debug Monitor mode: "
102 << ( fbDebugMonitorMode ? "ON" : "OFF" );
103*/
104
105 Bool_t initOK = fMonitorAlgo->InitContainers();
106 LOG(info) << "after initOK";
107
109 fMonitorAlgo->SetMonitorMode(fbMonitorMode);
110 fMonitorAlgo->SetHistoryHistoSize(fuHistoryHistoSize);
111 //fMonitorAlgo->SetPulserTotLimits(fuMinTotPulser, fuMaxTotPulser);
112 fMonitorAlgo->SetSpillThreshold(fuOffSpillCountLimit);
113
116 LOG(info) << "before creating histogram";
117 initOK &= fMonitorAlgo->CreateHistograms();
118 LOG(info) << "created histograms";
120 std::vector<std::pair<TNamed*, std::string>> vHistos = fMonitorAlgo->GetHistoVector();
122 std::vector<std::pair<TCanvas*, std::string>> vCanvases = fMonitorAlgo->GetCanvasVector();
123
125 THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
126 if (nullptr != server) {
127 for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
128 // LOG(info) << "Registering " << vHistos[ uHisto ].first->GetName()
129 // << " in " << vHistos[ uHisto ].second.data();
130 server->Register(Form("/%s", vHistos[uHisto].second.data()), vHistos[uHisto].first);
131 } // for( UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto )
132
133 for (UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv) {
134 // LOG(info) << "Registering " << vCanvases[ uCanv ].first->GetName()
135 // << " in " << vCanvases[ uCanv ].second.data();
136 server->Register(Form("/%s", vCanvases[uCanv].second.data()),
137 gROOT->FindObject((vCanvases[uCanv].first)->GetName()));
138 } // for( UInt_t uCanv = 0; uCanv < vCanvases.size(); ++uCanv )
139
140 server->RegisterCommand("/Reset_All", "bMcbm2018ResetTaskMuchLite=kTRUE");
141 server->RegisterCommand("/Write_All", "bMcbm2018WriteTaskMuchLite=kTRUE");
142 server->RegisterCommand("/ScanNoisyCh", "bMcbm2018ScanNoisyTaskMuchLite=kTRUE");
143 server->Restrict("/Reset_All", "allow=admin");
144 server->Restrict("/Write_All", "allow=admin");
145 server->Restrict("/ScanNoisyCh", "allow=admin");
146
147 } // if( nullptr != server )
148
149 return initOK;
150}
151
152Bool_t CbmMcbm2018MonitorTaskMuchLite::ReInitContainers()
153{
154 LOG(info) << "ReInit parameter containers for " << GetName();
155 Bool_t initOK = fMonitorAlgo->ReInitContainers();
156
157 return initOK;
158}
159
160/* Bool_t CbmMcbm2018MonitorTaskMuchLite::InitMuchParameters() {
161
162 fuNrOfDpbs = fUnpackParMuch->GetNrOfDpbs();
163 LOG(info) << "Nr. of MUCH DPBs: " << fuNrOfDpbs;
164
165 fDpbIdIndexMap.clear();
166 for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
167 fDpbIdIndexMap[fUnpackParMuch->GetDpbId(uDpb)] = uDpb;
168 LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x"
169 << std::setw(4) << std::hex << fUnpackParMuch->GetDpbId(uDpb)
170 << std::dec << " => "
171 << fDpbIdIndexMap[fUnpackParMuch->GetDpbId(uDpb)];
172 } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
173
174 fuNbFebs = fUnpackParMuch->GetNrOfFebs();
175 LOG(info) << "Nr. of FEBs: " << fuNbFebs;
176
177 fuNbStsXyters = fUnpackParMuch->GetNrOfAsics();
178 LOG(info) << "Nr. of StsXyter ASICs: " << fuNbStsXyters;
179
180 fvbCrobActiveFlag.resize(fuNrOfDpbs);
181 //fvdFebAdcGain.resize( fuNrOfDpbs );
182 //fvdFebAdcOffs.resize( fuNrOfDpbs );
183 for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
184 fvbCrobActiveFlag[uDpb].resize(fUnpackParMuch->GetNbCrobsPerDpb());
185 //fvdFebAdcGain[ uDpb ].resize( fUnpackParMuch->GetNbCrobsPerDpb() );
186 //fvdFebAdcOffs[ uDpb ].resize( fUnpackParMuch->GetNbCrobsPerDpb() );
187 for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb();
188 ++uCrobIdx) {
189 fvbCrobActiveFlag[uDpb][uCrobIdx] =
190 fUnpackParMuch->IsCrobActive(uDpb, uCrobIdx);
191 // fvdFebAdcGain[ uDpb ][ uCrobIdx ].resize( fUnpackParMuch->GetNbFebsPerCrob(), 0.0 );
192 //fvdFebAdcOffs[ uDpb ][ uCrobIdx ].resize( fUnpackParMuch->GetNbFebsPerCrob(), 0.0 );
193 } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb(); ++uCrobIdx )
194 } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
195
196 for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
197 for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb();
198 ++uCrobIdx) {
199 LOG(info) << Form("DPB #%02u CROB #%02u Active: ", uDpb, uCrobIdx)
200 << fvbCrobActiveFlag[uDpb][uCrobIdx];
201 } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb(); ++uCrobIdx )
202 } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
203
204 if (fbBinningFw)
205 LOG(info) << "Unpacking data in bin sorter FW mode";
206 else
207 LOG(info) << "Unpacking data in full time sorter FW mode (legacy)";
208
209 // Internal status initialization
210 fvulCurrentTsMsb.resize(fuNrOfDpbs);
211 fvuCurrentTsMsbCycle.resize(fuNrOfDpbs);
212 fvuInitialHeaderDone.resize(fuNrOfDpbs);
213 fvuInitialTsMsbCycleHeader.resize(fuNrOfDpbs);
214 fvuElinkLastTsHit.resize(fuNrOfDpbs);
215 for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
216 fvulCurrentTsMsb[uDpb] = 0;
217 fvuCurrentTsMsbCycle[uDpb] = 0;
218 fvuInitialHeaderDone[uDpb] = kFALSE;
219 fvuInitialTsMsbCycleHeader[uDpb] = 0;
220 } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
221
222 fvdPrevMsTime.resize(kiMaxNbFlibLinks);
223 fvulChanLastHitTime.resize(fuNbStsXyters);
224 fvdChanLastHitTime.resize(fuNbStsXyters);
225 fvdMsTime.resize(fuMaxNbMicroslices);
226 fvuChanNbHitsInMs.resize(fuNbFebs);
227 fvdChanLastHitTimeInMs.resize(fuNbFebs);
228 fvusChanLastHitAdcInMs.resize(fuNbFebs);
229 fvmAsicHitsInMs.resize(fuNbFebs);
230
231 //fvdMsTime.resize( fuMaxNbMicroslices );
232 //fvuChanNbHitsInMs.resize( fuNbStsXyters );
233 //fvdChanLastHitTimeInMs.resize( fuNbStsXyters );
234 //fvusChanLastHitAdcInMs.resize( fuNbStsXyters );
235 //fvmAsicHitsInMs.resize( fuNbStsXyters );
236
237 for (UInt_t uXyterIdx = 0; uXyterIdx < fuNbFebs; ++uXyterIdx) {
238 fvulChanLastHitTime[uXyterIdx].resize(fUnpackParMuch->GetNbChanPerAsic());
239 fvdChanLastHitTime[uXyterIdx].resize(fUnpackParMuch->GetNbChanPerAsic());
240 fvuChanNbHitsInMs[uXyterIdx].resize(fUnpackParMuch->GetNbChanPerAsic());
241 fvdChanLastHitTimeInMs[uXyterIdx].resize(
242 fUnpackParMuch->GetNbChanPerAsic());
243 fvusChanLastHitAdcInMs[uXyterIdx].resize(
244 fUnpackParMuch->GetNbChanPerAsic());
245 fvmAsicHitsInMs[uXyterIdx].clear();
246
247 for (UInt_t uChan = 0; uChan < fUnpackParMuch->GetNbChanPerAsic();
248 ++uChan) {
249 fvulChanLastHitTime[uXyterIdx][uChan] = 0;
250 fvdChanLastHitTime[uXyterIdx][uChan] = -1.0;
251
252 fvuChanNbHitsInMs[uXyterIdx][uChan].resize(fuMaxNbMicroslices);
253 fvdChanLastHitTimeInMs[uXyterIdx][uChan].resize(fuMaxNbMicroslices);
254 fvusChanLastHitAdcInMs[uXyterIdx][uChan].resize(fuMaxNbMicroslices);
255 for (UInt_t uMsIdx = 0; uMsIdx < fuMaxNbMicroslices; ++uMsIdx) {
256 fvuChanNbHitsInMs[uXyterIdx][uChan][uMsIdx] = 0;
257 fvdChanLastHitTimeInMs[uXyterIdx][uChan][uMsIdx] = -1.0;
258 fvusChanLastHitAdcInMs[uXyterIdx][uChan][uMsIdx] = 0;
259 } // for( UInt_t uMsIdx = 0; uMsIdx < fuMaxNbMicroslices; ++uMsIdx )
260 } // for( UInt_t uChan = 0; uChan < fUnpackParMuch->GetNbChanPerAsic(); ++uChan )
261 } // for( UInt_t uXyterIdx = 0; uXyterIdx < fuNbStsXyters; ++uXyterIdx )
262
263 LOG(info) << "CbmMcbm2018MonitorTaskMuchLite::ReInitContainers => Changed "
264 "fvuChanNbHitsInMs size "
265 << fvuChanNbHitsInMs.size() << " VS " << fuNbFebs;
266 LOG(info) << "CbmMcbm2018MonitorTaskMuchLite::ReInitContainers => Changed "
267 "fvuChanNbHitsInMs size "
268 << fvuChanNbHitsInMs[0].size() << " VS "
269 << fUnpackParMuch->GetNbChanPerAsic();
270 LOG(info) << "CbmMcbm2018MonitorTaskMuchLite::ReInitContainers => Changed "
271 "fvuChanNbHitsInMs size "
272 << fvuChanNbHitsInMs[0][0].size() << " VS " << fuMaxNbMicroslices;
273
274 fvmFebHitsInMs.resize(fuNbFebs);
275 fviFebTimeSecLastRateUpdate.resize(fuNbFebs, -1);
276 fviFebCountsSinceLastRateUpdate.resize(fuNbFebs, -1);
277 fvdFebChanCountsSinceLastRateUpdate.resize(fuNbFebs);
278 fdMuchFebChanLastTimeForDist.resize(fuNbFebs);
279 for (UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx) {
280 fvmFebHitsInMs[uFebIdx].clear();
281 fvdFebChanCountsSinceLastRateUpdate[uFebIdx].resize(
282 fUnpackParMuch->GetNbChanPerFeb(), 0.0);
283 fdMuchFebChanLastTimeForDist[uFebIdx].resize(
284 fUnpackParMuch->GetNbChanPerFeb(), -1.0);
285 } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
286
288 // SmxErrInitializeVariables();
290
291 return kTRUE;
292} */
293
294void CbmMcbm2018MonitorTaskMuchLite::AddMsComponentToList(size_t component, UShort_t usDetectorId)
295{
296 fMonitorAlgo->AddMsComponentToList(component, usDetectorId);
297}
298
299Bool_t CbmMcbm2018MonitorTaskMuchLite::DoUnpack(const fles::Timeslice& ts, size_t /*component*/)
300{
301 if (bMcbm2018ResetTaskMuchLite) {
302 fMonitorAlgo->ResetAllHistos();
303 bMcbm2018ResetTaskMuchLite = kFALSE;
304 } // if( bMcbm2018ResetMuchLite )
305 if (bMcbm2018WriteTaskMuchLite) {
306 fMonitorAlgo->SaveAllHistos(fsHistoFilename);
307 bMcbm2018WriteTaskMuchLite = kFALSE;
308 } // if( bMcbm2018WriteMuchLite )
309 if (bMcbm2018ScanNoisyTaskMuchLite) {
310 fMonitorAlgo->ScanForNoisyChannels();
311 bMcbm2018ScanNoisyTaskMuchLite = kFALSE;
312 } // if( bMcbm2018WriteMuchLite )
313
314
315 /* if (fbMonitorMode && bMcbm2018MonitorTaskMuchResetHistos) {
316 LOG(info) << "Reset Much Monitor histos ";
317 fMonitorAlgo->ResetAllHistos();
318 bMcbm2018MonitorTaskMuchResetHistos = kFALSE;
319 } // if( fbMonitorMode && bMcbm2018MonitorTaskBmonResetHistos ) */ //closed by me
320
321 if (kFALSE == fMonitorAlgo->ProcessTs(ts)) {
322 //if (kFALSE == fMonitorAlgo->ProcessMuchMs(ts)) {
323 LOG(error) << "Failed processing TS " << ts.index() << " in unpacker algorithm class";
324 return kTRUE;
325 } // if( kFALSE == fMonitorAlgo->ProcessTs( ts ) )
326
328 std::vector<CbmMuchBeamTimeDigi> vDigi = fMonitorAlgo->GetVector();
329 fMonitorAlgo->ClearVector();
330
331 if (0 == fulTsCounter % 10000) LOG(info) << "Processed " << fulTsCounter << "TS";
332 fulTsCounter++;
333
334 return kTRUE;
335}
336
337
338void CbmMcbm2018MonitorTaskMuchLite::Reset() {}
339
340void CbmMcbm2018MonitorTaskMuchLite::Finish()
341{
342 fMonitorAlgo->Finish();
344 std::vector<std::pair<TNamed*, std::string>> vHistos = fMonitorAlgo->GetHistoVector();
345
347 TFile* oldFile = gFile;
348 TDirectory* oldDir = gDirectory;
349
350 TFile* histoFile = nullptr;
351
352 // open separate histo file in recreate mode
353 histoFile = new TFile(fsHistoFilename, "RECREATE");
354 histoFile->cd();
355
357 for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
359 TString sFolder = vHistos[uHisto].second.data();
360 if (nullptr == gDirectory->Get(sFolder)) gDirectory->mkdir(sFolder);
361 gDirectory->cd(sFolder);
362
364 vHistos[uHisto].first->Write();
365
366 histoFile->cd();
367 } // for( UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto )
368
370 gFile = oldFile;
371 gDirectory = oldDir;
372
373 histoFile->Close();
374}
375
376void CbmMcbm2018MonitorTaskMuchLite::SetIgnoreOverlapMs(Bool_t bFlagIn) { fMonitorAlgo->SetIgnoreOverlapMs(bFlagIn); }
377
378/*void CbmMcbm2018MonitorTaskMuchLite::SetChannelMap(UInt_t uChan0,
379 UInt_t uChan1,
380 UInt_t uChan2,
381 UInt_t uChan3,
382 UInt_t uChan4,
383 UInt_t uChan5,
384 UInt_t uChan6,
385 UInt_t uChan7) {
386 fMonitorAlgo->SetChannelMap(
387 uChan0, uChan1, uChan2, uChan3, uChan4, uChan5, uChan6, uChan7);
388} */
389
390ClassImp(CbmMcbm2018MonitorTaskMuchLite)
ClassImp
ClassImp(CbmConverterManager)
bMcbm2018ResetTaskMuchLite
Bool_t bMcbm2018ResetTaskMuchLite
Definition CbmMcbm2018MonitorTaskMuchLite.cxx:29
bMcbm2018WriteTaskMuchLite
Bool_t bMcbm2018WriteTaskMuchLite
Definition CbmMcbm2018MonitorTaskMuchLite.cxx:30
bMcbm2018ScanNoisyTaskMuchLite
Bool_t bMcbm2018ScanNoisyTaskMuchLite
Definition CbmMcbm2018MonitorTaskMuchLite.cxx:31
Int_t
int Int_t
Definition RootTypesDef.h:16
Bool_t
bool Bool_t
Definition RootTypesDef.h:15
CbmMcbm2018MonitorTaskMuchLite::DoUnpack
virtual Bool_t DoUnpack(const fles::Timeslice &ts, size_t component)
Definition CbmMcbm2018MonitorTaskMuchLite.cxx:299
CbmMcbm2018MonitorTaskMuchLite::fuHistoryHistoSize
UInt_t fuHistoryHistoSize
Histograms related variables.
Definition CbmMcbm2018MonitorTaskMuchLite.h:114
CbmMcbm2018MonitorTaskMuchLite::fMonitorAlgo
CbmMcbm2018MonitorAlgoMuchLite * fMonitorAlgo
Definition CbmMcbm2018MonitorTaskMuchLite.h:125
CbmMcbm2018MonitorTaskMuchLite::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition CbmMcbm2018MonitorTaskMuchLite.cxx:294