CbmTofUnpackMonitorPulser.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer]  */
 
#include "CbmTofUnpackMonitorPulser.h"
 
#include "CbmFlesHistosTools.h"
#include "CriGet4Mess001.h"
#include "MicrosliceDescriptor.hpp"
 
#include <FairRunOnline.h>
#include <Logger.h>
 
#include <RtypesCore.h>
#include <TCanvas.h>
#include <TF1.h>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
#include <THttpServer.h>
#include <TMath.h>
#include <TPaveStats.h>
#include <TProfile.h>
#include <TROOT.h>
 
CbmTofUnpackMonitorPulser::CbmTofUnpackMonitorPulser() : CbmTofUnpackMonitor()
{
  // Disabled all special modes of the base class to prevent their usage
  CbmTofUnpackMonitor::SetBmonMode(false);
  CbmTofUnpackMonitor::SetBmonMicroSpillMode(false);
  CbmTofUnpackMonitor::SetBmonScvdMode(false);
  CbmTofUnpackMonitor::SetBmonQFactorMode(false);
  CbmTofUnpackMonitor::SetTofQFactorMode(false);
}
 
CbmTofUnpackMonitorPulser::~CbmTofUnpackMonitorPulser() {}

Bool_t CbmTofUnpackMonitorPulser::Init(CbmMcbm2018TofPar* digiParSet)
{
  // Get Infos from the parset
  fUnpackPar = digiParSet;
 
  fuNbOfComps = fUnpackPar->GetNrOfGdpbs();
  // FIXME: Start using again the parameter class accessors once a new CRI oriented class is brought into use
  fuNbOfGet4PerComp     = 80;
  fuNbOfChannelsPerGet4 = 4;
  fuNbOfChannelsPerComp = fuNbOfGet4PerComp * fuNbOfChannelsPerGet4;
  fuNbOfGet4InSyst      = fuNbOfComps * fuNbOfGet4PerComp;
  fuNbOfChannelsPerFee  = fuNbOfGet4PerFee * fuNbOfChannelsPerGet4;

  fvuFeeNbHitsLastMs.resize(fuNbOfFeePerComp * fuNbOfComps, 0);
  fdTsLastPulserHit.resize(fuNbOfFeePerComp * fuNbOfComps, 0.0);

  TFile* oldFile     = gFile;
  TDirectory* oldDir = gDirectory;
  gROOT->cd();

  CreateHistograms();
  DrawCanvases();

  gFile      = oldFile;
  gDirectory = oldDir;

  std::vector<std::pair<TNamed*, std::string>> vHistos = GetHistoVector();

  std::vector<std::pair<TCanvas*, std::string>> vCanvases = GetCanvasVector();

  std::string sSystem = "tof";
  if (fBmonMode || fBmonMicroSpillMode || fBmonQfactorsMode) {
    //
    sSystem = "bmon";
  }
 
  if (fbInternalHttp) {
    THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
    if (nullptr != server) {
      for (UInt_t uCanvas = 0; uCanvas < vCanvases.size(); ++uCanvas) {
        server->Register(Form("/%s/%s", sSystem.data(), vCanvases[uCanvas].second.data()), vCanvases[uCanvas].first);
      }
      for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
        server->Register(Form("/%s/%s", sSystem.data(), vHistos[uHisto].second.data()), vHistos[uHisto].first);
      }
      /*
      server->RegisterCommand(Form("/Reset_%s_Hist", sSystem.data()), "bMcbm2018UnpackerTaskStsResetHistos=kTRUE");
      server->Restrict("/Reset_UnpSts_Hist", "allow=admin");
      */
    }
  }
 
  return kTRUE;
}
 
