CbmTrdUnpackMonitor.h

Go to the documentation of this file.

/* Copyright (C) 2021 Goethe-University Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pascal Raisig [committer] */

 
#ifndef CbmTrdUnpackMonitor_H
#define CbmTrdUnpackMonitor_H
 
#include "CbmTrdDigi.h"
#include "CbmTrdParSetAsic.h"
#include "CbmTrdParSetDigi.h"
#include "CbmTrdRawMessageSpadic.h"
#include "CbmTrdSpadic.h"
 
#include <MicrosliceDescriptor.hpp>
#include <Timeslice.hpp>
 
#include <FairRunOnline.h>
#include <FairTask.h>
#include <Logger.h>
 
#include <Rtypes.h>  // for types
#include <RtypesCore.h>
#include <TFile.h>
#include <TH1.h>
#include <THttpServer.h>  // for histogram server
 
#include <cmath>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
class CbmTrdUnpackMonitor {
 public:
  enum class eDigiHistos : size_t
  {
    kMap = 0,
    kMap_St,
    kMap_Nt,
    kChannel,
    kChannel_St,
    kChannel_Nt,
    kCharge,
    kCharge_St,
    kCharge_Nt,
    kTriggerType,
    kDigiDeltaT,
    kDigiNtCorr
  };

  enum class eRawHistos : size_t
  {
    kSignalshape = 0,
    kSignalshape_St,
    kSignalshape_Nt,
    kMap,
    kMap_St,
    kMap_Nt,
    kElinkId,
    kSampleDistStdDev,
    kSample0perChannel,
    kHitType,
    kRawRate,
  };

  enum class eOtherHistos : size_t
  {
    kSpadic_Info_Types = 0,
    kMs_Flags,
    kBomRate,
    kBufRate,
    kBomPerRawRate
  };

  static const uint32_t kTimeplotLenghtSeconds = 600;  // 10 minuntes

  CbmTrdUnpackMonitor(/* args */);

  virtual ~CbmTrdUnpackMonitor();

  CbmTrdUnpackMonitor(const CbmTrdUnpackMonitor&) = delete;

  CbmTrdUnpackMonitor& operator=(const CbmTrdUnpackMonitor&) = delete;

  void FillHistos(CbmTrdDigi* digi, CbmTrdRawMessageSpadic* raw = nullptr);

  void FillHisto(Spadic::MsInfoType type, uint32_t moduleid);

  void FillHisto(fles::MicrosliceFlags flag, uint32_t moduleid);

  void Finish();
 
  // Runtime functions
  Bool_t Init(CbmTrdParSetDigi* digiParSet, CbmTrdParSetAsic* asicParSet = nullptr);

  void SetActiveHistos(std::vector<eDigiHistos> vec) { fActiveDigiHistos.swap(vec); }

  void SetActiveHistos(std::vector<eRawHistos> vec) { fActiveRawHistos.swap(vec); }

  void SetActiveHistos(std::vector<eOtherHistos> vec) { fActiveOtherHistos.swap(vec); }

  void SetSpadicObject(std::shared_ptr<CbmTrdSpadic> value) { fSpadic = value; }

  void SetWriteToFile(std::string filename)
  {
    fOutfilename   = filename;
    fDoWriteToFile = true;
  }

  void SetDigiOutputVec(std::vector<CbmTrdDigi>* digiOutputVec) { fDigiOutputVec = digiOutputVec; }

  void SetCurrentTimesliceStartTime(uint64_t time) { fCurrentTimesliceStartTimeNs = time; };
 
 
 protected:
  template<class histotype>
  void addHistoToMap(std::shared_ptr<TH1> histo,
                     std::map<histotype, std::map<uint32_t, std::shared_ptr<TH1>>>* histomap, uint32_t moduleid,
                     histotype kHisto)
  {
    // If the histogram already exists we stop here
    if (checkIfHistoExists(kHisto, histomap, moduleid)) return;
 
    // Create a histo module pair
    auto histopair = std::make_pair(moduleid, histo);
 
    // Check if already have a histo map for the histo category
    auto histomapIt = histomap->find(kHisto);
    if (histomapIt == histomap->end()) {
      // There is no map yet for the given histogram category
      std::map<uint32_t, std::shared_ptr<TH1>> newmap = {};
      newmap.emplace(histopair);
      // Create a pair with the map and the histogram category
      auto pair = std::make_pair(kHisto, newmap);
      // And put it to the digi histo map
      histomap->emplace(pair);
    }
    else {
      // We found a map where we can put the histopair into
      histomapIt->second.emplace(histopair);
    }
    // And finally if we have HttpServer we pass the histogram pointer to it
    if (fHistoServer) {
 
      std::string directory = std::to_string(moduleid) + "/" + getHistoType(histo) + "/";
      fHistoServer->Register(directory.data(), histo.get());
    }
  }
 
