CbmMcbm2018UnpackerTaskTrdR.cxx

Go to the documentation of this file.

#include "CbmMcbm2018UnpackerTaskTrdR.h"
#include "CbmMcbm2018UnpackerAlgoTrdR.h"
 
#include "FairLogger.h"
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRunOnline.h"
#include "FairRuntimeDb.h"
 
#include <TFile.h>
#include <THttpServer.h>
 
/* Default Constructor */
CbmMcbm2018UnpackerTaskTrdR::CbmMcbm2018UnpackerTaskTrdR()
  : CbmMcbmUnpack()
  , fbMonitorMode(kFALSE)
  , fbDebugMonitorMode(kFALSE)
  , fbWriteOutput(kTRUE)
  , fbDebugWriteOutput(kFALSE)
  , fbBaselineAvg(kFALSE)
  , fSystemIdentifier((std::uint8_t) fles::SubsystemIdentifier::TRD)
  , fdMsSizeInNs(1.28e6)  // default value corresponds to mCbm 2020 value
  , fMonitorHistoFileName("")
  , fIsActiveHistoVec(CbmMcbm2018UnpackerAlgoTrdR::kEndDefinedHistos, false)
  , fTrdDigiVector(nullptr)
  , fTrdRawMessageVector(nullptr)
  , fSpadicInfoMsgVector(nullptr)
  , fUnpackerAlgo(nullptr) {
  fUnpackerAlgo = new CbmMcbm2018UnpackerAlgoTrdR();
}
 
/* Default Destructor */
CbmMcbm2018UnpackerTaskTrdR::~CbmMcbm2018UnpackerTaskTrdR() {
  delete fUnpackerAlgo;
}
 
Bool_t CbmMcbm2018UnpackerTaskTrdR::Init() {
  LOG(info) << "Initializing CbmMcbm2018UnpackerTaskTrdR...";
  Bool_t initOK = 1;
 
  FairRootManager* ioman = nullptr;
  ioman                  = FairRootManager::Instance();
  if (ioman == nullptr) { LOG(fatal) << "No FairRootManager instance"; }
 
  fTrdDigiVector = new std::vector<CbmTrdDigi>();
  if (fTrdDigiVector) {
    ioman->RegisterAny("TrdDigi", fTrdDigiVector, fbWriteOutput);
    initOK &= fUnpackerAlgo->SetDigiOutputPointer(fTrdDigiVector);
  } else {
    LOG(fatal) << "fTrdDigiVector could not be registered at FairRootManager.";
  }
 
  if (fbDebugWriteOutput) {
    fTrdRawMessageVector = new std::vector<CbmTrdRawMessageSpadic>();
    fSpadicInfoMsgVector =
      new std::vector<std::pair<std::uint64_t, std::uint64_t>>();
    if (fTrdRawMessageVector && fSpadicInfoMsgVector) {
      ioman->RegisterAny(
        "CbmTrdSpadicRawMessages", fTrdRawMessageVector, kTRUE);
      ioman->RegisterAny(
        "CbmTrdSpadicInfoMessages", fSpadicInfoMsgVector, kTRUE);
      initOK &= fUnpackerAlgo->SetRawOutputPointer(fTrdRawMessageVector,
                                                   fSpadicInfoMsgVector);
    } else {
      LOG(fatal) << "[CbmMcbm2018UnpackerTaskTrdR::Init] Raw output could not "
                    "be registered at FairRootManager.";
    }
  }
 
  fUnpackerAlgo->SetMsSizeInNs(
    fdMsSizeInNs);  // TODO handle this with asic parameter files
  fUnpackerAlgo->SetFirstChannelsElinkEven(fIsFirstChannelsElinkEven);
  initOK &= fUnpackerAlgo->Init();
 
  if (initOK) {
    LOG(info) << "Initialization of CbmMcbm2018UnpackerTaskTrdR and "
                 "CbmMcbm2018UnpackerAlgoTrdR successfull!";
  } else {
    LOG(fatal) << "Init of CbmMcbm2018UnpackerAlgoTrdR failed!";
  }
 
  return initOK;
}
 
Bool_t CbmMcbm2018UnpackerTaskTrdR::DoUnpack(const fles::Timeslice& ts,
                                             size_t /*component*/) {
  if (kFALSE == fUnpackerAlgo->ProcessTs(ts)) {
    LOG(error) << "CbmMcbm2018UnpackerTaskTrdR: Failed processing TS "
               << ts.index() << " in unpacker algorithm class.";
    return kFALSE;
  }
 
 
  // sts does a time sorting of fTrdDigiVector here. but this could also be done in the algo?!
 
 
  return kTRUE;
}
 
void CbmMcbm2018UnpackerTaskTrdR::Reset() {
  if (fTrdDigiVector) fTrdDigiVector->clear();
  if (fTrdRawMessageVector) fTrdRawMessageVector->clear();
  if (fSpadicInfoMsgVector) fSpadicInfoMsgVector->clear();
  if (fUnpackerAlgo) fUnpackerAlgo->Reset();
}
 