Bool_t CbmTofUnpackMonitorPulser::CreateHistograms()
{
  std::string sSystem = "tof";
 
  // Full Fee time difference test
  UInt_t uNbBinsDt = kuNbBinsDt + 1;  // To account for extra bin due to shift by 1/2 bin of both ranges
 
  fuNbFeePlotsPerComp = fuNbOfFeePerComp / fuNbFeePlot + (0 != fuNbOfFeePerComp % fuNbFeePlot ? 1 : 0);
  dMinDt              = -1. * (kuNbBinsDt * critof001::kdBinSize / 2.) - critof001::kdBinSize / 2.;
  dMaxDt              = 1. * (kuNbBinsDt * critof001::kdBinSize / 2.) + critof001::kdBinSize / 2.;
 
  /*******************************************************************/
  // clang-format off
  fhGet4MessType = new TH2I(Form("%sGet4MessType", sSystem.data()),
                            "Nb of message for each type per GET4; GET4 chip # ; Type",
                            fuNbOfGet4InSyst, 0., fuNbOfGet4InSyst,
                            4, 0., 4.);
  fhGet4MessType->GetYaxis()->SetBinLabel(1, "DATA 32b");
  fhGet4MessType->GetYaxis()->SetBinLabel(2, "EPOCH");
  fhGet4MessType->GetYaxis()->SetBinLabel(3, "S.C.M");
  fhGet4MessType->GetYaxis()->SetBinLabel(4, "ERROR");

  fvhTimeDiffPulser.resize(fuNbOfFeePerComp * fuNbOfComps);
  for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; uFeeA++) {
    fvhTimeDiffPulser[uFeeA].resize(fuNbOfFeePerComp * fuNbOfComps);
    for (UInt_t uFeeB = 0; uFeeB < fuNbOfFeePerComp * fuNbOfComps; uFeeB++) {
      if (uFeeA < uFeeB) {
        UInt_t uCompA  = uFeeA / (fuNbOfFeePerComp);
        UInt_t uFeeIdA = uFeeA - (fuNbOfFeePerComp * uCompA);
        UInt_t uCompB  = uFeeB / (fuNbOfFeePerComp);
        UInt_t uFeeIdB = uFeeB - (fuNbOfFeePerComp * uCompB);
        fvhTimeDiffPulser[uFeeA][uFeeB] =
          new TH1I(Form("hTimeDiffPulser_g%02u_f%1u_g%02u_f%1u", uCompA, uFeeIdA, uCompB, uFeeIdB),
                   Form("Time difference for pulser on gDPB %02u FEE %1u and gDPB %02u FEE %1u; DeltaT [ps]; Counts",
                        uCompA, uFeeIdA, uCompB, uFeeIdB),
                   uNbBinsDt, dMinDt, dMaxDt);
      }  // if( uFeeA < uFeeB )
      else
        fvhTimeDiffPulser[uFeeA][uFeeB] = nullptr;
    }  // for( UInt_t uFeeB = uFeeA; uFeeB < fuNbOfFeePerComp * fuNbOfComps - 1; uFeeB++)
  }    // for( UInt_t uFeeA = 0; uFeeA < kuNbChanTest - 1; uFeeA++)
 
  fhTimeMeanPulser = new TH2D("hTimeMeanPulser",
                              "Time difference Mean for each FEE pairs; FEE A; FEE B ; Mean [ps]",
                              fuNbOfFeePerComp * fuNbOfComps - 1, -0.5, fuNbOfFeePerComp * fuNbOfComps - 1.5,
                              fuNbOfFeePerComp * fuNbOfComps - 1,  0.5, fuNbOfFeePerComp * fuNbOfComps - 0.5);
 
  fhTimeRmsPulser = new TH2D("hTimeRmsPulser",
                             "Time difference RMS for each FEE pairs; FEE A; FEE B ; RMS [ps]",
                             fuNbOfFeePerComp * fuNbOfComps - 1, -0.5, fuNbOfFeePerComp * fuNbOfComps - 1.5,
                             fuNbOfFeePerComp * fuNbOfComps - 1,  0.5, fuNbOfFeePerComp * fuNbOfComps - 0.5);
 
  fhTimeRmsZoomFitPuls = new TH2D("hTimeRmsZoomFitPuls",
                                  "Time difference RMS after zoom for each FEE pairs; FEE A; FEE B ; RMS [ps]",
                                  fuNbOfFeePerComp * fuNbOfComps - 1, -0.5, fuNbOfFeePerComp * fuNbOfComps - 1.5,
                                  fuNbOfFeePerComp * fuNbOfComps - 1, 0.5, fuNbOfFeePerComp * fuNbOfComps - 0.5);
 
  fhTimeResFitPuls = new TH2D("hTimeResFitPuls",
                              "Time difference Res from fit for each FEE pairs; FEE A; FEE B ; Sigma [ps]",
                              fuNbOfFeePerComp * fuNbOfComps - 1, -0.5, fuNbOfFeePerComp * fuNbOfComps - 1.5,
                              fuNbOfFeePerComp * fuNbOfComps - 1,  0.5, fuNbOfFeePerComp * fuNbOfComps - 0.5);
 
  /*
   FIXME: only one GBTx per comp in CRI design!
  fvhPulserTimeDiffEvoGbtxGbtx.resize(fuNbOfComps * (kuNbGbtxPerComp - 1));
  */
  fvvhPulserTimeDiffEvoCompComp.resize(fuNbOfComps);
  for (UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp) {
    fvhPulserCountEvoPerFeeComp.push_back(new TH2D(Form("hPulserCountEvoPerFeeComp%02u", uComp),
                                                   Form("Pulser count per FEE in gDPB %02u; time in run [s]; dt [ps]",
                                                        uComp),
                                                   fuHistoryHistoSize, 0, fuHistoryHistoSize,
                                                   fuNbOfFeePerComp, -0.5, fuNbOfFeePerComp));
 
    /*
     FIXME: only one GBTx per comp in CRI design!
    for (UInt_t uGbtx = 0; uGbtx < kuNbGbtxPerComp - 1; ++uGbtx) {
      fvhPulserTimeDiffEvoGbtxGbtx[uComp * (kuNbGbtxPerComp - 1) + uGbtx] =
        new TProfile(Form("hPulserTimeDiffEvoComp%02uGbtx00Gbtx%02u", uComp, uGbtx + 1),
                     Form("Time difference of the 1st FEE in the 1st GBTx of gDPB %02u vs GBTx %02u; time in run [s];"
                          " dt [ps]", uComp, uGbtx + 1),
                     fuHistoryHistoSize, 0, fuHistoryHistoSize);
    }  // for( UInt_t uGbtx = 0; uGbtx < kuNbGbtxPerComp; ++uGbtx )
    */
 
    fvvhPulserTimeDiffEvoCompComp[uComp].resize(fuNbOfComps, nullptr);
    for (UInt_t uCompB = uComp + 1; uCompB < fuNbOfComps; ++uCompB) {
      fvvhPulserTimeDiffEvoCompComp[uComp][uCompB] =
        new TProfile(Form("hPulserTimeDiffEvoComp%02uComp%02u", uComp, uCompB),
                     Form("Time difference of the 1st FEE in the 1st GBTx of gDPB %02u vs %02u; time in run [s];"
                          " dt [ps]", uComp, uCompB),
                     fuHistoryHistoSize,  0, fuHistoryHistoSize);
    }  // for( UInt_t uCompB = uComp + 1; uCompB < fuNbOfComps; ++uCompB )
  }    // for( UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp )
 
  fvvhPulserTimeDiffEvoFeeFee.resize(kuNbRefFeeEvo);
  for (UInt_t uFeeRef = 0; uFeeRef < kuNbRefFeeEvo; ++uFeeRef) {
    UInt_t uCompRef  = kuRefFeeEvoIdx[uFeeRef] / (fuNbOfFeePerComp);
    UInt_t uFeeIdRef = kuRefFeeEvoIdx[uFeeRef] - (fuNbOfFeePerComp * uCompRef);
 
    fvvhPulserTimeDiffEvoFeeFee[uFeeRef].resize(fuNbOfFeePerComp * fuNbOfComps);
    for (UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++) {
      UInt_t uComp  = uFee / (fuNbOfFeePerComp);
      UInt_t uFeeId = uFee - (fuNbOfFeePerComp * uComp);
 
      fvvhPulserTimeDiffEvoFeeFee[uFeeRef][uFee] =
        new TProfile(Form("hTimeDiffEvoFeeFee_g%02u_f%02u_g%02u_f%02u", uCompRef, uFeeIdRef, uComp, uFeeId),
                     Form("Time difference for pulser on gDPB %02u FEE %1u and gDPB %02u FEE %02u; time in run [s]"
                          "; DeltaT [ps]", uCompRef, uFeeIdRef, uComp, uFeeId),
                     fuHistoryHistoSize / 2, 0, fuHistoryHistoSize);
    }  // for( UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++)
  }    // for( UInt_t uFeeRef = 0; uFeeRef < kuNbRefFeeEvo; ++uFeeRef )
 
   fhFeeFtDistribPerCh.resize( fuNbOfFeePerComp * fuNbOfComps );
   fhFeeFtNormDnl.resize( fuNbOfFeePerComp * fuNbOfComps );
   fhFeeFtNormInl.resize( fuNbOfFeePerComp * fuNbOfComps );
   for( UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++)
   {
      UInt_t uComp  = uFee / ( fuNbOfFeePerComp );
      UInt_t uFeeId = uFee - ( fuNbOfFeePerComp * uComp );
      fhFeeFtDistribPerCh[ uFee ] = new TH2D(
            Form( "hFeeFtDistribPerCh_g%02u_f%02u", uComp, uFeeId ),
            Form( "FT distribution per channel for gDPB %02u FEE %02u", uComp, uFeeId ),
            critof001::kdFtBinsNb, 0, critof001::kdFtBinsNb,
            fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5 );
      fhFeeFtNormDnl[ uFee ] = new TH2D(
            Form( "hFeeFtNormDnl_g%02u_f%02u", uComp, uFeeId ),
            Form( "Normalized DNL per channel for gDPB %02u FEE %02u", uComp, uFeeId ),
            critof001::kdFtBinsNb, 0, critof001::kdFtBinsNb,
            fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5 );
      fhFeeFtNormInl[ uFee ] = new TH2D(
            Form( "hFeeFtNormInl_g%02u_f%02u", uComp, uFeeId ),
            Form( "Normalized INL per channel for gDPB %02u FEE %02u", uComp, uFeeId ),
            critof001::kdFtBinsNb, 0, critof001::kdFtBinsNb,
            fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5 );
   } // for( UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++)

  // clang-format on

  std::string sFolder = "TofDt";
  AddHistoToVector(fhGet4MessType, sFolder);
 
  for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; uFeeA++) {
    for (UInt_t uFeeB = 0; uFeeB < fuNbOfFeePerComp * fuNbOfComps; uFeeB++) {
      if (nullptr != fvhTimeDiffPulser[uFeeA][uFeeB]) {
        AddHistoToVector(fvhTimeDiffPulser[uFeeA][uFeeB], sFolder);
      }
    }
  }
 
  sFolder = "TofRaw";
  AddHistoToVector(fhTimeMeanPulser, sFolder);
  AddHistoToVector(fhTimeRmsPulser, sFolder);
  AddHistoToVector(fhTimeRmsZoomFitPuls, sFolder);
  AddHistoToVector(fhTimeResFitPuls, sFolder);
 
  sFolder = "TofDtEvo";
  for (UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp) {
    AddHistoToVector(fvhPulserCountEvoPerFeeComp[uComp], sFolder);
 
    /*
     FIXME: only one GBTx per comp in CRI design!
    for (UInt_t uGbtx = 0; uGbtx < kuNbGbtxPerComp - 1; ++uGbtx) {
      if (nullptr != fvhPulserTimeDiffEvoGbtxGbtx[uComp * (kuNbGbtxPerComp - 1) + uGbtx]) {
        AddHistoToVector(fvhPulserTimeDiffEvoGbtxGbtx[uComp * (kuNbGbtxPerComp - 1) + uGbtx], sFolder);
      }
    }
    */
 
    for (UInt_t uCompB = uComp + 1; uCompB < fuNbOfComps; ++uCompB) {
      if (nullptr != fvvhPulserTimeDiffEvoCompComp[uComp][uCompB]) {
        AddHistoToVector(fvvhPulserTimeDiffEvoCompComp[uComp][uCompB], sFolder);
      }
    }
  }  // for( UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp )
 
  sFolder = "DnlInl";
  for (UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++) {
    AddHistoToVector(fhFeeFtDistribPerCh[uFee], sFolder);
    AddHistoToVector(fhFeeFtNormDnl[uFee], sFolder);
    AddHistoToVector(fhFeeFtNormInl[uFee], sFolder);
  }  // for( UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; uFee++)
 
  return kTRUE;
}
 