  template<typename THistotype>
  bool checkIfHistoExists(THistotype etype, std::map<THistotype, std::map<uint32_t, std::shared_ptr<TH1>>>* histomap,
                          uint32_t moduleid)
  {
    // First check if the map knows about the type, if not the histo does not exist yet.
    auto histotypemapIt = histomap->find(etype);
    if (histotypemapIt == histomap->end()) return false;
 
    // Check if at the moduleId position we find something
    auto histopair = histotypemapIt->second.find(moduleid);
    if (histopair == histotypemapIt->second.end()) return false;
 
    // Check if there is a pointer to the histo which not null
    if (histopair->second != nullptr) return true;
 
    return false;
  }

  virtual void createHistos();

  virtual void createHisto(eDigiHistos kHisto);

  virtual void createHisto(eRawHistos kHisto);

  virtual void createHisto(eOtherHistos kHisto);

  virtual void fillHisto(CbmTrdDigi* digi, eDigiHistos kHisto, uint32_t moduleid, std::shared_ptr<TH1> histo);

  void fillHisto(CbmTrdRawMessageSpadic* raw, eRawHistos kHisto, std::shared_ptr<TH1> histo, CbmTrdDigi* digi);

  void fillSamplesHisto(std::shared_ptr<TH1> histo, CbmTrdRawMessageSpadic* raw);

  std::double_t getDeltaT(CbmTrdDigi* digi);

  std::string getHistoName(eDigiHistos kHisto);

  std::string getHistoName(eRawHistos kHisto);

  std::string getHistoName(eOtherHistos kHisto);

  static std::string getTypeName(eDigiHistos kHisto)
  {
    (void) kHisto;
    return "Digi";
  };

  static std::string getTypeName(eRawHistos kHisto)
  {
    (void) kHisto;
    return "Raw";
  };

  static std::string getTypeName(eOtherHistos kHisto)
  {
    (void) kHisto;
    return "Other";
  };

  std::string getHistoType(std::shared_ptr<TH1> histo);

  std::pair<uint32_t, uint32_t> getRowAndCol(uint32_t moduleid, uint32_t channelid);

  std::float_t getSamplesStdDev(CbmTrdRawMessageSpadic* raw);
 
  template<class histotype>
  size_t writeHistosToFile(std::map<histotype, std::map<uint32_t, std::shared_ptr<TH1>>>* histomap, TFile* file)
  {
    // Counter of written histos
    size_t nhistos = 0;
 
    // Make sure we are in the file to which we want to write our histos
    file->cd();
    for (auto typemappair : *histomap) {
      for (auto histopair : typemappair.second) {
 
        // Make sure we end up in chosen folder
        std::string moduleidname = std::to_string(histopair.first);
        if (nullptr == gDirectory->Get(moduleidname.data())) gDirectory->mkdir(moduleidname.data());
        gDirectory->cd(moduleidname.data());
 
        // Now move(create) to the histotype folder (digi, raw or other histo)
        std::string histotypename = getTypeName(typemappair.first);
        // (Create and) Move to the directory of the type
        if (nullptr == gDirectory->Get(histotypename.data())) gDirectory->mkdir(histotypename.data());
        gDirectory->cd(histotypename.data());
 
        // Write histogram
        LOG(debug) << Class_Name() << "::Finish() Write histo " << histopair.second->GetName() << " to file "
                   << file->GetName() << " in folder " << moduleidname.data() << "/" << histotypename.data();
        histopair.second->Write();
        nhistos++;
        // Move back to root directory of the output file
        file->cd();
      }
    }
    return nhistos;
  }

  void fillNtCorrHisto(std::shared_ptr<TH1> histo, CbmTrdDigi* digi);

  void resetTimeplots();

  void adjustTimeplots(uint64_t newtime);
 
  // Member variables
  std::map<eDigiHistos, std::map<uint32_t, std::shared_ptr<TH1>>> fDigiHistoMap = {};

  std::map<eRawHistos, std::map<uint32_t, std::shared_ptr<TH1>>> fRawHistoMap = {};

  std::map<eOtherHistos, std::map<uint32_t, std::shared_ptr<TH1>>> fOtherHistoMap = {};

  std::vector<eDigiHistos> fActiveDigiHistos = {};

  std::vector<eRawHistos> fActiveRawHistos = {};

  std::vector<eOtherHistos> fActiveOtherHistos = {};

  THttpServer* fHistoServer = nullptr;

  bool fDoWriteToFile = false;

  std::string fOutfilename = "";
 
  // ---- TRD parameters ----
  std::vector<uint32_t> fModuleIdsVec = {};

  std::map<uint32_t, uint8_t> fModuleOrientation = {};

  std::map<uint32_t, uint8_t> fModuleNrRows = {};

  std::map<uint32_t, uint8_t> fModuleNrColumns = {};

  std::map<uint32_t, std::vector<size_t>> fLastDigiTimeMap = {};

  std::vector<CbmTrdDigi>* fDigiOutputVec = {};
 
  // All other parameters and containers
  std::shared_ptr<CbmTrdSpadic> fSpadic = nullptr;

  uint64_t fCurrentTimeplotStartNs = 0;

  uint64_t fCurrentTimesliceStartTimeNs = 0;

  uint64_t fLastRawTime = 0;
 
 private:
  ClassDef(CbmTrdUnpackMonitor, 2)
};
 
#endif  // CbmTrdUnpackMonitor_H