void CbmMcbm2018UnpackerTaskTrdR::Finish() {
  LOG(info) << "Finish of CbmMcbm2018UnpackerTaskTrdR";
  fUnpackerAlgo->Finish();
 
  if ((fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE)
      && fMonitorHistoFileName != "") {
    std::vector<std::pair<TNamed*, std::string>> vHistos =
      fUnpackerAlgo->GetHistoVector();
 
    TDirectory* oldDir = nullptr;
    TFile* histoFile   = nullptr;
    // Store current directory position to allow restore later
    oldDir = gDirectory;
    // open separate histo file in recreate mode
    TString histoFileName = fMonitorHistoFileName;
    histoFile             = new TFile(histoFileName.Data(), "RECREATE");
    histoFile->cd();
    for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
      // Make sure we end up in chosen folder
      TString sFolder = vHistos[uHisto].second.data();
      if (nullptr == gDirectory->Get(sFolder)) gDirectory->mkdir(sFolder);
      gDirectory->cd(sFolder);
      // Write histogram
      vHistos[uHisto].first->Write();
      histoFile->cd();
    }
    // Restore original directory position
    oldDir->cd();
    histoFile->Close();
  }
}
 
void CbmMcbm2018UnpackerTaskTrdR::SetParContainers() {
  LOG(info) << "Setting parameter containers for " << GetName();
 
  TList* fParContList = fUnpackerAlgo->GetParList();
 
  Int_t iParCont(0);
  for (auto parSetIt : *fParContList) {
    CbmTrdParSet* tempObj = (CbmTrdParSet*) (parSetIt);
    fParContList->Remove(tempObj);
    std::string sParamName {tempObj->GetName()};
    delete tempObj;
    CbmTrdParSet* updatedParSet = nullptr;
    updatedParSet               = dynamic_cast<CbmTrdParSet*>(
      FairRun::Instance()->GetRuntimeDb()->getContainer(sParamName.data()));
 
    if (!updatedParSet) {
      LOG(error) << "Failed to obtain parameter container " << sParamName
                 << ", for parameter index " << iParCont;
      return;
    }
    fParContList->AddAt(updatedParSet, iParCont);
  }
}
 
Bool_t CbmMcbm2018UnpackerTaskTrdR::InitContainers() {
  if (fUnpackerAlgo == nullptr) {
    LOG(error) << "CbmMcbm2018UnpackerTaskTrdR::InitContainers failed! No "
                  "Unpacker Algo.";
    return kFALSE;
  }
  LOG(info) << "Init containers for CbmMcbm2018UnpackerTaskTrdR";
 
  fUnpackerAlgo->SetMonitorMode(fbMonitorMode);
  fUnpackerAlgo->SetDebugMonitorMode(fbDebugMonitorMode);
  fUnpackerAlgo->SetWriteOutput(fbWriteOutput);
  fUnpackerAlgo->SetDebugWriteOutput(fbDebugWriteOutput);
  fUnpackerAlgo->SetDebugSortOutput(fbDebugSortOutput);
  fUnpackerAlgo->SetBaselineAvg(fbBaselineAvg);
  // Activate histograms in unpacker
  fUnpackerAlgo->SetActiveHistograms(fIsActiveHistoVec);
 
  Bool_t initOK = fUnpackerAlgo->InitContainers();
 
  if (fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE) {
    initOK &= fUnpackerAlgo->CreateHistograms();
 
    std::vector<std::pair<TNamed*, std::string>> vHistos =
      fUnpackerAlgo->GetHistoVector();
 
    THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
    if (nullptr != server) {
      for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
        server->Register(Form("/%s", vHistos[uHisto].second.data()),
                         vHistos[uHisto].first);
      }
      // FIXME: register the correct command
      //server->RegisterCommand("/Reset_UnpSts_Hist", "bMcbm2018UnpackerTaskStsResetHistos=kTRUE");
      //server->Restrict("/Reset_UnpSts_Hist", "allow=admin");
    } else {
      //                        initOK &= 0;
      LOG(warning) << "The histograms from CbmMcbm2018UnpackerTaskTrdR will "
                      "not be available online as no server present";
    }  // end if( nullptr != server )
  }    // end if (fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE)
 
  return initOK;
}
 
Bool_t CbmMcbm2018UnpackerTaskTrdR::ReInitContainers() {
  if (fUnpackerAlgo == nullptr) return kFALSE;
 
  LOG(info) << "ReInit parameter containers for CbmMcbm2018UnpackerTaskTrdR";
 
  Bool_t initOK = fUnpackerAlgo->ReInitContainers();
  return initOK;
}
 
void CbmMcbm2018UnpackerTaskTrdR::AddMsComponentToList(size_t component,
                                                       UShort_t usDetectorId) {
  if (usDetectorId != (UShort_t) fSystemIdentifier) {
    LOG(error) << "CbmMcbm2018UnpackerTaskTrdR::AddMsComponentToList : Wrong "
                  "Detector ID!";
    return;
  }
  if (fUnpackerAlgo != nullptr)
    fUnpackerAlgo->AddMsComponentToList(component, usDetectorId);
}
 
void CbmMcbm2018UnpackerTaskTrdR::SetNbMsInTs(size_t uCoreMsNb,
                                              size_t uOverlapMsNb) {
  if (fUnpackerAlgo != nullptr)
    fUnpackerAlgo->SetNbMsInTs(uCoreMsNb, uOverlapMsNb);
}
 
void CbmMcbm2018UnpackerTaskTrdR::SetHistoFileName(TString filename) {
  fMonitorHistoFileName = filename;
  SetMonitorMode(kTRUE);
}
 
void CbmMcbm2018UnpackerTaskTrdR::SetTimeOffsetNs(Double_t dOffsetIn) {
  if (fUnpackerAlgo != nullptr) fUnpackerAlgo->SetTimeOffsetNs(dOffsetIn);
}
 
void CbmMcbm2018UnpackerTaskTrdR::SetIgnoreOverlapMs(Bool_t bFlagIn) {
  fUnpackerAlgo->SetIgnoreOverlapMs(bFlagIn);
}
ClassImp(CbmMcbm2018UnpackerTaskTrdR)