void CbmTofUnpackMonitorPulser::DrawCanvases()
{
  std::string sSystem = "tof";

  fcSummaryGet4s =
    new TCanvas(Form("c%sSummaryGet4s", sSystem.data()), Form("GET4s message stats, %s", sSystem.data()));
  fcSummaryGet4s->Divide(3, 2);
 
  fcSummaryGet4s->cd(1);
  gPad->SetGridx();
  gPad->SetGridy();
  gPad->SetLogz();
  fhGet4MessType->Draw("colz");
 
  std::string sFolder = "canvases";
  AddCanvasToVector(fcSummaryGet4s, sFolder);
 
  /*****************************/
  fcPulser = new TCanvas("cPulser", "Time difference RMS for pulser channels when FEE pulser mode is ON");
  fcPulser->Divide(2, 2);
 
  fcPulser->cd(1);
  gPad->SetGridx();
  gPad->SetGridy();
  fhTimeRmsPulser->Draw("colz");
 
  fcPulser->cd(2);
  gPad->SetGridx();
  gPad->SetGridy();
  fhTimeMeanPulser->Draw("colz");
 
  fcPulser->cd(3);
  gPad->SetGridx();
  gPad->SetGridy();
  fhTimeRmsZoomFitPuls->Draw("colz");
 
  fcPulser->cd(4);
  gPad->SetGridx();
  gPad->SetGridy();
  fhTimeResFitPuls->Draw("colz");
 
  AddCanvasToVector(fcPulser, sFolder);
  /*****************************/

  fcPulserEvo = new TCanvas("cPulserEvo", "Time difference evolution between 1st FEE of 1st GBTx of Comp pairs");
  fcPulserEvo->Divide(1, fuNbOfComps - 1);
  for (UInt_t uComp = 0; uComp < fuNbOfComps - 1; uComp++) {
    fcPulserEvo->cd(1 + uComp);
    gPad->SetGridx();
    gPad->SetGridy();
    if (nullptr != fvvhPulserTimeDiffEvoCompComp[uComp][uComp + 1]) {
      fvvhPulserTimeDiffEvoCompComp[uComp][uComp + 1]->Draw();
    }
  }  // for( UInt_t uComp = 0; uComp < fuNbOfComps - 1; uComp ++)
 
  AddCanvasToVector(fcPulserEvo, sFolder);
  /*****************************/

  /*
     FIXME: only one GBTx per comp in CRI design!
  for (UInt_t uComp = 0; uComp < fuNbOfComps; uComp++) {
    fcPulserEvoGbtx.push_back(
      new TCanvas(Form("cPulserEvoGbtx%02u", uComp),
                  Form("Time difference evolution between 1st FEE of GBTx pairs in Comp %02u", uComp)));
    fcPulserEvoGbtx[uComp]->Divide(1, kuNbGbtxPerComp - 1);
 
    for (UInt_t uGbtx = 0; uGbtx < kuNbGbtxPerComp - 1; ++uGbtx) {
      fcPulserEvoGbtx[uComp]->cd(1 + uGbtx);
      gPad->SetGridx();
      gPad->SetGridy();
 
      if (nullptr != fvhPulserTimeDiffEvoGbtxGbtx[uComp * (kuNbGbtxPerComp - 1) + uGbtx]) {
        fvhPulserTimeDiffEvoGbtxGbtx[uComp * (kuNbGbtxPerComp - 1) + uGbtx]->Draw();
      }
    }  // for( UInt_t uGbtx = 0; uGbtx < kuNbGbtxPerComp - 1; ++uGbtx )
    AddCanvasToVector(fcPulserEvoGbtx[uComp], sFolder);
  }  // for( UInt_t uComp = 0; uComp < fuNbOfComps; uComp ++)
  */
  /*****************************/
}
 
