diff --git a/fles/mcbm2018/CMakeLists.txt b/fles/mcbm2018/CMakeLists.txt index dbd294e9d26b68c8407cd9593b2479fc3c69775c..e44e2b2cc4523712171294ce8a5d36649bb82d3b 100644 --- a/fles/mcbm2018/CMakeLists.txt +++ b/fles/mcbm2018/CMakeLists.txt @@ -27,6 +27,7 @@ Set(INCLUDE_DIRECTORIES ${CBMROOT_SOURCE_DIR}/fles/mcbm2018/tasks ${CBMDETECTORBASE_DIR}/trd # required for parameter handling of the trd + ${CBMDETECTORBASE_DIR}/psd ) Set(SYSTEM_INCLUDE_DIRECTORIES @@ -131,7 +132,7 @@ EndIf() Set(LINKDEF CbmFlibMcbm2018LinkDef.h ) Set(LIBRARY_NAME CbmFlibMcbm2018) Set(DEPENDENCIES - CbmFlibFlesTools CbmData CbmBase fles_ipc Eve Base CbmTrdBase + CbmFlibFlesTools CbmData CbmBase fles_ipc Eve Base CbmTrdBase CbmPsdBase ) GENERATE_LIBRARY() diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx index 0b6371b396b27c6d6714e469910f761df91987c2..6e380f37b97f19458cc3d299af8fe73346dde6a2 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx @@ -52,6 +52,7 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() : fdTsStartTime( -1.0 ), fdTsStopTimeCore( -1.0 ), fdMsTime( -1.0 ), + fdPrevMsTime( -1.0 ), fuMsIndex( 0 ), fuCurrentEquipmentId( 0 ), fuCurrDpbId( 0 ), @@ -84,6 +85,7 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() : fvhHitChargeByWfmChan( kuNbChanPsd, nullptr ), fvhHitChargeEvoChan( kuNbChanPsd, nullptr ), fvhHitWfmChan( kuNbChanPsd, nullptr ), + fvhHitFitWfmChan( kuNbChanPsd, nullptr ), kvuWfmRanges( kuNbWfmRanges, 0 ), kvuWfmInRangeToChangeChan( kuNbChanPsd*kuNbWfmRanges, 0 ), fv3hHitWfmFlattenedChan( kuNbChanPsd*kuNbWfmRanges*kuNbWfmExamples, nullptr ), @@ -104,10 +106,14 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() : fhLostMsgsCntEvo( nullptr ), fhReadEvtsCntEvo( nullptr ), fhAdcTimeEvo( nullptr ), + fhMsLengthEvo( nullptr ), fhMsgsCntPerMsEvo( nullptr ), fhReadMsgsCntPerMsEvo( nullptr ), fhLostMsgsCntPerMsEvo( nullptr ), fhReadEvtsCntPerMsEvo( nullptr ), + fvhFitHarmonic1Chan( kuNbChanPsd, nullptr ), + fvhFitHarmonic2Chan( kuNbChanPsd, nullptr ), + fvhFitQaChan( kuNbChanPsd, nullptr ), fcSummary( nullptr ), fcHitMaps( nullptr ), fcChargesFPGA( nullptr ), @@ -440,6 +446,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u UInt_t uHitChannel = PsdReader.VectHitHdr.at(hit_iter).uHitChannel; UInt_t uSignalCharge = PsdReader.VectHitHdr.at(hit_iter).uSignalCharge; UInt_t uZeroLevel = PsdReader.VectHitHdr.at(hit_iter).uZeroLevel; + std::vector<uint16_t> uWfm = PsdReader.VectHitData.at(hit_iter).uWfm; + if(uHitChannel >= kuNbChanPsd) //uHitChannel numerated from 0 { LOG(error) << "hit channel number out of range! channel index: " << uHitChannel << " max: " << GetNbChanPsd(); @@ -463,11 +471,12 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u uint16_t uHitAmlpitude = 0; uint16_t uHitChargeWfm = 0; fvhHitWfmChan[ uHitChannel ]->Reset(); - for(UInt_t wfm_iter = 0; wfm_iter < PsdReader.VectHitData.at(hit_iter).uWfm.size(); wfm_iter++) + fvhHitFitWfmChan[ uHitChannel ]->Reset(); + for(UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++) { - if(PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter) > uHitAmlpitude) uHitAmlpitude = PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter); - uHitChargeWfm += PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter) - uZeroLevel; - fvhHitWfmChan[ uHitChannel ]->Fill(wfm_iter, PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter)); + if(uWfm.at(wfm_iter) > uHitAmlpitude) uHitAmlpitude = uWfm.at(wfm_iter); + uHitChargeWfm += uWfm.at(wfm_iter) - uZeroLevel; + fvhHitWfmChan[ uHitChannel ]->Fill(wfm_iter, uWfm.at(wfm_iter)); } fvhHitWfmChan[ uHitChannel ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel )); uHitAmlpitude -= uZeroLevel; @@ -484,8 +493,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u UInt_t uFlatIndexHisto = uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd + i * kuNbChanPsd + uHitChannel; fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Reset(); - for(UInt_t wfm_iter = 0; wfm_iter < PsdReader.VectHitData.at(hit_iter).uWfm.size(); wfm_iter++) - fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Fill(wfm_iter, PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter)); + for(UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++) + fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Fill(wfm_iter, uWfm.at(wfm_iter)); fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel )); kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) ++; @@ -494,6 +503,36 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u }// if( uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i+1) ) }// for (uint8_t i=0; i<kuNbWfmRanges; ++i) + + int gate_beg = 0; + int gate_end = 7; + PsdSignalFitting::PronyFitter Pfitter(2,2,gate_beg,gate_end); + + Pfitter.SetDebugMode(0); + Pfitter.SetWaveform(uWfm, uZeroLevel); + int SignalBeg = 2; + Int_t best_signal_begin = Pfitter.ChooseBestSignalBeginHarmonics(SignalBeg-1, SignalBeg+1); + + Pfitter.SetSignalBegin(best_signal_begin); + Pfitter.CalculateFitHarmonics(); + Pfitter.CalculateFitAmplitudes(); + + Float_t fit_integral = Pfitter.GetIntegral(gate_beg, gate_end); + Float_t fit_R2 = Pfitter.GetRSquare(gate_beg, gate_end); + + std::complex<float>* harmonics = Pfitter.GetHarmonics(); + std::vector<uint16_t> uFitWfm = Pfitter.GetFitWfm(); + for(UInt_t wfm_iter = 0; wfm_iter < uFitWfm.size(); wfm_iter++) + { + fvhHitFitWfmChan[ uHitChannel ]->Fill(wfm_iter, uFitWfm.at(wfm_iter)); + fvhHitWfmChan[ uHitChannel ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u R2 %.5f; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel, fit_R2 )); + } + + fvhFitQaChan[ uHitChannel ]->Fill(fit_integral, fit_R2); + + if(fit_R2 > 0.02) continue; + fvhFitHarmonic1Chan[ uHitChannel ]->Fill(std::real(harmonics[1]), std::imag(harmonics[1])); + fvhFitHarmonic2Chan[ uHitChannel ]->Fill(std::real(harmonics[2]), std::imag(harmonics[2])); } // for(int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber; hit_iter++) } @@ -540,6 +579,12 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u } } + if( fulCurrentMsIdx != PsdReader.EvHdrAb.ulMicroSlice ) + LOG(error) << "Wrong MS index!" + << " in microslice " << fulCurrentMsIdx + << " by PsdReader " << PsdReader.EvHdrAb.ulMicroSlice + << "\n"; + fhMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, uNbMessages ); fhReadMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, PsdReader.GetTotalGbtWordsRead() ); fhLostMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, uNbMessages - PsdReader.GetTotalGbtWordsRead() ); @@ -551,6 +596,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u }//if(uSize != 0) + if(fdPrevMsTime < 0.) fdPrevMsTime = fdMsTime; + else + { + fhMsLengthEvo->Fill( fdMsTime - fdStartTime, 1e9* (fdMsTime - fdPrevMsTime)); + fdPrevMsTime = fdMsTime; + } + /// Fill histograms FillHistograms(); @@ -560,7 +612,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() { std::string sFolder = "MoniPsd"; - + std::string sFitFolder = "PronyFit"; LOG(info) << "create Histos for PSD monitoring "; /// Logarithmic bining @@ -601,6 +653,9 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() fhAdcTimeEvo = new TH2I( "hAdcTimeEvo", "Evolution of ADC time vs time in run; Time in run [s]; Adc time *12.5[ns]", fuHistoryHistoSize, 0, fuHistoryHistoSize, 500, 0, 9000 ); + fhMsLengthEvo = new TH2I( "hMsLengthEvo", "Evolution of MS length vs time in run; Time in run [s]; MS length [ns]", + fuHistoryHistoSize, 0, fuHistoryHistoSize, (Int_t)1e2, 0, 1e8); + fhMsgsCntPerMsEvo = new TH2I( "hMsgsCntPerMsEvo", "Evolution of TotalMsgs counts, per MS vs time in run; Time in run [s]; TotalMsgs Count/MS []; MS", fuHistoryHistoSize, 0, fuHistoryHistoSize, @@ -633,6 +688,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() AddHistoToVector( fhReadEvtsCntEvo, sFolder ); AddHistoToVector( fhAdcTimeEvo, sFolder ); + AddHistoToVector( fhMsLengthEvo, sFolder ); AddHistoToVector( fhMsgsCntPerMsEvo, sFolder ); AddHistoToVector( fhReadMsgsCntPerMsEvo, sFolder ); @@ -682,6 +738,15 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() Form( "hHitWfmChan%03u", uChan ), Form( "HitWfmChan%03u", uChan ), 8, 0, 8); + fvhHitWfmChan[ uChan ]->SetMarkerStyle(31); + fvhHitWfmChan[ uChan ]->SetMarkerSize(0.5); + + fvhHitFitWfmChan[ uChan ] = new TH1I( + Form( "hHitFitWfmChan%03u", uChan ), + Form( "HitFitWfmChan%03u", uChan ), + 8, 0, 8); + fvhHitFitWfmChan[ uChan ]->SetLineColor(kRed); + fvhHitFitWfmChan[ uChan ]->SetLineWidth(2); for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++) { @@ -696,6 +761,23 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() }// for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++) } // for( UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples; uWfmExampleIter ++) + fvhFitHarmonic1Chan[ uChan ] = new TH2I( + Form( "hFitHarmonic1Chan%03u", uChan ), + Form( "Waveform fit harmonic 1 for channel %03u; Real part []; Imag part []", uChan ), + 400, -2, 2, 200, -1, 1 ); + fvhFitHarmonic1Chan[ uChan ]->SetMarkerColor(kRed); + + fvhFitHarmonic2Chan[ uChan ] = new TH2I( + Form( "hFitHarmonic2Chan%03u", uChan ), + Form( "Waveform fit harmonic 2 for channel %03u; Real part []; Imag part []", uChan ), + 400, -2, 2, 200, -1, 1 ); + fvhFitHarmonic2Chan[ uChan ]->SetMarkerColor(kBlue); + + fvhFitQaChan[ uChan ] = new TH2I( + Form( "hFitQaChan%03u", uChan ), + Form( "Waveform fit QA for channel %03u; Integral [adc counts]; R2 []", uChan ), + fviHistoChargeArgs.at(0), fviHistoChargeArgs.at(1), fviHistoChargeArgs.at(2), 500, 0, 1 ); + /// Add pointers to the vector with all histo for access by steering class AddHistoToVector( fvhHitCntEvoChan[ uChan ], sFolder ); @@ -706,10 +788,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() AddHistoToVector( fvhHitChargeByWfmChan[ uChan ], sFolder ); AddHistoToVector( fvhHitChargeEvoChan[ uChan ], sFolder ); + AddHistoToVector( fvhFitHarmonic1Chan[ uChan ], sFitFolder ); + AddHistoToVector( fvhFitHarmonic2Chan[ uChan ], sFitFolder ); + AddHistoToVector( fvhFitQaChan[ uChan ], sFitFolder ); + } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan ) - /// Cleanup array of log bins -// delete dBinsLog; + /*******************************************************************/ @@ -766,6 +851,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() gPad->SetLogz(); fhHitChargeMap->Draw("colz"); + fcSummary->cd( 4 ); + gPad->SetGridx(); + gPad->SetGridy(); + gPad->SetLogy(); + gPad->SetLogz(); + fhMsLengthEvo->Draw("colz"); + AddCanvasToVector( fcSummary, "canvases" ); /*******************************************************************/ @@ -871,7 +963,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++) { fcWfmsAllChannels->cd( 1 + uChan ); - fvhHitWfmChan[ uChan ]->Draw("HIST LP"); + fvhHitWfmChan[ uChan ]->Draw("HIST P"); + fvhHitFitWfmChan[ uChan ]->Draw("L SAME"); } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++) AddCanvasToVector( fcWfmsAllChannels, "waveforms" ); @@ -901,6 +994,26 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() /*******************************************************************/ + fcPronyFit = new TCanvas( "cPronyFit", "Prony wfm fitting", w, h); + fcPronyFit->Divide( 2 ); + + fcPronyFit->cd( 1 ); + for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++) + { + fvhFitHarmonic1Chan[ uChan ]->Draw( "same" ); + fvhFitHarmonic2Chan[ uChan ]->Draw( "same" ); + } + + fcPronyFit->cd( 2 ); + for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++) + { + fvhFitQaChan[ uChan ]->Draw( "same" ); + } + + AddCanvasToVector( fcPronyFit, "PronyFit" ); + + /*******************************************************************/ + return kTRUE; } @@ -938,6 +1051,11 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ResetHistograms() fvhHitChargeByWfmChan[ uChan ]->Reset(); fvhHitChargeEvoChan[ uChan ]->Reset(); fvhHitWfmChan[ uChan ]->Reset(); + fvhHitFitWfmChan[ uChan ]->Reset(); + + fvhFitHarmonic1Chan[ uChan ]->Reset(); + fvhFitHarmonic2Chan[ uChan ]->Reset(); + fvhFitQaChan[ uChan ]->Reset(); } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan ) for( UInt_t uFlatIndex = 0; uFlatIndex < kuNbChanPsd*kuNbWfmRanges*kuNbWfmExamples; ++uFlatIndex ) @@ -961,6 +1079,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ResetHistograms() fhReadEvtsCntEvo->Reset(); fhAdcTimeEvo->Reset(); + fhMsLengthEvo->Reset(); fhMsgsCntPerMsEvo->Reset(); fhReadMsgsCntPerMsEvo->Reset(); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h index b049a12aec03118d6430d089250caeac904d69d6..7bb3657c4b2877d2da6430845cb9d41aad81a918 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h @@ -14,6 +14,7 @@ // Data #include "PsdGbtReader.h" #include "CbmPsdDigi.h" +#include "PronyFitter.h" // CbmRoot @@ -25,10 +26,6 @@ #include <map> class CbmMcbm2018PsdPar; -/* -class TCanvas; -class THttpServer; -*/ class TH1; class TH2; class TProfile; @@ -68,13 +65,13 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> private: - /// Control flags + /// Control flags Bool_t fbMonitorMode; //! Switch ON the filling of a minimal set of histograms Bool_t fbDebugMonitorMode; //! Switch ON the filling of a additional set of histograms std::vector< Bool_t > fvbMaskedComponents; Bool_t fbFirstPackageError; - /// Settings from parameter file + /// Settings from parameter file CbmMcbm2018PsdPar* fUnpackPar; //! /// Readout chain dimensions and mapping UInt_t fuNrOfGdpbs; //! Total number of GDPBs in the system @@ -83,19 +80,20 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> UInt_t fuNrOfChannelsPerFee; //! Number of channels in each FEE UInt_t fuNrOfChannelsPerGdpb; //! Number of channels per GDPB - /// Constants + /// Constants static const Int_t kiMaxNbFlibLinks = 32; static const UInt_t kuBytesPerMessage = 8; - static const UInt_t kuNbChanPsd = 32; + static const UInt_t kuNbChanPsd = 10; static constexpr UInt_t GetNbChanPsd() { return kuNbChanPsd; } - /// Running indices + /// Running indices /// TS/MS info ULong64_t fulCurrentTsIdx; ULong64_t fulCurrentMsIdx; Double_t fdTsStartTime; //! Time in ns of current TS from the index of the first MS first component Double_t fdTsStopTimeCore; //! End Time in ns of current TS Core from the index of the first MS first component Double_t fdMsTime; //! Start Time in ns of current MS from its index field in header + Double_t fdPrevMsTime; //! Start Time in ns of previous MS from its index field in header UInt_t fuMsIndex; //! Index of current MS within the TS /// Current data properties @@ -115,13 +113,13 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> Double_t fdStartTimeMsSz; /** Time of first microslice, used as reference for evolution plots**/ std::chrono::steady_clock::time_point ftStartTimeUnix; /** Time of run Start from UNIX system, used as reference for long evolution plots against reception time **/ - /// Histograms related variables + /// Histograms related variables UInt_t fuHistoryHistoSize; /** Size in seconds of the evolution histograms **/ std::vector< Int_t > fviHistoChargeArgs; /** Charge histogram arguments in adc counts **/ std::vector< Int_t > fviHistoAmplArgs; /** Amplitude histogram arguments in adc counts **/ std::vector< Int_t > fviHistoZLArgs; /** ZeroLevel histogram arguments in adc counts **/ - /// Histograms + /// Histograms UInt_t fuReadEvtCnt; UInt_t fuMsgsCntInMs; UInt_t fuReadMsgsCntInMs; @@ -140,6 +138,7 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> std::vector< TH1 * > fvhHitChargeByWfmChan; std::vector< TH2 * > fvhHitChargeEvoChan; std::vector< TH1 * > fvhHitWfmChan; + std::vector< TH1 * > fvhHitFitWfmChan; static const UInt_t kuNbWfmRanges = 8; static const UInt_t kuNbWfmExamples = 8; @@ -172,13 +171,19 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> TH1 * fhReadEvtsCntEvo; TH2 * fhAdcTimeEvo; + TH2 * fhMsLengthEvo; TH2 * fhMsgsCntPerMsEvo; TH2 * fhReadMsgsCntPerMsEvo; TH2 * fhLostMsgsCntPerMsEvo; TH2 * fhReadEvtsCntPerMsEvo; - /// Canvases + /// Waveform fitting + std::vector< TH2 * > fvhFitHarmonic1Chan; + std::vector< TH2 * > fvhFitHarmonic2Chan; + std::vector< TH2 * > fvhFitQaChan; + + /// Canvases TCanvas * fcSummary; TCanvas * fcHitMaps; TCanvas * fcChargesFPGA; @@ -189,6 +194,7 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> TCanvas * fcSpillCountsHori; TCanvas * fcWfmsAllChannels; std::vector< TCanvas * > fvcWfmsChan; + TCanvas * fcPronyFit; CbmMcbm2018MonitorAlgoPsd(const CbmMcbm2018MonitorAlgoPsd&); CbmMcbm2018MonitorAlgoPsd operator=(const CbmMcbm2018MonitorAlgoPsd&); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx index bde6d476e756b1aecb37625309384fbd630ed0b1..5a44a44c01081cfd60dd82fbc388c27fccab57c2 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx @@ -368,9 +368,9 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM static_cast<unsigned int>(msDescriptor.hdr_id), static_cast<unsigned int>(msDescriptor.hdr_ver), msDescriptor.eq_id, msDescriptor.flags, static_cast<unsigned int>(msDescriptor.sys_id), - static_cast<unsigned int>(msDescriptor.sys_ver), + static_cast<unsigned int>(msDescriptor.sys_ver), static_cast<unsigned long>(msDescriptor.idx), msDescriptor.crc, - msDescriptor.size, + msDescriptor.size, static_cast<unsigned long>(msDescriptor.offset) ); } // if( fulCurrentTsIdx < 10 && 0 == uMsIdx ) /* @@ -424,6 +424,7 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM fuCurrentSpillIdx++; fuCurrentSpillPlot = ( fuCurrentSpillPlot + 1 ) % kuNbSpillPlots; fdStartTimeSpill = fdMsTime; + fvhDpbMapSpill[ fuCurrentSpillPlot ]->Reset(); fvhChannelMapSpill[ fuCurrentSpillPlot ]->Reset(); } // if( fbSpillOn && fuCountsLastSecond < fuOffSpillCountLimit ) else if( fuOffSpillCountLimit < fuCountsLastSecond ) @@ -513,8 +514,10 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM UInt_t uTot = mess.getGdpbHit32Tot(); if( uTot < fuMinTotPulser || fuMaxTotPulser < uTot ) { + fhDpbMap->Fill( fuCurrDpbIdx ); fhChannelMap->Fill( uChannelT0 ); + fvhDpbMapSpill[ fuCurrentSpillPlot ]->Fill( fuCurrDpbIdx ); fvhChannelMapSpill[ fuCurrentSpillPlot ]->Fill( fuDiamChanMap[ uChannelT0 ] ); fhHitsPerSpill->Fill( fuCurrentSpillIdx ); } // if( uTot < fuMinTotPulser || fuMaxTotPulser < uTot ) @@ -879,14 +882,16 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms() uint32_t iNbBinsLog = 0; /// Parameters are NbDecadesLog, NbStepsDecade, NbSubStepsInStep std::vector<double> dBinsLogVector = GenerateLogBinArray( 4, 9, 1, iNbBinsLog ); - double* dBinsLog = dBinsLogVector.data(); + double* dBinsLog = dBinsLogVector.data(); // double * dBinsLog = GenerateLogBinArray( 4, 9, 1, iNbBinsLog ); /*******************************************************************/ + fhDpbMap = new TH1I( "hDpbMap", "Map of hits on T0 detector; DPB; Hits Count []", + fuNrOfGdpbs, -0.5, fuNrOfGdpbs - 0.5 ); fhChannelMap = new TH1I( "hChannelMap", "Map of hits on T0 detector; Strip; Hits Count []", - kuNbChanDiamond, 0., kuNbChanDiamond); + kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5 ); fhHitMapEvo = new TH2I( "hHitMapEvo", "Map of hits on T0 detector vs time in run; Chan; Time in run [s]; Hits Count []", - kuNbChanDiamond, 0., kuNbChanDiamond, + kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5, fuHistoryHistoSize, 0, fuHistoryHistoSize ); fhHitTotEvo = new TH2I( "hHitTotEvo", "Evolution of TOT in T0 detector vs time in run; Time in run [s]; TOT [ bin ]; Hits Count []", fuHistoryHistoSize, 0, fuHistoryHistoSize, @@ -896,9 +901,12 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms() fuHistoryHistoSize, 0, fuHistoryHistoSize ); for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) { + fvhDpbMapSpill.push_back( new TH1I( Form("hDpbMapSpill%02u", uSpill), + Form("Map of hits on T0 detector in current spill %02u; DPB; Hits Count []", uSpill), + fuNrOfGdpbs, -0.5, fuNrOfGdpbs - 0.5) ); fvhChannelMapSpill.push_back( new TH1I( Form("hChannelMapSpill%02u", uSpill), Form("Map of hits on T0 detector in current spill %02u; Strip; Hits Count []", uSpill), - kuNbChanDiamond, 0., kuNbChanDiamond) ); + kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5) ); } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) fhHitsPerSpill = new TH1I( "hHitsPerSpill", "Hit count per spill; Spill; Hits Count []", 2000, 0., 2000); @@ -954,12 +962,16 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms() fuHistoryHistoSize, 0, fuHistoryHistoSize ); /// Add pointers to the vector with all histo for access by steering class + AddHistoToVector( fhDpbMap, sFolder ); AddHistoToVector( fhChannelMap, sFolder ); AddHistoToVector( fhHitMapEvo, sFolder ); AddHistoToVector( fhHitTotEvo, sFolder ); AddHistoToVector( fhChanHitMapEvo, sFolder ); for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) + { + AddHistoToVector( fvhDpbMapSpill[ uSpill ], sFolder ); AddHistoToVector( fvhChannelMapSpill[ uSpill ], sFolder ); + } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) AddHistoToVector( fhHitsPerSpill, sFolder ); AddHistoToVector( fhMsgCntEvo, sFolder ); @@ -1204,6 +1216,30 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms() AddCanvasToVector( fcSpillCountsHori, "canvases" ); /*******************************************************************/ + /*******************************************************************/ + /// General summary: Hit maps, Hit rate vs time in run, error fraction vs time un run + fcSpillDpbCountsHori = new TCanvas( "cSpillDpbCountsHori", "Counts in DPB per spill, last 5 spills including current one", w, h); + fcSpillDpbCountsHori->Divide( kuNbSpillPlots ); + + for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) + { + fcSpillDpbCountsHori->cd( 1 + uSpill ); + gPad->SetGridx(); + gPad->SetGridy(); + gPad->SetLogy(); + fvhDpbMapSpill[ uSpill ]->Draw(); + gPad->Update(); + TPaveStats* st = (TPaveStats *)fvhDpbMapSpill[ uSpill ]->FindObject( "stats" ); + st->SetOptStat( 110 ); + st->SetX1NDC( 0.25 ); + st->SetX2NDC( 0.95 ); + st->SetY1NDC( 0.90 ); + st->SetY2NDC( 0.95 ); + } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) + + AddCanvasToVector( fcSpillDpbCountsHori, "canvases" ); + /*******************************************************************/ + return kTRUE; } Bool_t CbmMcbm2018MonitorAlgoT0::FillHistograms() @@ -1253,7 +1289,7 @@ Bool_t CbmMcbm2018MonitorAlgoT0::FillHistograms() return kTRUE; } -Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms( Bool_t bResetTime ) +Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms( Bool_t bResetTime ) { for( UInt_t uChan = 0; uChan < kuNbChanDiamond; ++uChan ) { @@ -1278,10 +1314,14 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms( Bool_t bResetTime ) fuCurrentSpillIdx = 0; fuCurrentSpillPlot = 0; + fhDpbMap->Reset(); fhChannelMap->Reset(); fhHitMapEvo->Reset(); for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) + { + fvhDpbMapSpill[ uSpill ]->Reset(); fvhChannelMapSpill[ uSpill ]->Reset(); + } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++) fhHitsPerSpill->Reset(); fhMsgCntEvo->Reset(); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h index be5240a7da8a15858d76b18080095b11d69683eb..0a4be5baf4f829a1811d7ce158f4b7bf26d1b4ad 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h @@ -165,10 +165,12 @@ class CbmMcbm2018MonitorAlgoT0 : public CbmStar2019Algo<CbmTofDigi> static const UInt_t kuNbSpillPlots = 5; // UInt_t kuDiamChanMap[ kuNbChanDiamond ] = { 2, 3, 4, 5, 0, 1, 6, 7 }; //! Map from electronics channel to Diamond strip UInt_t fuDiamChanMap[ kuNbChanDiamond ] = { 0, 1, 2, 3, 4, 5, 6, 7 }; //! Map from electronics channel to Diamond strip + TH1 * fhDpbMap = nullptr; TH1 * fhChannelMap; TH2 * fhHitMapEvo; TH2 * fhHitTotEvo; TH2 * fhChanHitMapEvo; + std::vector< TH1 * > fvhDpbMapSpill = {}; std::vector< TH1 * > fvhChannelMapSpill; TH1 * fhHitsPerSpill; /// Global Rate @@ -196,6 +198,7 @@ class CbmMcbm2018MonitorAlgoT0 : public CbmStar2019Algo<CbmTofDigi> TCanvas * fcGenCntsPerMs; TCanvas * fcSpillCounts; TCanvas * fcSpillCountsHori; + TCanvas * fcSpillDpbCountsHori = nullptr; /* void ProcessEpochCycle( uint64_t ulCycleData ); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx index 77a45d89eb18526636521c4e14c420f0f0309d93..b6b3f5da850e821d002d7caa84dd9b7d30ae8db9 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx @@ -19,6 +19,7 @@ #include "FairRuntimeDb.h" #include "FairRunOnline.h" +#include "TProfile2D.h" #include "TROOT.h" #include "TList.h" #include "TString.h" @@ -101,6 +102,7 @@ CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof() : fhGdpbEpochMissEvo( nullptr ), fhGdpbEndMsBufferNotEmpty( nullptr ), fhGdpbEndMsDataLost( nullptr ), + fhGdpbHitRate( nullptr ), fvhGdpbGet4MessType(), fvhGdpbGet4ChanScm(), fvhGdpbGet4ChanErrors(), @@ -121,6 +123,7 @@ CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof() : fvhRemapTot_gDPB(), fvhRemapChCount_gDPB(), fvhRemapChRate_gDPB(), + fvhRemapChErrFract_gDPB(), fuNbMissmatchPattern(), fhNbMissPatternPerMs( nullptr ), fhPatternMissmatch( nullptr ), @@ -448,12 +451,13 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ProcessMs( const fles::Timeslice& ts, size_t u /// Save start time of first valid MS ) if( fdStartTime < 0 ) - fdStartTime = fdMsTime; + fdStartTime = ( fbUseAbsoluteTime ? 0.0 : fdMsTime ); /// Reset the histograms if reached the end of the evolution histos range else if( fuHistoryHistoSize < fdMsTime - fdStartTime ) { ResetEvolutionHistograms(); - fdStartTime = fdMsTime; + fdStartTime = ( fbUseAbsoluteTime ? fuHistoryHistoSize * static_cast< uint32_t >( fdMsTime / fuHistoryHistoSize ) : + fdMsTime); } // else if( fuHistoryHistoSize < fdMsTime - fdStartTime ) /* /// In Run rate evolution @@ -522,6 +526,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ProcessMs( const fles::Timeslice& ts, size_t u else { /// Histogramming + fhGdpbHitRate->Fill( fdMsTime - fdStartTime, fuCurrDpbIdx ); fhGet4MessType->Fill( fuGet4Nr, 0 ); fvhGdpbGet4MessType[ fuCurrDpbIdx ]->Fill( fuGet4Id, 0 ); @@ -822,6 +827,8 @@ void CbmMcbm2018MonitorAlgoTof::ProcessHit( gdpbv100::FullMessage mess ) if (0 <= fdStartTime) { fvhRemapChRate_gDPB[ fuCurrDpbIdx ]->Fill( 1e-9 * dHitTime - fdStartTime, uRemappedChannelNr ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( 1e-9 * dHitTime - fdStartTime, uRemappedChannelNr, 0 ); // fvhFeeRate_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime)); // fvhFeeErrorRatio_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime), 0, 1); } // if (0 <= fdStartTime) @@ -923,6 +930,14 @@ void CbmMcbm2018MonitorAlgoTof::ProcessError( gdpbv100::FullMessage mess ) } // if (0 <= fdStartTime) */ Int_t dGdpbChId = fuGet4Id * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId(); + UInt_t uChannelNrInFee = (fuGet4Id % fuNrOfGet4PerFee) * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId(); + UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee); +// UInt_t uFeeNrInSys = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr; + UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + fUnpackPar->Get4ChanToPadiChan( uChannelNrInFee ); + /// Diamond FEE have straight connection from Get4 to eLink and from PADI to GET4 + if( 0x90 == fuCurrentMsSysId ) + uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + uChannelNrInFee; + Int_t dFullChId = fuGet4Nr * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId(); switch( uErrorType ) @@ -1009,42 +1024,56 @@ void CbmMcbm2018MonitorAlgoTof::ProcessError( gdpbv100::FullMessage mess ) { fhGet4ChanErrors->Fill(dFullChId, 13); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 13 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT: case gdpbv100::GET4_V2X_ERR_TOT_RANGE: { fhGet4ChanErrors->Fill(dFullChId, 14); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 14 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_TOT_RANGE: case gdpbv100::GET4_V2X_ERR_EVT_DISCARD: { fhGet4ChanErrors->Fill(dFullChId, 15); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 15 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_EVT_DISCARD: case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG: { fhGet4ChanErrors->Fill(dFullChId, 16); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 16 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG: case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL: { fhGet4ChanErrors->Fill(dFullChId, 17); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 17 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL: case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER: { fhGet4ChanErrors->Fill(dFullChId, 18); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 18 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER: case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF: { fhGet4ChanErrors->Fill(dFullChId, 19); fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 19 ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 ); break; } // case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF: case gdpbv100::GET4_V2X_ERR_UNKNOWN: @@ -1506,6 +1535,10 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms() fuNrOfGdpbs, dGdpbMin, dGdpbMax, iNbBinsLog, dBinsLog ); + fhGdpbHitRate = new TH2D( "fhGdpbHitRate", "Hit rate per second and gDPB; Time[s]; gDPB #; HITS Nb", + fuHistoryHistoSize, 0, fuHistoryHistoSize, + fuNrOfGdpbs, dGdpbMin, dGdpbMax ); + if( kTRUE == fbDebugMonitorMode ) { fhNbMissPatternPerMs = new TH2I( "hNbMissPatternPerMs", @@ -1544,6 +1577,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms() AddHistoToVector( fhGdpbEpochMissEvo, sFolder ); AddHistoToVector( fhGdpbEndMsBufferNotEmpty, sFolder ); AddHistoToVector( fhGdpbEndMsDataLost, sFolder ); + AddHistoToVector( fhGdpbHitRate, sFolder ); /// Pattern Messages /// Pattern messages per gDPB if( kTRUE == fbDebugMonitorMode ) @@ -1647,6 +1681,13 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms() fuHistoryHistoSize, 0, fuHistoryHistoSize, fuNrOfFeePerGdpb * fuNrOfChannelsPerFee, 0, fuNrOfFeePerGdpb * fuNrOfChannelsPerFee ) ); + if( kTRUE == fbDebugMonitorMode ) + fvhRemapChErrFract_gDPB.push_back( new TProfile2D( + Form("RemapChErrFract_gDPB_%02u", uGdpbIndex), + Form("PADI channel error fraction gDPB %02u; Time in run [s]; PADI channel; Fraction []", uGdpbIndex), + 18000, 0, 180, + fuNrOfFeePerGdpb * fuNrOfChannelsPerFee, 0, fuNrOfFeePerGdpb * fuNrOfChannelsPerFee ) ); + /// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// if( kTRUE == fbDebugMonitorMode ) { @@ -1792,6 +1833,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms() AddHistoToVector( fvhRemapChRate_gDPB[ uGdpb ], sFolderGdpb ); if( kTRUE == fbDebugMonitorMode ) { + AddHistoToVector( fvhRemapChErrFract_gDPB[ uGdpb ], sFolderGdpb ); /// Per MS in gDPB AddHistoToVector( fvhGdpbPatternMissmatchEvo[ uGdpb ], sFolderGdpbPatt ); AddHistoToVector( fvhGdpbPatternEnableEvo[ uGdpb ], sFolderGdpbPatt ); @@ -2147,6 +2189,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ResetHistograms( Bool_t bResetTime ) fhGdpbEpochMissEvo ->Reset(); fhGdpbEndMsBufferNotEmpty->Reset(); fhGdpbEndMsDataLost ->Reset(); + fhGdpbHitRate ->Reset(); if( kTRUE == fbDebugMonitorMode ) { fhNbMissPatternPerMs->Reset(); @@ -2170,6 +2213,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ResetHistograms( Bool_t bResetTime ) fvhRemapChRate_gDPB[ uGdpb ] ->Reset(); if( kTRUE == fbDebugMonitorMode ) { + fvhRemapChErrFract_gDPB[ uGdpb ] ->Reset(); fvhGdpbPatternMissmatchEvo[ uGdpb ] ->Reset(); fvhGdpbPatternEnableEvo[ uGdpb ] ->Reset(); fvhGdpbPatternResyncEvo[ uGdpb ] ->Reset(); @@ -2218,6 +2262,7 @@ void CbmMcbm2018MonitorAlgoTof::ResetEvolutionHistograms() fvhRemapChRate_gDPB[ uGdpb ]->Reset(); if( kTRUE == fbDebugMonitorMode ) { + fvhRemapChErrFract_gDPB[ uGdpb ]->Reset(); // fvhGdpbPatternMissmatchEvo[ uGdpb ] ->Reset(); // fvhGdpbPatternEnableEvo[ uGdpb ] ->Reset(); // fvhGdpbPatternResyncEvo[ uGdpb ] ->Reset(); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h index 5b8c6e27496e043e4013275e4883fd827cda473a..5ca84c0372b4f00216640bea70d1e8571f92a12b 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h @@ -27,6 +27,7 @@ class CbmMcbm2018TofPar; class TH1; class TH2; class TProfile; +class TProfile2D; class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi> { @@ -62,12 +63,15 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi> inline void SetGdpbIndex( Int_t iGdpb = -1 ) { fiGdpbIndex = iGdpb; } + inline void UseAbsoluteTime( Bool_t bFlagIn = kTRUE) { fbUseAbsoluteTime = bFlagIn; } + private: /// Control flags Bool_t fbDebugMonitorMode; //! Switch ON the filling of a additional set of histograms Bool_t fbIgnoreCriticalErrors; //! If ON not printout at all for critical errors std::vector< Bool_t > fvbMaskedComponents; Int_t fiGdpbIndex; + Bool_t fbUseAbsoluteTime = kFALSE; //! Switch ON the usage of abolute time scale for the evo histo (no start time) /// Settings from parameter file CbmMcbm2018TofPar* fUnpackPar; //! @@ -161,6 +165,7 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi> TH2* fhGdpbEpochMissEvo; //! TH1* fhGdpbEndMsBufferNotEmpty; //! TH2* fhGdpbEndMsDataLost; //! + TH2* fhGdpbHitRate; //! /// Per GET4 in gDPB std::vector< TH2* > fvhGdpbGet4MessType; //! std::vector< TH2* > fvhGdpbGet4ChanScm; //! @@ -184,6 +189,7 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi> std::vector< TH2 * > fvhRemapTot_gDPB; //! std::vector< TH1 * > fvhRemapChCount_gDPB; //! std::vector< TH2 * > fvhRemapChRate_gDPB; //! + std::vector< TProfile2D * > fvhRemapChErrFract_gDPB; //! /// Pattern Messages /// Pattern messages per gDPB std::vector< UInt_t > fuNbMissmatchPattern; diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx index 2a30c98b4cacd042e28d53e55980c5cce3e5fb65..f2df917161f38d887a27f367ee09e88778668d6a 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx @@ -70,7 +70,7 @@ CbmMcbm2018MonitorMuchLite::CbmMcbm2018MonitorMuchLite() : fUnpackParMuch->GetNbChanPerAsic()(0), fuNbFebs(0), */ - fsHistoFileFullname( "data/SetupHistos.root" ), + fsHistoFileFullname( "data/HistosMonitorMuch.root" ), fbPrintMessages( kFALSE ), fPrintMessCtrl( stsxyter::MessagePrintMask::msg_print_Human ), fulCurrentTsIdx( 0 ), @@ -237,6 +237,10 @@ Bool_t CbmMcbm2018MonitorMuchLite::InitMuchParameters() } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb(); ++uCrobIdx ) } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb ) + if( fbBinningFw ) + LOG(info) << "Unpacking data in bin sorter FW mode"; + else LOG(info) << "Unpacking data in full time sorter FW mode (legacy)"; + // Internal status initialization fvulCurrentTsMsb.resize( fuNrOfDpbs ); fvuCurrentTsMsbCycle.resize( fuNrOfDpbs ); @@ -489,6 +493,12 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() title = "Rate in kHz with Adc cut"; fhRateAdcCut = new TH1I(sHistName, title, 10000, -0.5, 9999.5); + + sHistName = "hFEBcount"; + title = "Count vs FEB number; FEB Number; Count"; + fhFEBcount = new TH1I(sHistName, title, 40, -0.5, 39.5); + + sHistName = "hSysMessTypePerDpb"; title = "Nb of system message of each type for each DPB; DPB; System Type"; fhMuchSysMessTypePerDpb = new TH2I(sHistName, title, fuNrOfDpbs, 0, fuNrOfDpbs, 17, 0., 17.); @@ -579,6 +589,22 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() //fhMuchFebChanCntRawGood.push_back( new TH1I(sHistName, title, // fUnpackParMuch->GetNbChanPerFeb(), -0.5, fUnpackParMuch->GetNbChanPerFeb() - 0.5 ) ); + sHistName = Form( "fhMuchFebSpill_%03u", uFebIdx ); + title = Form( "Time distribution of hits, FEB #%03u; Time ; Counts ", uFebIdx ); + fhMuchFebSpill.push_back( new TH1I(sHistName, title, 1000,0,1000 ) ); + + + sHistName = Form( "hMuchChannelTime_FEB%03u", uFebIdx ); + title = Form( "Time vs Channel, FEB #%03u; TIME(s) ; CHANNEL ", uFebIdx ); + fhMuchChannelTime.push_back( new TH2I(sHistName, title, 1000,0,1000, 129, -0.5 , 128.5 ) ); + + + + sHistName = Form( "hMuchFebADC_%03u", uFebIdx ); + title = Form( "CHANNEL vs ADC, FEB #%03u; CHANNEL ; ADC ", uFebIdx ); + fhMuchFebADC.push_back( new TH2I(sHistName, title, 129,-0.5,128.5, 34, -0.5, 33.5 ) ); + + /// Raw Adc Distribution sHistName = Form( "hMuchFebChanAdcRaw_%03u", uFebIdx ); title = Form( "Raw Adc distribution per channel, FEB #%03u; Channel []; Adc []; Hits []", uFebIdx ); @@ -682,6 +708,10 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) +///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/// + fhDpbMsErrors = new TH2I( "fhDpbMsErrors", "; DPB []; Error type []; Counts []", + fuNrOfDpbs, 0, fuNrOfDpbs, + 4, -0.5, 3.5 ); ///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/// // Miscroslice properties histos @@ -697,18 +727,19 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() { for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId ) { - server->Register("/MuchRaw", fHistPadDistr[uModuleId] ); - server->Register("/MuchRaw", fRealHistPadDistr[uModuleId] ); - server->Register("/MuchFeb", fhMuchFebDuplicateHitProf[uModuleId] ); + // server->Register("/MuchRaw", fHistPadDistr[uModuleId] ); + // server->Register("/MuchRaw", fRealHistPadDistr[uModuleId] ); + // server->Register("/MuchFeb", fhMuchFebDuplicateHitProf[uModuleId] ); } - server->Register("/MuchRaw", fhRate ); - server->Register("/MuchRaw", fhRateAdcCut ); + // server->Register("/MuchRaw", fhRate ); + // server->Register("/MuchRaw", fhRateAdcCut ); + server->Register("/MuchRaw", fhFEBcount ); server->Register("/MuchRaw", fhMuchMessType ); - server->Register("/MuchRaw", fhMuchSysMessType ); + // server->Register("/MuchRaw", fhMuchSysMessType ); server->Register("/MuchRaw", fhMuchMessTypePerDpb ); server->Register("/MuchRaw", fhMuchSysMessTypePerDpb ); - server->Register("/MuchRaw", fhStatusMessType ); + // server->Register("/MuchRaw", fhStatusMessType ); server->Register("/MuchRaw", fhMsStatusFieldType ); server->Register("/MuchRaw", fhMuchHitsElinkPerDpb ); server->Register("/MuchRaw", fhMuchFebChanAdcRaw_combined ); @@ -717,19 +748,23 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) { server->Register("/MuchFeb", fhMuchFebChanCntRaw[ uFebIdx ] ); + server->Register( "/MuchFeb",fhMuchFebSpill[ uFebIdx ] ); + server->Register( "/MuchFeb",fhMuchFebADC[ uFebIdx ] ); + server->Register( "/MuchFeb",fhMuchChannelTime[ uFebIdx ] ); + //server->Register("/MuchFeb", fhMuchFebChanCntRawGood[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebChanAdcRaw[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebChanAdcRawProf[ uFebIdx ] ); + //// server->Register("/MuchFeb", fhMuchFebChanAdcRaw[ uFebIdx ] ); + // server->Register("/MuchFeb", fhMuchFebChanAdcRawProf[ uFebIdx ] ); //server->Register("/MuchFeb", fhMuchFebChanAdcCal[ uFebIdx ] ); //server->Register("/MuchFeb", fhMuchFebChanAdcCalProf[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebChanRawTs[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebChanHitRateEvo[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebChanHitRateProf[ uFebIdx ] ); + //// server->Register("/MuchFeb", fhMuchFebChanRawTs[ uFebIdx ] ); + //server->Register("/MuchFeb", fhMuchFebChanHitRateEvo[ uFebIdx ] ); + // server->Register("/MuchFeb", fhMuchFebChanHitRateProf[ uFebIdx ] ); //server->Register("/MuchFeb", fhMuchFebAsicHitRateEvo[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebHitRateEvo[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ] ); - server->Register("/MuchFeb", fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ] ); + // server->Register("/MuchFeb", fhMuchFebHitRateEvo[ uFebIdx ] ); + //// server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch[ uFebIdx ] ); + // server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ] ); + // server->Register("/MuchFeb", fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ] ); LOG(debug)<< "Initialized fhMuchFebHitRateEvo_WithoutDupli number "<< uFebIdx; /*server->Register("/MuchFeb", fhMuchFebChanHitRateEvoLong[ uFebIdx ] ); server->Register("/MuchFeb", fhMuchFebAsicHitRateEvoLong[ uFebIdx ] ); @@ -737,6 +772,7 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() server->Register("/MuchFeb", fhMuchFebChanDistT[ uFebIdx ] );*/ } // if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) + server->Register("/MuchRaw", fhDpbMsErrors ); } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) LOG(debug)<< "Initialized FEB 8th Histo"; @@ -753,56 +789,79 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() Double_t w = 10; Double_t h = 10; LOG(debug)<< "Initialized 7th Histo before Summary per FEB"; + + TCanvas* cChannel = new TCanvas( Form("CHANNELS"), + Form("CHANNELS") ); //, +// w, h); + cChannel->Divide( 4, 9 ); // Summary per FEB for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) { if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) { - TCanvas* cMuchSumm = new TCanvas( Form("cMuchSum_%03u", uFebIdx ), - Form("Summary plots for FEB %03u", uFebIdx ), - w, h); - cMuchSumm->Divide( 2, 2 ); - - cMuchSumm->cd(1); - gPad->SetGridx(); - gPad->SetGridy(); + cChannel->cd(uFebIdx+1); + //// gPad->SetGridx(); + // gPad->SetGridy(); gPad->SetLogy(); fhMuchFebChanCntRaw[ uFebIdx ]->Draw(); - cMuchSumm->cd(2); - gPad->SetGridx(); - gPad->SetGridy(); - gPad->SetLogy(); - fhMuchFebChanHitRateProf[ uFebIdx ]->Draw( "e0" ); - - cMuchSumm->cd(3); - gPad->SetGridx(); - gPad->SetGridy(); - gPad->SetLogz(); - fhMuchFebChanAdcRaw[ uFebIdx ]->Draw( "colz" ); - - cMuchSumm->cd(4); - gPad->SetGridx(); - gPad->SetGridy(); - // gPad->SetLogy(); - fhMuchFebChanAdcRawProf[ uFebIdx ]->Draw(); - - /*cMuchSumm->cd(5); - gPad->SetGridx(); - gPad->SetGridy(); - gPad->SetLogz(); - //fhMuchFebChanAdcCal[ uFebIdx ]->Draw( "colz" ); - - cMuchSumm->cd(6); - gPad->SetGridx(); - gPad->SetGridy(); - // gPad->SetLogy(); - //fhMuchFebChanAdcCalProf[ uFebIdx ]->Draw();*/ - } // if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) + server->Register("/canvases", cChannel); + //All Feb hit rate together on one Canvas + + TCanvas* cspill = new TCanvas( Form("SPILLS"),Form("SPILLS") ); //,w, h); + cspill->Divide( 4, 9 ); + + for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) + { + if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) + { + UInt_t flPad = 1+ uFebIdx; + cspill->cd(flPad); + //gPad->SetGridx(); + //gPad->SetGridy(); + // gPad->SetLogy(); + fhMuchFebSpill[ uFebIdx ]->Draw(); + } + // server->Register("/canvases", cspill); + } + server->Register("/canvases", cspill); + + TCanvas* cadc = new TCanvas( Form("ADC"),Form("ADC"),w, h); + cadc->Divide( 4, 9 ); + + for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) + { + if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) + { + UInt_t flPad = 1+ uFebIdx; + cadc->cd(flPad); + //gPad->SetGridx(); + //gPad->SetGridy(); + //gPad->SetLogy(); + fhMuchFebADC[ uFebIdx ]->Draw("colz"); + } + } + server->Register("/canvases", cadc); + + TCanvas* cChanneltime = new TCanvas( Form("ChannelvsTime"),Form("ChannelvsTime"),w, h); + cChanneltime->Divide( 4, 9 ); + for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) + { + if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) + { + UInt_t flPad = 1+ uFebIdx; + cChanneltime->cd(flPad); + //gPad->SetGridx(); + //gPad->SetGridy(); + //gPad->SetLogy(); + fhMuchChannelTime[ uFebIdx ]->Draw("colz"); + } + } + server->Register("/canvases", cChanneltime); //====================================================================// LOG(debug)<< "Initialized Last Histo before exiting CreateHistograms"; //====================================================================// @@ -812,9 +871,10 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms() fcMsSizeAll = dynamic_cast<TCanvas *>( gROOT->FindObject( "cMsSizeAll" ) ); if( NULL == fcMsSizeAll ) { - fcMsSizeAll = new TCanvas("cMsSizeAll", "Evolution of MS size in last 300 s", w, h); - fcMsSizeAll->Divide( 4, 4 ); + fcMsSizeAll = new TCanvas("cMsSizeAll", "Evolution of MS size in last 300 s"); //, w, h); + fcMsSizeAll->Divide( 1, 8 ); LOG(info) << "Created MS size canvas in Much monitor"; + server->Register("/canvases",fcMsSizeAll); } // if( NULL == fcMsSizeAll ) else LOG(info) << "Recovered MS size canvas in Much monitor"; //====================================================================// @@ -951,6 +1011,15 @@ Bool_t CbmMcbm2018MonitorMuchLite::DoUnpack(const fles::Timeslice& ts, size_t co * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx]) + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBins ) * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] ); + + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + dTsMsbTime = + static_cast<ULong64_t>( stsxyter::kuHitNbTsBinsBinning ) + * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx]) + + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBinsBinning ) + * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] ) + ; dTsMsbTime *= stsxyter::kdClockCycleNs * 1e-9; LOG(info) << "End of TS " << std::setw(7) << ts.index() @@ -1083,6 +1152,13 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz UInt_t uTsMsbCycleHeader = std::floor( fulCurrentMsIdx / ( stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs ) ) - fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ]; + + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + uTsMsbCycleHeader = std::floor( fulCurrentMsIdx / + ( stsxyter::kulTsCycleNbBinsBinning * stsxyter::kdClockCycleNs ) ) + - fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ]; + if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] ) { fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ] = uTsMsbCycleHeader; @@ -1132,8 +1208,8 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz */ stsxyter::MessType typeMess = mess.GetMessType(); fmMsgCounter[ typeMess ] ++; - fhMuchMessType->Fill( static_cast< uint16_t > (typeMess) ); - fhMuchMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) ); + // fhMuchMessType->Fill( static_cast< uint16_t > (typeMess) ); + // fhMuchMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) ); switch( typeMess ) { @@ -1141,6 +1217,10 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz { // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific! UShort_t usElinkIdx = mess.GetLinkIndex(); + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + usElinkIdx = mess.GetLinkIndexHitBinning(); + UInt_t uCrobIdx = usElinkIdx / fUnpackParMuch->GetNbElinkPerCrob(); Int_t uFebIdx = fUnpackParMuch->ElinkIdxToFebIdx( usElinkIdx ); // if(usElinkIdx!=0) @@ -1190,7 +1270,7 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz UShort_t usStatusField = mess.GetStatusStatus(); - fhStatusMessType->Fill( uAsicIdx, usStatusField ); + // fhStatusMessType->Fill( uAsicIdx, usStatusField ); /// Always print status messages... or not? if( fbPrintMessages ) { @@ -1205,6 +1285,14 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz // FillTsMsbInfo( mess ); break; } // case stsxyter::MessType::Empty : + case stsxyter::MessType::EndOfMs : + { + if( mess.IsMsErrorFlagOn() ) + { + fhDpbMsErrors->Fill( fuCurrDpbIdx, mess.GetMsErrorType() ); + } // if( pMess[uIdx].IsMsErrorFlagOn() ) + break; + } // case stsxyter::MessType::EndOfMs : case stsxyter::MessType::Dummy : { break; @@ -1232,12 +1320,17 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho //Below FebID is according to FEB Position in Module GEM A or Module GEM B (Carefully write MUCH Par file) Int_t FebId = fUnpackParMuch->GetFebId(uAsicIdx); + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + usRawTs = mess.GetHitTimeBinning(); + // UInt_t uFebIdx = uAsicIdx / fUnpackParMuch->GetNbAsicsPerFeb(); //For MUCH each FEB has one StsXyter UInt_t uFebIdx = uAsicIdx; // UInt_t uCrobIdx = usElinkIdx / fUnpackParMuch->GetNbElinkPerCrob(); // UInt_t uAsicInFeb = uAsicIdx % fUnpackParMuch->GetNbAsicsPerFeb(); UInt_t uChanInFeb = usChan + fUnpackParMuch->GetNbChanPerAsic() * (uAsicIdx % fUnpackParMuch->GetNbAsicsPerFeb()); + Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx); Int_t sector = fUnpackParMuch->GetPadXA(FebId, usChan); Int_t channel = fUnpackParMuch->GetPadYA(FebId, usChan); @@ -1251,26 +1344,27 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho ActualX = 1000-ActualX; channel = 96 - channel; - Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx); - LOG(debug)<< "Module Nr " << ModuleNr << " Sector Nr "<< sector <<" Channel Nr "<<channel << "Actual X "<< ActualX << "Actual Y " <<ActualY << "uAsicIdx "<<uAsicIdx; - fHistPadDistr[ModuleNr]->Fill(sector, channel); - fRealHistPadDistr[ModuleNr]->Fill(ActualY, ActualX); +// fHistPadDistr[ModuleNr]->Fill(sector, channel); +// fRealHistPadDistr[ModuleNr]->Fill(ActualY, ActualX); //Double_t dCalAdc = fvdFebAdcOffs[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ] // + (usRawAdc - 1)* fvdFebAdcGain[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ]; - + fhFEBcount->Fill(uFebIdx); +// fhMuchFebSpill[uFebIdx] ->Fill(usRawTs); fhMuchFebChanCntRaw[ uFebIdx ]->Fill( uChanInFeb ); - fhMuchFebChanAdcRaw[ uFebIdx ]->Fill( uChanInFeb, usRawAdc ); - fhMuchFebChanAdcRawProf[ uFebIdx ]->Fill( uChanInFeb, usRawAdc ); +// fhMuchFebChanAdcRaw[ uFebIdx ]->Fill( uChanInFeb, usRawAdc ); + // fhMuchFebChanAdcRawProf[ uFebIdx ]->Fill( uChanInFeb, usRawAdc ); //fhMuchFebChanAdcCal[ uFebIdx ]->Fill( uChanInFeb, dCalAdc ); //fhMuchFebChanAdcCalProf[ uFebIdx ]->Fill( uChanInFeb, dCalAdc ); - fhMuchFebChanRawTs[ uFebIdx ]->Fill( usChan, usRawTs ); + // fhMuchFebChanRawTs[ uFebIdx ]->Fill( usChan, usRawTs ); //fhMuchFebChanMissEvt[ uFebIdx ]->Fill( usChan, mess.IsHitMissedEvts() ); - fhMuchFebChanAdcRaw_combined->Fill(usRawAdc); + // fhMuchFebChanAdcRaw_combined->Fill(usRawAdc); + + fhMuchFebADC[uFebIdx]->Fill(usChan,usRawAdc); // Compute the Full time stamp ULong64_t ulOldHitTime = fvulChanLastHitTime[ uAsicIdx ][ usChan ]; // Long64_t dOldHitTime = fvdChanLastHitTime[ uAsicIdx ][ usChan ]; @@ -1285,6 +1379,15 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] ) ; + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + fvulChanLastHitTime[ uAsicIdx ][ usChan ] = usRawTs + + static_cast<ULong64_t>( stsxyter::kuHitNbTsBinsBinning ) + * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx]) + + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBinsBinning ) + * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] ) + ; + // Convert the Hit time in bins to Hit time in ns Long64_t dHitTimeNs = fvulChanLastHitTime[ uAsicIdx ][ usChan ] * stsxyter::kdClockCycleNs; @@ -1293,10 +1396,11 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho fvdChanLastHitTime[ uAsicIdx ][ usChan ] = fvulChanLastHitTime[ uAsicIdx ][ usChan ] * stsxyter::kdClockCycleNs; // For StsXyter2.0 Duplicate Hit Error //Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx); +/* fhMuchFebDuplicateHitProf[ModuleNr]->Fill(FebId,0); if( ulOldHitTime == fvulChanLastHitTime[uAsicIdx][usChan] ) fhMuchFebDuplicateHitProf[ModuleNr]->Fill(FebId,1); - +*/ /* LOG(info) << " Asic " << std::setw( 2 ) << uAsicIdx @@ -1330,8 +1434,8 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho } else { - fhRate->Fill(Counter); - fhRateAdcCut->Fill(Counter1); + //fhRate->Fill(Counter); + // fhRateAdcCut->Fill(Counter1); Counter=0; Counter1=0; prevtime_new = fvdChanLastHitTime[ uAsicIdx ][ usChan ]; @@ -1345,15 +1449,19 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho fviFebCountsSinceLastRateUpdate[uFebIdx]++; fvdFebChanCountsSinceLastRateUpdate[uFebIdx][uChanInFeb] += 1; - fhMuchFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb ); + // fhMuchFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb ); //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb ); - fhMuchFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec ); - fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Fill( dTimeSinceStartSec ); - if(usRawAdc>1)fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Fill( dTimeSinceStartSec ); + // fhMuchFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec ); + // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Fill( dTimeSinceStartSec ); + // if(usRawAdc>1)fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Fill( dTimeSinceStartSec ); //fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uChanInFeb, 1.0/60.0 ); //fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uAsicInFeb, 1.0/60.0 ); //fhMuchFebHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, 1.0/60.0 ); + fhMuchFebSpill[uFebIdx] ->Fill(dTimeSinceStartSec); + fhMuchFebChanCntRaw[ uFebIdx ]->Fill( usChan ); + fhMuchChannelTime[uFebIdx]->Fill(dTimeSinceStartSec,usChan); + /* if( mess.IsHitMissedEvts() ) { @@ -1369,7 +1477,7 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho } else { - fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Fill( dTimeSinceStartSec ); + // fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Fill( dTimeSinceStartSec ); } prevTime = fvdChanLastHitTime[ uAsicIdx ][ usChan ]; prevChan = usChan; @@ -1379,6 +1487,10 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho void CbmMcbm2018MonitorMuchLite::FillTsMsbInfo( stsxyter::Message mess, UInt_t /*uMessIdx*/, UInt_t /*uMsIdx*/ ) { UInt_t uVal = mess.GetTsMsbVal(); + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + uVal = mess.GetTsMsbValBinning(); + // Update Status counters if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] ) { @@ -1442,20 +1554,22 @@ void CbmMcbm2018MonitorMuchLite::SaveAllHistos( TString sFileName ) for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId ) { - fHistPadDistr[uModuleId]->Write(); - fRealHistPadDistr[uModuleId]->Write(); - fhMuchFebDuplicateHitProf[uModuleId]->Write(); + // fHistPadDistr[uModuleId]->Write(); + // fRealHistPadDistr[uModuleId]->Write(); + // fhMuchFebDuplicateHitProf[uModuleId]->Write(); } - fhRate->Write(); - fhRateAdcCut->Write(); - fhMuchMessType->Write(); - fhMuchSysMessType->Write(); - fhMuchMessTypePerDpb->Write(); - fhMuchSysMessTypePerDpb->Write(); - fhStatusMessType->Write(); + // fhRate->Write(); + // fhRateAdcCut->Write(); + fhFEBcount->Write(); +// fhMuchMessType->Write(); + // fhMuchSysMessType->Write(); +// fhMuchMessTypePerDpb->Write(); + // fhMuchSysMessTypePerDpb->Write(); + // fhStatusMessType->Write(); fhMsStatusFieldType->Write(); fhMuchHitsElinkPerDpb->Write(); - fhMuchFebChanAdcRaw_combined->Write(); + // fhMuchFebChanAdcRaw_combined->Write(); + fhDpbMsErrors->Write(); gDirectory->cd(".."); /***************************/ @@ -1467,18 +1581,21 @@ void CbmMcbm2018MonitorMuchLite::SaveAllHistos( TString sFileName ) if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) { fhMuchFebChanCntRaw[ uFebIdx ]->Write(); + fhMuchFebSpill[ uFebIdx ]->Write(); + fhMuchChannelTime[ uFebIdx ]->Write(); + fhMuchFebADC[ uFebIdx ]->Write(); //fhMuchFebChanCntRawGood[ uFebIdx ]->Write(); - fhMuchFebChanAdcRaw[ uFebIdx ]->Write(); - fhMuchFebChanAdcRawProf[ uFebIdx ]->Write(); + // fhMuchFebChanAdcRaw[ uFebIdx ]->Write(); + // fhMuchFebChanAdcRawProf[ uFebIdx ]->Write(); //fhMuchFebChanAdcCal[ uFebIdx ]->Write(); //fhMuchFebChanAdcCalProf[ uFebIdx ]->Write(); - fhMuchFebChanRawTs[ uFebIdx ]->Write(); - fhMuchFebChanHitRateProf[ uFebIdx ]->Write(); + // fhMuchFebChanRawTs[ uFebIdx ]->Write(); + // fhMuchFebChanHitRateProf[ uFebIdx ]->Write(); //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Write(); - fhMuchFebHitRateEvo[ uFebIdx ]->Write(); - fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Write(); - fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Write(); - fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Write(); + // fhMuchFebHitRateEvo[ uFebIdx ]->Write(); + // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Write(); + // fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Write(); + // fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Write(); /*fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Write(); fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Write(); fhMuchFebHitRateEvoLong[ uFebIdx ]->Write(); @@ -1525,39 +1642,44 @@ void CbmMcbm2018MonitorMuchLite::ResetAllHistos() for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId ) { - fHistPadDistr[uModuleId]->Reset(); - fRealHistPadDistr[uModuleId]->Reset(); + //fHistPadDistr[uModuleId]->Reset(); + //fRealHistPadDistr[uModuleId]->Reset(); fhMuchFebDuplicateHitProf[uModuleId]->Reset(); } - fhRate->Reset(); - fhRateAdcCut->Reset(); - fhMuchMessType->Reset(); - fhMuchSysMessType->Reset(); - fhMuchMessTypePerDpb->Reset(); - fhMuchSysMessTypePerDpb->Reset(); - fhStatusMessType->Reset(); + // fhRate->Reset(); + // fhRateAdcCut->Reset(); + fhFEBcount->Reset(); + // fhMuchMessType->Reset(); + // fhMuchSysMessType->Reset(); + // fhMuchMessTypePerDpb->Reset(); + // fhMuchSysMessTypePerDpb->Reset(); + // fhStatusMessType->Reset(); fhMsStatusFieldType->Reset(); fhMuchHitsElinkPerDpb->Reset(); - fhMuchFebChanAdcRaw_combined->Reset(); + // fhMuchFebChanAdcRaw_combined->Reset(); + fhDpbMsErrors->Reset(); for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) { if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) ) { fhMuchFebChanCntRaw[ uFebIdx ]->Reset(); + fhMuchFebSpill[ uFebIdx ] ->Reset(); + fhMuchChannelTime[ uFebIdx ]->Reset(); + fhMuchFebADC[ uFebIdx ] ->Reset(); //fhMuchFebChanCntRawGood[ uFebIdx ]->Reset(); - fhMuchFebChanAdcRaw[ uFebIdx ]->Reset(); - fhMuchFebChanAdcRawProf[ uFebIdx ]->Reset(); + //// fhMuchFebChanAdcRaw[ uFebIdx ]->Reset(); + //fhMuchFebChanAdcRawProf[ uFebIdx ]->Reset(); //fhMuchFebChanAdcCal[ uFebIdx ]->Reset(); //fhMuchFebChanAdcCalProf[ uFebIdx ]->Reset(); - fhMuchFebChanRawTs[ uFebIdx ]->Reset(); - fhMuchFebChanHitRateEvo[ uFebIdx ]->Reset(); - fhMuchFebChanHitRateProf[ uFebIdx ]->Reset(); + ////fhMuchFebChanRawTs[ uFebIdx ]->Reset(); + // fhMuchFebChanHitRateEvo[ uFebIdx ]->Reset(); + // fhMuchFebChanHitRateProf[ uFebIdx ]->Reset(); //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Reset(); - fhMuchFebHitRateEvo[ uFebIdx ]->Reset(); - fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Reset(); - fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Reset(); - fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Reset(); + //// fhMuchFebHitRateEvo[ uFebIdx ]->Reset(); + // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Reset(); + // fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Reset(); + // fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Reset(); /*fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Reset(); fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Reset(); fhMuchFebHitRateEvoLong[ uFebIdx ]->Reset(); diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h index 3fc9768e151e07beb48cb4f014a751969587a194..1de2cc170eaf9556106c8d77c5f52a701b7ca200 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h @@ -80,11 +80,18 @@ public: // void SetTimeBin( size_t uTimeBin ); void UseDaqBuffer(Bool_t) {}; //Virtual function in Mother Class, Need to update accordingly. VS + + /// => Quick and dirty hack for binning FW!!! + void SetBinningFwFlag( Bool_t bEnable = kTRUE ) { fbBinningFw = bEnable; } + private: // Parameters // Control flags Bool_t fbMuchMode; std::vector< Bool_t > fvbMaskedComponents; + /// => Quick and dirty hack for binning FW!!! + Bool_t fbBinningFw = kFALSE; + // FLES containers std::vector< size_t > fvMsComponentsList; //! size_t fuNbCoreMsPerTs; //! @@ -185,6 +192,7 @@ private: TH1* fhRate; TH1* fhRateAdcCut; + TH1* fhFEBcount = nullptr; // std::vector<TH1 *> fhMuchFebChanRateEvo; /// Plots per FEB-8 @@ -195,12 +203,15 @@ private: //Double_t fdFebChanCoincidenceLimit; // ns std::vector<TH1 *> fhMuchFebChanCntRaw; + std::vector<TH1 *> fhMuchFebSpill = {}; + std::vector<TH2 *> fhMuchFebADC = {}; //std::vector<TH1 *> fhMuchFebChanCntRawGood; std::vector<TH2 *> fhMuchFebChanAdcRaw; std::vector<TProfile*> fhMuchFebChanAdcRawProf; //std::vector<TH2 *> fhMuchFebChanAdcCal; //std::vector<TProfile*> fhMuchFebChanAdcCalProf; std::vector<TH2*> fhMuchFebChanRawTs; + std::vector<TH2*> fhMuchChannelTime = {}; //std::vector<TH2*> fhMuchFebChanMissEvt; //std::vector<TH2*> fhMuchFebChanMissEvtEvo; //std::vector<TH2*> fhMuchFebAsicMissEvtEvo; @@ -221,6 +232,9 @@ private: //std::vector< std::vector<TH2*> > fhMuchFebChanCoinc; std::vector<TProfile*> fhMuchFebDuplicateHitProf; + /// Binning FW error flag + TH2* fhDpbMsErrors = nullptr; + TCanvas* fcMsSizeAll; TH1* fhMsSz[kiMaxNbFlibLinks]; TProfile* fhMsSzTime[kiMaxNbFlibLinks]; diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx index 718217709a515a4888a3d7c303b454c4ad685d38..0d21f4164d76150963043c1c3a4fb4bf483b6b25 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx @@ -353,6 +353,10 @@ Bool_t CbmMcbm2018MonitorSts::InitStsParameters() } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParSts->GetNbCrobsPerDpb(); ++uCrobIdx ) } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb ) + if( fbBinningFw ) + LOG(info) << "Unpacking data in bin sorter FW mode"; + else LOG(info) << "Unpacking data in full time sorter FW mode (legacy)"; + // Internal status initialization fvulCurrentTsMsb.resize( fuNrOfDpbs ); fvuCurrentTsMsbCycle.resize( fuNrOfDpbs ); @@ -971,6 +975,10 @@ void CbmMcbm2018MonitorSts::CreateHistograms() } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) } // if( kTRUE == fbEnableCheckBugSmx20 ) ///------------------------------------------------------------------/// + + fhMsErrorsEvo = new TH2I( "fhMsErrorsEvo", "; MS index [s]; Error type []; Counts []", + 600, 0.0, 600.0, + 4, -0.5, 3.5 ); ///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/// // Miscroslice properties histos @@ -1039,6 +1047,8 @@ void CbmMcbm2018MonitorSts::CreateHistograms() } // if( kTRUE == fbEnableCheckBugSmx20 ) } // if( kTRUE == fUnpackParSts->IsFebActive( uFebIdx ) ) } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx ) + + server->Register("/StsRaw", fhMsErrorsEvo ); /* for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++ uModIdx ) { @@ -1893,8 +1903,23 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] ) { fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ] = uTsMsbCycleHeader; + fvulCurrentTsMsb[fuCurrDpbIdx] = 0; fvuInitialHeaderDone[ fuCurrDpbIdx ] = kTRUE; } // if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] ) + else if( 0 == uMsIdx ) + { + if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] ) + LOG(info) << " TS " << std::setw( 12 ) << fulCurrentTsIdx + << " MS " << std::setw( 12 ) << fulCurrentMsIdx + << " MS Idx " << std::setw( 4 ) << uMsIdx + << " Msg Idx " << std::setw( 5 ) << 0 + << " DPB " << std::setw( 2 ) << fuCurrDpbIdx + << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx] + << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx] + << " New MsbCy " << uTsMsbCycleHeader; + fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader; + fvulCurrentTsMsb[fuCurrDpbIdx] = 0; + } // if( 0 == uMsIdx ) else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] && 4194303 != fvulCurrentTsMsb[fuCurrDpbIdx] ) { @@ -1906,6 +1931,30 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM << " VS " << uTsMsbCycleHeader; fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader; } + else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] ) + { + if( 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx] ) + { + LOG(info) << " TS " << std::setw( 12 ) << fulCurrentTsIdx + << " MS " << std::setw( 12 ) << fulCurrentMsIdx + << " MS Idx " << std::setw( 4 ) << uMsIdx + << " Msg Idx " << std::setw( 5 ) << 0 + << " DPB " << std::setw( 2 ) << fuCurrDpbIdx + << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx] + << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx] + << " New MsbCy " << uTsMsbCycleHeader; + } + else + { + LOG(warning) << "TS MSB cycle from MS header does not match current cycle from data " + << "for TS " << std::setw( 12 ) << fulCurrentTsIdx + << " MS " << std::setw( 12 ) << fulCurrentMsIdx + << " MsInTs " << std::setw( 3 ) << uMsIdx + << " ====> " << fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] + << " (cnt) VS " << uTsMsbCycleHeader << " (header)"; + } // else of if( 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx] ) + fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader; + } // else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] ) // If not integer number of message in input buffer, print warning/error if( 0 != ( uSize % kuBytesPerMessage ) ) @@ -1947,6 +1996,10 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM { // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific! UShort_t usElinkIdx = mess.GetLinkIndex(); + /// => Quick and dirty hack for binning FW!!! + if( kTRUE == fbBinningFw ) + usElinkIdx = mess.GetLinkIndexHitBinning(); + fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackParSts->GetNbElinkPerDpb() + usElinkIdx, static_cast< uint16_t > (typeMess) ); fhStsHitsElinkPerDpb->Fill( fuCurrDpbIdx, usElinkIdx ); @@ -2031,6 +2084,20 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM // FillTsMsbInfo( mess ); break; } // case stsxyter::MessType::Empty : + case stsxyter::MessType::EndOfMs : + { +// ++vNbMessType[5]; +// sMessPatt += " En"; +// bError = pMess[uIdx].IsMsErrorFlagOn(); + +// fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) ); +// FillTsMsbInfo( pMess[uIdx] ); + if( mess.IsMsErrorFlagOn() ) + { + fhMsErrorsEvo->Fill( 1e-9 * fulCurrentMsIdx, mess.GetMsErrorType() ); + } // if( pMess[uIdx].IsMsErrorFlagOn() ) + break; + } // case stsxyter::MessType::EndOfMs : case stsxyter::MessType::Dummy : { fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackParSts->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) ); @@ -2269,7 +2336,11 @@ void CbmMcbm2018MonitorSts::FillTsMsbInfo( stsxyter::Message mess, UInt_t uMessI } // if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] ) if( uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1 && 0 != uVal && 4194303 != fvulCurrentTsMsb[fuCurrDpbIdx] && - 1 != uMessIdx ) + 1 != uMessIdx && /// First TS_MSB in MS may jump if TS dropped by DAQ + !( 0 == uVal && 0 == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx ) && /// case with cycle et edge of 2 MS + !( uVal == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx ) && /// Msg 1 and 2 will be same TS_MSB if data in 1st bin + uVal < fvulCurrentTsMsb[fuCurrDpbIdx] /// New FW introduced TS_MSB suppression + large TS_MSB => warning only if value not increasing + ) { LOG(info) << "TS MSb Jump in " << " TS " << std::setw( 12 ) << fulCurrentTsIdx diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h index 91d96e6ccff90a8e99847edcccbdf5ef97eeead4..e0ef8878165c256d06ba7154ea977dfb21aab2a2 100644 --- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h +++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h @@ -264,6 +264,9 @@ private: std::vector< TProfile *> fhStsFebSmxErrRatioCopySameAdcEvo; std::vector< TProfile2D *> fhStsFebSmxErrRatioCopySameAdcEvoAsic; + /// Binning FW error flag + TH2* fhMsErrorsEvo = nullptr; + /// Canvases std::vector< TCanvas * > fvcStsSumm; std::vector< TCanvas * > fvcStsSmxErr; diff --git a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx index d6a10c0f5d5a51a5be3fef31e0602bc1a62068d2..2cff87afd2b6729d89ad06da05f979b8661df091 100644 --- a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx +++ b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx @@ -30,9 +30,6 @@ CbmMcbm2018PsdPar::CbmMcbm2018PsdPar(const char* name, fiNbMsTot(0), fiNbMsOverlap(0), fdSizeMsInNs(0.0), - fdStarTriggerDeadtime(), - fdStarTriggerDelay(), - fdStarTriggerWinSize(), fdTsDeadtimePeriod(0.0) { detName="Psd"; @@ -71,9 +68,6 @@ void CbmMcbm2018PsdPar::putParams(FairParamList* l) l->add("NbMsTot", fiNbMsTot); l->add("NbMsOverlap", fiNbMsOverlap); l->add("SizeMsInNs", fdSizeMsInNs); - l->add("StarTriggerDeadtime", fdStarTriggerDeadtime); - l->add("StarTriggerDelay", fdStarTriggerDelay); - l->add("StarTriggerWinSize", fdStarTriggerWinSize); l->add("TsDeadtimePeriod", fdTsDeadtimePeriod); } @@ -103,12 +97,6 @@ Bool_t CbmMcbm2018PsdPar::getParams(FairParamList* l) { if ( ! l->fill("NbMsOverlap", &fiNbMsOverlap) ) return kFALSE; if ( ! l->fill("SizeMsInNs", &fdSizeMsInNs) ) return kFALSE; - fdStarTriggerDeadtime.Set(fiNrOfGdpb); - fdStarTriggerDelay.Set(fiNrOfGdpb); - fdStarTriggerWinSize.Set(fiNrOfGdpb); - if ( ! l->fill("StarTriggerDeadtime", &fdStarTriggerDeadtime) ) return kFALSE; - if ( ! l->fill("StarTriggerDelay", &fdStarTriggerDelay) ) return kFALSE; - if ( ! l->fill("StarTriggerWinSize", &fdStarTriggerWinSize) ) return kFALSE; if ( ! l->fill("TsDeadtimePeriod", &fdTsDeadtimePeriod) ) return kFALSE; return kTRUE; diff --git a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h index 5c5d1f74297b328f3f83b140d708406dd2728012..cc336d8ae5ed4fd247688bd3254b5d6777ead044 100644 --- a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h +++ b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h @@ -63,9 +63,6 @@ class CbmMcbm2018PsdPar : public FairParGenericSet inline Int_t GetNbMsOverlap() { return fiNbMsOverlap;} inline Double_t GetSizeMsInNs() { return fdSizeMsInNs;} - Double_t GetStarTriggDeadtime( UInt_t uGdpb ); - Double_t GetStarTriggDelay( UInt_t uGdpb ); - Double_t GetStarTriggWinSize( UInt_t uGdpb ); Double_t GetTsDeadtimePeriod();// { return fdTsDeadtimePeriod;} @@ -101,9 +98,6 @@ class CbmMcbm2018PsdPar : public FairParGenericSet Int_t fiNbMsOverlap; // Number of overlap MS per TS Double_t fdSizeMsInNs; // Size of the MS in ns, needed for MS border detection - TArrayD fdStarTriggerDeadtime; // STAR: Array to hold for each gDPB the deadtime between triggers in ns - TArrayD fdStarTriggerDelay; // STAR: Array to hold for each gDPB the Delay in ns to subtract when looking for beginning of coincidence of data with trigger window - TArrayD fdStarTriggerWinSize; // STAR: Array to hold for each gDPB the Size of the trigger window in ns Double_t fdTsDeadtimePeriod; // Period (ns) in the first MS of each TS where events with missing triggers should be built using the overlap MS of previous TS (overlap events) ClassDef(CbmMcbm2018PsdPar,1);