Bool_t CbmTofUnpackMonitorPulser::ResetHistograms()
{
  fhGet4MessType->Reset();
 
  return kTRUE;
}

void CbmTofUnpackMonitorPulser::Finish()
{
  UpdateZoomedFit();

  UpdateNormedDnlInl();

  CbmTofUnpackMonitor::Finish();
}

void CbmTofUnpackMonitorPulser::FillHitMonitoringHistos(const double_t& dMsTime, const uint32_t& uCurrCompIdx,
                                                        const uint32_t& uGet4Id, const uint32_t& uRawCh,
                                                        const uint32_t& /*uRemapCh*/, const uint32_t& uTot,
                                                        const double_t& dHitTime, const uint32_t& uFts, bool bDiamond)
{
  if (-1 == fdStartTime) {
    fdStartTime = dMsTime;
  }
  uint32_t uGet4InSys = uGet4Id + uCurrCompIdx * fuNbOfGet4PerComp;
  fhGet4MessType->Fill(uGet4InSys, 0);
 
  //UInt_t uChannelNrInFee = (uGet4Id % fuNbOfGet4PerFee) * fuNbOfChannelsPerGet4 + uRawCh;
  UInt_t uChannelNrInFee = uRawCh % (fuNbOfGet4PerFee * fuNbOfChannelsPerGet4);
  UInt_t uFeeNr          = (uGet4Id / fuNbOfGet4PerFee);
  UInt_t uFeeNrInSys     = uCurrCompIdx * fuNbOfFeePerComp + uFeeNr;

  fhFeeFtDistribPerCh[uFeeNrInSys]->Fill(uFts, uChannelNrInFee);

  if (fuMinTotPulser < uTot && uTot < fuMaxTotPulser) {
    /*
    LOG(info) << "CbmTofUnpackMonitorPulser::FillHitMonitoringHistos => Pulser hit "
              << Form( "%3u %2u %3u %3u %1u",  uTot, uCurrCompIdx, uGet4Id, uRawCh, bDiamond);
    LOG(info) << "                                                   => "
              << Form( "%3u %3u", uFeeNrInSys, uChannelNrInFee);
    */
    if (bDiamond) {
      if (critof001::kuFeePulserChannelDiam == uChannelNrInFee) {
        fdTsLastPulserHit[uFeeNrInSys] = dHitTime;
        fvuFeeNbHitsLastMs[uFeeNrInSys]++;
        fvhPulserCountEvoPerFeeComp[uCurrCompIdx]->Fill(dHitTime * 1e-9, uFeeNr);
      }  // if (critof001::kuFeePulserChannel == uChannelNrInFee) {
    }    // if (bDiamond) {
    else {
      if (critof001::kuFeePulserChannel == uChannelNrInFee) {
        fdTsLastPulserHit[uFeeNrInSys] = dHitTime;
        fvuFeeNbHitsLastMs[uFeeNrInSys]++;
        fvhPulserCountEvoPerFeeComp[uCurrCompIdx]->Fill(dHitTime * 1e-9, uFeeNr);
      }  // if (critof001::kuFeePulserChannel == uChannelNrInFee) {
    }    // else of if (bDiamond) {
  }      // if( fuMinTotPulser < uTot && uTot < fuMaxTotPulser )
}

void CbmTofUnpackMonitorPulser::FinalizeMsHistos()
{
  for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; ++uFeeA) {
    if (1 != fvuFeeNbHitsLastMs[uFeeA]) {
      fvuFeeNbHitsLastMs[uFeeA] = 0;
      continue;
    }  // if( 1 != fvuFeeNbHitsLastMs[ uFeeA ] )
 
    UInt_t uCompNr = uFeeA / fuNbOfFeePerComp;
    UInt_t uGbtxNr = (uFeeA % fuNbOfFeePerComp) / kuNbFeePerGbtx;
 
    UInt_t uFeeRefIndexA = kuNbRefFeeEvo;
    for (UInt_t uFeeRef = 0; uFeeRef < kuNbRefFeeEvo; ++uFeeRef)
      if (kuRefFeeEvoIdx[uFeeRef] == uFeeA) uFeeRefIndexA = uFeeRef;

    for (UInt_t uFeeB = uFeeA + 1; uFeeB < fuNbOfFeePerComp * fuNbOfComps; ++uFeeB) {
      if (1 != fvuFeeNbHitsLastMs[uFeeB]) continue;
 
      if (nullptr != fvhTimeDiffPulser[uFeeA][uFeeB]) {
        UInt_t uFeeRefIndexB = kuNbRefFeeEvo;
        for (UInt_t uFeeRef = 0; uFeeRef < kuNbRefFeeEvo; ++uFeeRef)
          if (kuRefFeeEvoIdx[uFeeRef] == uFeeB) uFeeRefIndexB = uFeeRef;
 
        Double_t dTimeDiff = 1e3 * (fdTsLastPulserHit[uFeeB] - fdTsLastPulserHit[uFeeA]);
        if (TMath::Abs(dTimeDiff) < kdMaxDtPulserPs) {
          fvhTimeDiffPulser[uFeeA][uFeeB]->Fill(dTimeDiff);
 
          if (uFeeRefIndexA < kuNbRefFeeEvo)
            fvvhPulserTimeDiffEvoFeeFee[uFeeRefIndexA][uFeeB]->Fill(1e-9 * (fdTsLastPulserHit[uFeeA] - fdStartTime),
                                                                    dTimeDiff);
 
          if (uFeeRefIndexB < kuNbRefFeeEvo)
            fvvhPulserTimeDiffEvoFeeFee[uFeeRefIndexB][uFeeA]->Fill(1e-9 * (fdTsLastPulserHit[uFeeB] - fdStartTime),
                                                                    -1.0 * dTimeDiff);

          if (0 == uFeeA % kuNbFeePerGbtx && 0 == uFeeB % kuNbFeePerGbtx) {
            UInt_t uCompNrB = uFeeB / fuNbOfFeePerComp;
            UInt_t uGbtxNrB = (uFeeB % fuNbOfFeePerComp) / kuNbFeePerGbtx;

            if (uCompNr == uCompNrB) {
              /*
               FIXME: only one GBTx per comp in CRI design!
              if (0 == uGbtxNr) {
                UInt_t uPlotIdx = uCompNr * (kuNbGbtxPerComp - 1) + uGbtxNrB - 1;
                fvhPulserTimeDiffEvoGbtxGbtx[uPlotIdx]->Fill(1e-9 * (fdTsLastPulserHit[uFeeA] - fdStartTime),
                                                             dTimeDiff);
              }   // if( 0 == uGbtxNr  )
              */
            }     // if( uCompNr == uFeeB / fuNbOfFeePerComp )
            else  // if (uCompNr == uCompNrB)
            {
              if (0 == uGbtxNr && 0 == uGbtxNrB)
                fvvhPulserTimeDiffEvoCompComp[uCompNr][uFeeB / fuNbOfFeePerComp]->Fill(
                  1e-9 * (fdTsLastPulserHit[uFeeA] - fdStartTime), dTimeDiff);
            }  // else of if( uCompNr == uFeeB / fuNbOfFeePerComp )
          }    // if( 0 == uFeeA % kuNbFeePerGbtx && 0 == uFeeB % kuNbFeePerGbtx )
        }      // if( TMath::Abs( dTimeDiff ) < kdMaxDtPulserPs )
      }        // if( nullptr != fvhTimeDiffPulser[uFeeA][uFeeB] )
    }          // for( UInt_t uFeeB = uFeeA + 1; uFeeB < fuNbOfFeePerComp * fuNbOfComps; ++uFeeB)

    fvuFeeNbHitsLastMs[uFeeA] = 0;
  }  // for( UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; ++uFeeA)
}

void CbmTofUnpackMonitorPulser::FinalizeTsHistos(double_t dTsStartTime)
{
  // Update RMS plots only every 10s in data
  if (10.0 < dTsStartTime * 1e-9 - fdLastRmsUpdateTime) {
    LOG(info) << "CbmTofUnpackMonitorPulser::FinalizeTsHistos => Update pulser statistics ";
    // Reset summary histograms for safety
    fhTimeMeanPulser->Reset();
    fhTimeRmsPulser->Reset();
 
    for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; uFeeA++)
      for (UInt_t uFeeB = 0; uFeeB < fuNbOfFeePerComp * fuNbOfComps; uFeeB++)
        if (nullptr != fvhTimeDiffPulser[uFeeA][uFeeB]) {
          fhTimeMeanPulser->Fill(uFeeA, uFeeB, fvhTimeDiffPulser[uFeeA][uFeeB]->GetMean());
          fhTimeRmsPulser->Fill(uFeeA, uFeeB, fvhTimeDiffPulser[uFeeA][uFeeB]->GetRMS());
        }  // for( UInt_t uChan = 0; uChan < kuNbChanTest - 1; uChan++)
    fdLastRmsUpdateTime = dTsStartTime * 1e-9;
    fuNbRmsUpdates++;
 
    // Update zoomed plots only every 60s as no http UI commands in this version of monitor
    if (6 == fuNbRmsUpdates) {  //
      UpdateZoomedFit();
      UpdateNormedDnlInl();
 
      fuNbRmsUpdates = 0;
    }  // if (6 == fuNbRmsUpdates)
  }    // if( 10.0 < dTsStartTime - fdLastRmsUpdateTime )
}
 
void CbmTofUnpackMonitorPulser::UpdateZoomedFit()
{
  // Only do something is the user defined the width he want for the zoom
  if (0.0 < fdFitZoomWidthPs) {
    // Reset summary histograms for safety
    fhTimeRmsZoomFitPuls->Reset();
    fhTimeResFitPuls->Reset();
 
    Double_t dRes = 0;
    TF1* fitFuncPairs[fuNbOfFeePerComp * fuNbOfComps][fuNbOfFeePerComp * fuNbOfComps];
 
    for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; uFeeA++)
      for (UInt_t uFeeB = 0; uFeeB < fuNbOfFeePerComp * fuNbOfComps; uFeeB++)
        if (nullptr != fvhTimeDiffPulser[uFeeA][uFeeB]) {
          // Check that we have at least 1 entry
          if (0 == fvhTimeDiffPulser[uFeeA][uFeeB]->GetEntries()) {
            fhTimeRmsZoomFitPuls->Fill(uFeeA, uFeeB, 0.0);
            fhTimeResFitPuls->Fill(uFeeA, uFeeB, 0.0);
            LOG(debug) << "CbmTofUnpackMonitorPulser::UpdateZoomedFit => Empty input "
                       << "for FEE pair " << uFeeA << " and " << uFeeB << " !!! ";
            continue;
          }  // if( 0 == fvhTimeDiffPulser[uFeeA][uFeeB]->GetEntries() )
 
          // Read the peak position (bin with max counts) + total nb of entries
          Int_t iBinWithMax  = fvhTimeDiffPulser[uFeeA][uFeeB]->GetMaximumBin();
          Double_t dNbCounts = fvhTimeDiffPulser[uFeeA][uFeeB]->Integral();
 
          // Zoom the X axis to +/- ZoomWidth around the peak position
          Double_t dPeakPos = fvhTimeDiffPulser[uFeeA][uFeeB]->GetXaxis()->GetBinCenter(iBinWithMax);
          fvhTimeDiffPulser[uFeeA][uFeeB]->GetXaxis()->SetRangeUser(dPeakPos - fdFitZoomWidthPs,
                                                                    dPeakPos + fdFitZoomWidthPs);
 
          // Read integral and check how much we lost due to the zoom (% loss allowed)
          Double_t dZoomCounts = fvhTimeDiffPulser[uFeeA][uFeeB]->Integral();
          if ((dZoomCounts / dNbCounts) < 0.99) {
            fhTimeRmsZoomFitPuls->Fill(uFeeA, uFeeB, 0.0);
            fhTimeResFitPuls->Fill(uFeeA, uFeeB, 0.0);
            LOG(warning) << "CbmTofUnpackMonitorPulser::UpdateZoomedFit => Zoom too strong, "
                         << "more than 1% loss for FEE pair " << uFeeA << " and " << uFeeB << " !!! ";
            continue;
          }  // if( ( dZoomCounts / dNbCounts ) < 0.99 )
 
          // Fill new RMS after zoom into summary histo
          fhTimeRmsZoomFitPuls->Fill(uFeeA, uFeeB, fvhTimeDiffPulser[uFeeA][uFeeB]->GetRMS());
 
 
          // Fit using zoomed boundaries + starting gaussian width, store into summary histo
          dRes                       = 0;
          fitFuncPairs[uFeeA][uFeeB] = new TF1(Form("fPair_%02d_%02d", uFeeA, uFeeB), "gaus",
                                               dPeakPos - fdFitZoomWidthPs, dPeakPos + fdFitZoomWidthPs);
          // Fix the Mean fit value around the Histogram Mean
          fitFuncPairs[uFeeA][uFeeB]->SetParameter(0, dZoomCounts);
          fitFuncPairs[uFeeA][uFeeB]->SetParameter(1, dPeakPos);
          fitFuncPairs[uFeeA][uFeeB]->SetParameter(2, 200.0);  // Hardcode start with ~4*BinWidth, do better later
          // Using integral instead of bin center seems to lead to unrealistic values => no "I"
          fvhTimeDiffPulser[uFeeA][uFeeB]->Fit(Form("fPair_%02d_%02d", uFeeA, uFeeB), "QRM0");
          // Get Sigma
          dRes = fitFuncPairs[uFeeA][uFeeB]->GetParameter(2);
          // Cleanup memory
          delete fitFuncPairs[uFeeA][uFeeB];
          // Fill summary
          fhTimeResFitPuls->Fill(uFeeA, uFeeB, dRes / TMath::Sqrt2());
 
 
          LOG(info) << "CbmTofUnpackMonitorPulser::UpdateZoomedFit => "
                    << "For FEE pair " << uFeeA << " and " << uFeeB
                    << " we have zoomed RMS = " << fvhTimeDiffPulser[uFeeA][uFeeB]->GetRMS() << " and a resolution of "
                    << dRes / TMath::Sqrt2();
 
          // Restore original axis state?
          fvhTimeDiffPulser[uFeeA][uFeeB]->GetXaxis()->UnZoom();
        }  // loop on uFeeA and uFeeB + check if corresponding fvhTimeDiffPulser exists
  }        // if( 0.0 < fdFitZoomWidthPs )
  else {
    LOG(error) << "CbmTofUnpackMonitorPulser::UpdateZoomedFit => Zoom width not defined, "
               << "please use SetFitZoomWidthPs, e.g. in macro, before trying this update !!!";
  }  // else of if( 0.0 < fdFitZoomWidthPs )
}
 
void CbmTofUnpackMonitorPulser::UpdateNormedDnlInl()
{
  TDirectory* oldDir = gDirectory;
 
  gROOT->cd();
  TF1* constantVal = new TF1("constant", "1", 0, critof001::kdFtBinsNb);
  for (UInt_t uFeeNrInSys = 0; uFeeNrInSys < fuNbOfFeePerComp * fuNbOfComps; uFeeNrInSys++) {
    fhFeeFtNormDnl[uFeeNrInSys]->Reset();
    fhFeeFtNormInl[uFeeNrInSys]->Reset();
 
    for (UInt_t uChannel = 0; uChannel < fuNbOfChannelsPerFee; uChannel++) {
      // Rising edge
      TH1* pFtSelChSlice =
        fhFeeFtDistribPerCh[uFeeNrInSys]->ProjectionX("temp_pFtSelChSlice", 1 + uChannel, 1 + uChannel);
      if (0 < pFtSelChSlice->GetEntries()) {
        Double_t dNormFactRise = pFtSelChSlice->GetEntries() / critof001::kdFtBinsNb;
        pFtSelChSlice->Scale(1.0 / dNormFactRise);
        pFtSelChSlice->Add(constantVal, -1.);
      }  // if( 0 < pFtSelChSliceRise->GetEntries() )
 
      // INLs + storage
      Double_t dDnl = 0.0;
      Double_t dInl = 0.0;
      for (UInt_t uFtBin = 0; uFtBin < critof001::kdFtBinsNb; uFtBin++) {
        dDnl = pFtSelChSlice->GetBinContent(1 + uFtBin);
        dInl += dDnl;
        fhFeeFtNormDnl[uFeeNrInSys]->Fill(uFtBin, uChannel, dDnl);
        fhFeeFtNormInl[uFeeNrInSys]->Fill(uFtBin, uChannel, dInl);
      }  // for( UInt_t uFtBin = 0; uFtBin < critof001::kuFineCounterSize; uFtBin++)
 
      delete pFtSelChSlice;
    }  // for( UInt_t uChannel = 0; uChannel < fuNbOfChannelsPerFee; uChannel++ )
  }    // for( UInt_t uFeeNrInSys = 0; uFeeNrInSys < fuNbOfFeePerComp * fuNbOfComps; uFeeNrInSys++ )
  delete constantVal;
 
  oldDir->cd();
}
 
/**********************************************************************************************************************/
void CbmTofUnpackMonitorPulser::SetBmonMode(bool /*value*/)
{
  LOG(fatal) << "SetBmonMode mode not available in CbmTofUnpackMonitorPulser (forced off)";
}
 
void CbmTofUnpackMonitorPulser::SetBmonMicroSpillMode(bool /*value*/)
{
  LOG(fatal) << "SetBmonMicroSpillMode mode not available in CbmTofUnpackMonitorPulser (forced off)";
}
 
void CbmTofUnpackMonitorPulser::SetBmonScvdMode(bool /*value*/)
{
  LOG(fatal) << "SetBmonScvdMode mode not available in CbmTofUnpackMonitorPulser (forced off)";
}
 
void CbmTofUnpackMonitorPulser::SetBmonQFactorMode(bool /*value*/)
{
  LOG(fatal) << "SetBmonQFactorMode mode not available in CbmTofUnpackMonitorPulser (forced off)";
}
 
void CbmTofUnpackMonitorPulser::SetTofQFactorMode(bool /*value*/)
{
  LOG(fatal) << "SetTofQFactorMode mode not available in CbmTofUnpackMonitorPulser (forced off)";
}
/**********************************************************************************************************************/
 
ClassImp(CbmTofUnpackMonitorPulser)