CbmMcbm2019TimeWinEventBuilderAlgo.cxx

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#include "CbmMcbm2019TimeWinEventBuilderAlgo.h"

/// CBM headers
#include "CbmEvent.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmPsdDigi.h"
#include "CbmRichDigi.h"
#include "CbmStsDigi.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
#include "TimesliceMetaData.h"

#include "CbmDigiManager.h"

/// FAIRROOT headers
#include "FairLogger.h"
#include "FairRootManager.h"
#include "FairRunOnline.h"

/// FAIRSOFT headers (geant, boost, ...)
#include "TCanvas.h"
#include "TClonesArray.h"
#include "TH1.h"
#include "TH2.h"
#include "THttpServer.h"

/// C/C++ headers

// ---- Default constructor --------------------------------------------
CbmMcbm2019TimeWinEventBuilderAlgo::CbmMcbm2019TimeWinEventBuilderAlgo() {}

// ---- Destructor -----------------------------------------------------
CbmMcbm2019TimeWinEventBuilderAlgo::~CbmMcbm2019TimeWinEventBuilderAlgo() {}

// ---- Init -----------------------------------------------------------
Bool_t CbmMcbm2019TimeWinEventBuilderAlgo::InitAlgo() {
  LOG(info)
    << "CbmMcbm2019TimeWinEventBuilderAlgo::InitAlgo => Starting sequence";

  // Get a handle from the IO manager
  FairRootManager* ioman = FairRootManager::Instance();

  // Get a pointer to the previous already existing data level
  fDigiMan = CbmDigiManager::Instance();
  fDigiMan->UseMuchBeamTimeDigi();
  fDigiMan->Init();

  // T0 is not included in DigiManager
  fT0DigiVec = ioman->InitObjectAs<std::vector<CbmTofDigi> const*>("T0Digi");
  if (!fT0DigiVec) {
    LOG(info) << "No T0 digi input.";
    if (ECbmModuleId::kT0 == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fT0DigiVec )

  if (!fDigiMan->IsPresent(ECbmModuleId::kSts)) {
    LOG(info) << "No STS digi input.";
    if (ECbmModuleId::kSts == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kSts) )

  if (!fDigiMan->IsPresent(ECbmModuleId::kMuch)) {
    LOG(info) << "No MUCH digi input.";
    if (ECbmModuleId::kMuch == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kMuch) )

  if (!fDigiMan->IsPresent(ECbmModuleId::kTrd)) {
    LOG(info) << "No TRD digi input.";
    if (ECbmModuleId::kTrd == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kTrd) )

  if (!fDigiMan->IsPresent(ECbmModuleId::kTof)) {
    LOG(info) << "No TOF digi input.";
    if (ECbmModuleId::kTof == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kTof) )

  if (!fDigiMan->IsPresent(ECbmModuleId::kRich)) {
    LOG(info) << "No RICH digi input.";
    if (ECbmModuleId::kRich == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kRich) )

  if (!fDigiMan->IsPresent(ECbmModuleId::kPsd)) {
    LOG(info) << "No PSD digi input.";
    if (ECbmModuleId::kPsd == fRefDet) {
      LOG(fatal) << "No digi input for reference detector, stopping there!";
    }  // if( ECbmModuleId::kT0 == fRefDet )
  }    // if( ! fDigiMan->IsPresent(ECbmModuleId::kPsd) )

  /// Access the TS metadata to know TS start tim
  fTimeSliceMetaDataArray =
    dynamic_cast<TClonesArray*>(ioman->GetObject("TimesliceMetaData"));
  if (!fTimeSliceMetaDataArray)
  {
    LOG(fatal) << "No TS metadata input found"
               << " => Please check in the unpacking macro if the following line"
                  " was present!"
               << std::endl
               <<"source->SetWriteOutputFlag(kTRUE);  // For writing TS metadata";
  } // if (!fTimeSliceMetaDataArray)

  /// Store the time window for the reference detector
  switch (fRefDet) {
    case ECbmModuleId::kSts: {
      fdRefTimeWinBeg = fdStsTimeWinBeg;
      fdRefTimeWinEnd = fdStsTimeWinEnd;
      break;
    }  // case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch: {
      fdRefTimeWinBeg = fdMuchTimeWinBeg;
      fdRefTimeWinEnd = fdMuchTimeWinEnd;
      break;
    }  // case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd: {
      fdRefTimeWinBeg = fdTrdTimeWinBeg;
      fdRefTimeWinEnd = fdTrdTimeWinEnd;
      break;
    }  // case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof: {
      fdRefTimeWinBeg = fdTofTimeWinBeg;
      fdRefTimeWinEnd = fdTofTimeWinEnd;
      break;
    }  // case ECbmModuleId::kTof:
    case ECbmModuleId::kRich: {
      fdRefTimeWinBeg = fdRichTimeWinBeg;
      fdRefTimeWinEnd = fdRichTimeWinEnd;
      break;
    }  // case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      fdRefTimeWinBeg = fdPsdTimeWinBeg;
      fdRefTimeWinEnd = fdPsdTimeWinEnd;
      break;
    }  // case ECbmModuleId::kPsd:
    case ECbmModuleId::kT0: {
      fdRefTimeWinBeg = fdT0TimeWinBeg;
      fdRefTimeWinEnd = fdT0TimeWinEnd;
      break;
    }  // case ECbmModuleId::kT0:
    default: {
      LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::Init => "
                 << "Trying to use unsupported detectore as reference: "
                 << fRefDet;
      break;
    }  // default:
  }    // switch( fRefDet )

  if (fbFillHistos) { CreateHistograms(); }  // if( fbFillHistos )

  LOG(info) << "CbmMcbm2019TimeWinEventBuilderAlgo::InitAlgo => Done";

  return kTRUE;
}

// ---- ProcessTs ------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::ProcessTs() {
  LOG_IF(info, fuNrTs % 1000 == 0) << "Begin of TS " << fuNrTs;

  InitTs();

  BuildEvents();

  /// Store last event with trigger if not done by other seed
  if (nullptr != fCurrentEvent) {
    /// TODO: store start time of current event ?
    //        fCurrentEvent->SetStartTime( fPrevTime ); // Replace Seed time with time of first digi in event?
    fCurrentEvent->SetEndTime(fdPrevEvtEndTime);
    fEventVector.push_back(fCurrentEvent);
    fuCurEv++;

    /// Prevent building over TS edge
    fCurrentEvent = nullptr;
  }  // if( nullptr != fCurrentEvent )

  LOG(debug) << "Found " << fEventVector.size() << " triggered events";

  if (fbFillHistos) { FillHistos(); }  // if( fbFillHistos )

  fuNrTs++;
}
void CbmMcbm2019TimeWinEventBuilderAlgo::ClearEventVector() {
  /// Need to delete the object the pointer points to first
  int counter = 0;
  for (CbmEvent* event : fEventVector) {
    LOG(debug) << "Event " << counter << " has " << event->GetNofData()
               << " digis";
    delete event;
    counter++;
  }  // for( CbmEvent* event: fEventVector)

  fEventVector.clear();
}
// ---- Finish ---------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::Finish() {
  LOG(info) << "Total errors: " << fuErrors;
}

// ---------------------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::InitTs() {
  /// Reset TS based variables (analysis per TS = no building over the border)
  fuStartIndexT0   = 0;
  fuStartIndexSts  = 0;
  fuStartIndexMuch = 0;
  fuStartIndexTrd  = 0;
  fuStartIndexTof  = 0;
  fuStartIndexRich = 0;
  fuStartIndexPsd  = 0;
  fuEndIndexT0     = 0;
  fuEndIndexSts    = 0;
  fuEndIndexMuch   = 0;
  fuEndIndexTrd    = 0;
  fuEndIndexTof    = 0;
  fuEndIndexRich   = 0;
  fuEndIndexPsd    = 0;
}

void CbmMcbm2019TimeWinEventBuilderAlgo::BuildEvents() {
  /// Call LoopOnSeed with proper template argument
  switch (fRefDet) {
    case ECbmModuleId::kSts: {
      LoopOnSeeds<CbmStsDigi>();
      break;
    }  // case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch: {
      LoopOnSeeds<CbmMuchBeamTimeDigi>();
      break;
    }  // case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd: {
      LoopOnSeeds<CbmTrdDigi>();
      break;
    }  // case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof: {
      LoopOnSeeds<CbmTofDigi>();
      break;
    }  // case ECbmModuleId::kTof:
    case ECbmModuleId::kRich: {
      LoopOnSeeds<CbmRichDigi>();
      break;
    }  // case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      LoopOnSeeds<CbmPsdDigi>();
      break;
    }  // case ECbmModuleId::kPsd:
    case ECbmModuleId::kT0: {
      LoopOnSeeds<CbmTofDigi>();
      break;
    }  // case ECbmModuleId::kT0:
    default: {
      LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::BuildEvents => "
                 << "Trying to search event seeds with unsupported det: "
                 << fRefDet;
      break;
    }  // default:
  }    // switch( *det )
}

template<class DigiSeed>
void CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds() {
  pTsMetaData =
    dynamic_cast<TimesliceMetaData*>(fTimeSliceMetaDataArray->At(0));
  if (nullptr == pTsMetaData)
    LOG(fatal) << Form("CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => No "
                       "TS metadata found for TS %6u.",
                       fuNrTs);

  /// Print warning in first TS if time window borders out of potential overlap
  if ((0.0 < fdEarliestTimeWinBeg
       && pTsMetaData->GetOverlapDuration() < fdLatestTimeWinEnd)
      || (pTsMetaData->GetOverlapDuration() < fdWidestTimeWinRange)) {
    LOG(warning) << "CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => "
                 << Form("Event window not fitting in TS overlap, risk of "
                         "incomplete events: %f %f %f %llu",
                         fdEarliestTimeWinBeg,
                         fdLatestTimeWinEnd,
                         fdWidestTimeWinRange,
                         pTsMetaData->GetOverlapDuration());
  }  // if end of event window does not fit in overlap for a seed at edge of TS core

  /// Define an acceptance window for the seeds in order to use the overlap
  /// part of the TS to avoid incomplete events
  Double_t dSeedWindowBeg =
    pTsMetaData->GetStartTime()
    + (0.0 < fdEarliestTimeWinBeg ? 0.0 : -fdEarliestTimeWinBeg);
  Double_t dSeedWindowEnd =
    pTsMetaData->GetOverlapStartTime()
    + (0.0 < fdEarliestTimeWinBeg ? 0.0 : -fdEarliestTimeWinBeg);
  if (fbIgnoreTsOverlap) {
    dSeedWindowBeg = pTsMetaData->GetStartTime();
    dSeedWindowEnd = pTsMetaData->GetOverlapStartTime();
  }  // if( fbIgnoreTsOverlap )

  switch (fRefDet) {
    case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof:
    case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      UInt_t uNbRefDigis =
        (0 < fDigiMan->GetNofDigis(fRefDet) ? fDigiMan->GetNofDigis(fRefDet)
                                            : 0);
      /// Loop on size of vector
      for (UInt_t uDigi = 0; uDigi < uNbRefDigis; ++uDigi) {
        LOG(debug) << Form("Checking seed %6u / %6u", uDigi, uNbRefDigis);
        const DigiSeed* pDigi = fDigiMan->Get<DigiSeed>(uDigi);
        /// Check that _entry is not out of range
        if (nullptr != pDigi) {
          Double_t dTime = pDigi->GetTime();

          /// Check if seed in acceptance window
          if (dTime < dSeedWindowBeg) {
            continue;
          }  // if( dTime < dSeedWindowBeg )
          else if (dSeedWindowEnd < dTime) {
            break;
          }  // else if( dSeedWindowEnd < dTime )

          /// Check Seed and build event if needed
          CheckSeed(dTime, uDigi);
        }  // if( nullptr != pDigi )
      }    // for( UInt_t uDigi = 0; uDigi < uNbRefDigis; ++uDigi )
      break;
    }  // Digi containers controlled by DigiManager
    case ECbmModuleId::kT0: {
      if (fT0DigiVec) {
        /// Loop on size of vector
        UInt_t uNbRefDigis = fT0DigiVec->size();
        /// Loop on size of vector
        for (UInt_t uDigi = 0; uDigi < uNbRefDigis; ++uDigi) {
          LOG(debug) << Form("Checking seed %6u / %6u", uDigi, uNbRefDigis);

          Double_t dTime = fT0DigiVec->at(uDigi).GetTime();

          /// Check Seed and build event if needed
          CheckSeed(dTime, uDigi);
        }  // for( UInt_t uDigi = 0; uDigi < uNbRefDigis; ++uDigi )
      }    // if ( fT0DigiVec )
      else
        LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => "
                   << "T0 as reference detector but vector not found!";
      break;
    }  // case ECbmModuleId::kT0
    default: {
      LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => Unknow "
                    "reference detector enum! "
                 << fRefDet;
      break;
    }  // default:
  }    // switch( fRefDet )
}

void CbmMcbm2019TimeWinEventBuilderAlgo::CheckSeed(Double_t dSeedTime,
                                                   UInt_t uSeedDigiIdx) {
  /// If previous event valid and event overlap not allowed, check if we are in overlap
  /// and react accordingly
  if (nullptr != fCurrentEvent && EOverlapMode::AllowOverlap != fOverMode
      && dSeedTime - fdPrevEvtTime < fdWidestTimeWinRange) {
    /// Within overlap range
    switch (fOverMode) {
      case EOverlapMode::NoOverlap: {
        /// No overlap allowed => reject
        LOG(debug1) << "Reject seed due to overlap";
        return;
        break;
      }  // case EOverlapMode::NoOverlap:
      case EOverlapMode::MergeOverlap: {
        /// Merge overlap mode => do nothing and go on filling current event
        break;
      }  // case EOverlapMode::MergeOverlap:
      case EOverlapMode::AllowOverlap: {
        /// Not in Merge overlap mode => should have been catched before, nothing to do
        break;
      }  // case EOverlapMode::AllowOverlap:
    }    // switch( fOverMode )
  }      // if( prev Event exists and overlap not allowed and overlap present )
  else {
    /// Out of overlap range or in overlap allowed mode
    /// => store previous event if not empty and create new one
    if (nullptr != fCurrentEvent) {
      /// TODO: store start time of current event ?
      //        fCurrentEvent->SetStartTime( fPrevTime ); // Replace Seed time with time of first digi in event?
      fCurrentEvent->SetEndTime(fdPrevEvtEndTime);
      fEventVector.push_back(fCurrentEvent);
      fuCurEv++;
    }  // if( nullptr != fCurrentEvent )
    fCurrentEvent = new CbmEvent(fuCurEv, dSeedTime, 0.);
  }  // else of if( prev Event exists and overlap not allowed and overlap present )

  /// If window open for reference detector, search for other reference Digis matching it
  /// Otherwise only add the current seed
  if (fdRefTimeWinBeg < fdRefTimeWinEnd) {
    switch (fRefDet) {
      case ECbmModuleId::kSts: {
        SearchMatches<CbmStsDigi>(dSeedTime, fRefDet, fuStartIndexSts);
        break;
      }  // case ECbmModuleId::kSts:
      case ECbmModuleId::kMuch: {
        SearchMatches<CbmMuchBeamTimeDigi>(
          dSeedTime, fRefDet, fuStartIndexMuch);
        break;
      }  // case ECbmModuleId::kMuch:
      case ECbmModuleId::kTrd: {
        SearchMatches<CbmTrdDigi>(dSeedTime, fRefDet, fuStartIndexTrd);
        break;
      }  // case ECbmModuleId::kTrd:
      case ECbmModuleId::kTof: {
        SearchMatches<CbmTofDigi>(dSeedTime, fRefDet, fuStartIndexTof);
        break;
      }  // case ECbmModuleId::kTof:
      case ECbmModuleId::kRich: {
        SearchMatches<CbmRichDigi>(dSeedTime, fRefDet, fuStartIndexRich);
        break;
      }  // case ECbmModuleId::kRich:
      case ECbmModuleId::kPsd: {
        SearchMatches<CbmPsdDigi>(dSeedTime, fRefDet, fuStartIndexPsd);
        break;
      }  // case ECbmModuleId::kPsd:
      case ECbmModuleId::kT0: {
        SearchMatches<CbmTofDigi>(dSeedTime, fRefDet, fuStartIndexT0);
        break;
      }  // case ECbmModuleId::kT0:
      default: {
        LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => "
                   << "Trying to search matches with unsupported det: "
                   << fRefDet;
        break;
      }  // default:
    }    // switch( fRefDet )

    /// Also add the seed if the window starts after the seed
    if (0 < fdRefTimeWinBeg) AddDigiToEvent(fRefDet, uSeedDigiIdx);
  }  // if( fdRefTimeWinBeg < fdRefTimeWinEnd )
  else {
    AddDigiToEvent(fRefDet, uSeedDigiIdx);
  }  // else of if( fdRefTimeWinBeg < fdRefTimeWinEnd )

  /// Search for matches for each detector in selection list
  for (std::vector<ECbmModuleId>::iterator det = fvDets.begin();
       det != fvDets.end();
       ++det) {
    switch (*det) {
      case ECbmModuleId::kSts: {
        SearchMatches<CbmStsDigi>(dSeedTime, *det, fuStartIndexSts);
        break;
      }  // case ECbmModuleId::kSts:
      case ECbmModuleId::kMuch: {
        SearchMatches<CbmMuchBeamTimeDigi>(dSeedTime, *det, fuStartIndexMuch);
        break;
      }  // case ECbmModuleId::kMuch:
      case ECbmModuleId::kTrd: {
        SearchMatches<CbmTrdDigi>(dSeedTime, *det, fuStartIndexTrd);
        break;
      }  // case ECbmModuleId::kTrd:
      case ECbmModuleId::kTof: {
        SearchMatches<CbmTofDigi>(dSeedTime, *det, fuStartIndexTof);
        break;
      }  // case ECbmModuleId::kTof:
      case ECbmModuleId::kRich: {
        SearchMatches<CbmRichDigi>(dSeedTime, *det, fuStartIndexRich);
        break;
      }  // case ECbmModuleId::kRich:
      case ECbmModuleId::kPsd: {
        SearchMatches<CbmPsdDigi>(dSeedTime, *det, fuStartIndexPsd);
        break;
      }  // case ECbmModuleId::kPsd:
      case ECbmModuleId::kT0: {
        SearchMatches<CbmTofDigi>(dSeedTime, *det, fuStartIndexT0);
        break;
      }  // case ECbmModuleId::kT0:
      default: {
        LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::LoopOnSeeds => "
                   << "Trying to search matches with unsupported det: " << *det;
        break;
      }  // default:
    }    // switch( *det )
  }  // for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )

  /// Check if event is filling trigger conditions and clear it if not
  if (HasTrigger(fCurrentEvent)) {
    fdPrevEvtTime = dSeedTime;

    /// In case of NoOverlap or MergeOverlap, we can and should start checking teh next window
    /// from end of current window in order to save CPU and avoid duplicating
    if (EOverlapMode::NoOverlap == fOverMode
        || EOverlapMode::MergeOverlap == fOverMode) {
      fuStartIndexT0   = fuEndIndexT0;
      fuStartIndexSts  = fuEndIndexSts;
      fuStartIndexMuch = fuEndIndexMuch;
      fuStartIndexTrd  = fuEndIndexTrd;
      fuStartIndexTof  = fuEndIndexTof;
      fuStartIndexRich = fuEndIndexRich;
      fuStartIndexPsd  = fuEndIndexPsd;
    }  // If no overlap or merge overlap
  }    // if( !HasTrigger( fCurrentEvent ) )
  else {
    LOG(debug1) << "Reject seed due to Trigger requirements";
    delete fCurrentEvent;
    fCurrentEvent = nullptr;  /// delete does NOT set a pointer to nullptr...
  }                           // else of if( !HasTrigger( fCurrentEvent ) )
}

template<class DigiCheck>
void CbmMcbm2019TimeWinEventBuilderAlgo::SearchMatches(Double_t dSeedTime,
                                                       ECbmModuleId detMatch,
                                                       UInt_t& uStartIndex) {
  /// This algo relies on time sorted vectors for the selected detectors
  UInt_t uLocalIndexStart = uStartIndex;
  UInt_t uLocalIndexEnd   = uStartIndex;

  /// FIXME: Use method parameters instead to save 1 switch?
  Double_t dTimeWinBeg = 0;
  Double_t dTimeWinEnd = 0;
  switch (detMatch) {
    case ECbmModuleId::kSts: {
      dTimeWinBeg = fdStsTimeWinBeg;
      dTimeWinEnd = fdStsTimeWinEnd;
      break;
    }  // case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch: {
      dTimeWinBeg = fdMuchTimeWinBeg;
      dTimeWinEnd = fdMuchTimeWinEnd;
      break;
    }  // case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd: {
      dTimeWinBeg = fdTrdTimeWinBeg;
      dTimeWinEnd = fdTrdTimeWinEnd;
      break;
    }  // case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof: {
      dTimeWinBeg = fdTofTimeWinBeg;
      dTimeWinEnd = fdTofTimeWinEnd;
      break;
    }  // case ECbmModuleId::kTof:
    case ECbmModuleId::kRich: {
      dTimeWinBeg = fdRichTimeWinBeg;
      dTimeWinEnd = fdRichTimeWinEnd;
      break;
    }  // case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      dTimeWinBeg = fdPsdTimeWinBeg;
      dTimeWinEnd = fdPsdTimeWinEnd;
      break;
    }  // case ECbmModuleId::kPsd:
    case ECbmModuleId::kT0: {
      dTimeWinBeg = fdT0TimeWinBeg;
      dTimeWinEnd = fdT0TimeWinEnd;
      break;
    }  // case ECbmModuleId::kT0:
    default: {
      LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::SearchMatches => "
                 << "Trying to search matches with unsupported det: "
                 << detMatch;
      break;
    }  // default:
  }    // switch( detMatch )

  /// Check the Digis until out of window
  switch (detMatch) {
    case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof:
    case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      UInt_t uNbSelDigis =
        (0 < fDigiMan->GetNofDigis(detMatch) ? fDigiMan->GetNofDigis(detMatch)
                                             : 0);
      /// Loop on size of vector
      for (UInt_t uDigi = uStartIndex; uDigi < uNbSelDigis; ++uDigi) {
        const DigiCheck* pDigi = fDigiMan->Get<DigiCheck>(uDigi);
        /// Check that _entry is not out of range
        if (nullptr != pDigi) {
          Double_t dTime     = pDigi->GetTime();
          Double_t dTimeDiff = dTime - dSeedTime;

          LOG(debug4) << detMatch
                      << Form(" => Checking match %6u / %6u, dt %f",
                              uDigi,
                              uNbSelDigis,
                              dTimeDiff);

          /// Check if within time window, update start/stop indices if needed
          if (dTimeDiff < dTimeWinBeg) {
            ++uLocalIndexStart;
            continue;
          }  // if( dTimeDiff < dTimeWinBeg )
          else if (dTimeWinEnd < dTimeDiff) {
            /// Store as end the first digi out of window to avoid double counting in case of
            /// merged overlap event mode
            uLocalIndexEnd = uDigi;
            break;
          }  // else if( dTimeWinEnd < dTimeDiff ) of if( dTimeDiff < dTimeWinBeg )

          AddDigiToEvent(detMatch, uDigi);

          if (fdPrevEvtEndTime < dTime) fdPrevEvtEndTime = dTime;
        }  // if( nullptr != pDigi )
      }    // for( UInt_t uDigi = 0; uDigi < uNbSelDigis; ++uDigi )

      /// catch the case where we reach the end of the vector before being out of the time window
      if (uLocalIndexEnd < uLocalIndexStart) uLocalIndexEnd = uNbSelDigis;

      break;
    }  // Digi containers controlled by DigiManager
    case ECbmModuleId::kT0: {
      if (fT0DigiVec) {
        /// Loop on size of vector
        UInt_t uNbSelDigis = fT0DigiVec->size();
        /// Loop on size of vector
        for (UInt_t uDigi = uStartIndex; uDigi < uNbSelDigis; ++uDigi) {
          Double_t dTime = fT0DigiVec->at(uDigi).GetTime();

          Double_t dTimeDiff = dTime - dSeedTime;

          /// Check if within time window, update start/stop indices if needed
          if (dTimeDiff < dTimeWinBeg) {
            ++uLocalIndexStart;
            continue;
          }  // if( dTimeDiff < dTimeWinBeg )
          else if (dTimeWinEnd < dTimeDiff) {
            /// Store as end the first digi out of window to avoid double counting in case of
            /// merged overlap event mode
            uLocalIndexEnd = uDigi;
            break;
          }  // else if( dTimeWinEnd < dTimeDiff ) of if( dTimeDiff < dTimeWinBeg )

          AddDigiToEvent(detMatch, uDigi);

          if (fdPrevEvtEndTime < dTime) fdPrevEvtEndTime = dTime;
        }  // for( UInt_t uDigi = 0; uDigi < uNbSelDigis; ++uDigi )

        /// catch the case where we reach the end of the vector before being out of the time window
        if (uLocalIndexEnd < uLocalIndexStart) uLocalIndexEnd = uNbSelDigis;
      }  // if ( fT0DigiVec )
      else
        LOG(fatal) << "CbmMcbm2019TimeWinEventBuilderAlgo::SearchMatches => "
                   << "T0 as selection detector but vector not found!";

      break;
    }  // case ECbmModuleId::kT0
    default: {
      return;
      break;
    }  // default:
  }    // switch( detMatch )

  /// Update the StartIndex and EndIndex for the next event seed
  switch (detMatch) {
    case ECbmModuleId::kSts: {
      fuStartIndexSts = uLocalIndexStart;
      fuEndIndexSts   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kSts:
    case ECbmModuleId::kMuch: {
      fuStartIndexMuch = uLocalIndexStart;
      fuEndIndexMuch   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kMuch:
    case ECbmModuleId::kTrd: {
      fuStartIndexTrd = uLocalIndexStart;
      fuEndIndexTrd   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kTrd:
    case ECbmModuleId::kTof: {
      fuStartIndexTof = uLocalIndexStart;
      fuEndIndexTof   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kTof:
    case ECbmModuleId::kRich: {
      fuStartIndexRich = uLocalIndexStart;
      fuEndIndexRich   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kRich:
    case ECbmModuleId::kPsd: {
      fuStartIndexPsd = uLocalIndexStart;
      fuEndIndexPsd   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kPsd:
    case ECbmModuleId::kT0: {
      fuStartIndexT0 = uLocalIndexStart;
      fuEndIndexT0   = uLocalIndexEnd;
      break;
    }  // case ECbmModuleId::kT0:
    default: {
      return;
      break;
    }  // default:
  }    // switch( detMatch )
}

void CbmMcbm2019TimeWinEventBuilderAlgo::AddDigiToEvent(ECbmModuleId _system,
                                                        Int_t _entry) {
  // Fill digi index into event
  switch (_system) {
    case ECbmModuleId::kMvd:
      fCurrentEvent->AddData(ECbmDataType::kMvdDigi, _entry);
      break;
    case ECbmModuleId::kSts:
      fCurrentEvent->AddData(ECbmDataType::kStsDigi, _entry);
      break;
    case ECbmModuleId::kRich:
      fCurrentEvent->AddData(ECbmDataType::kRichDigi, _entry);
      break;
    case ECbmModuleId::kMuch:
      fCurrentEvent->AddData(ECbmDataType::kMuchDigi, _entry);
      break;
    case ECbmModuleId::kTrd:
      fCurrentEvent->AddData(ECbmDataType::kTrdDigi, _entry);
      break;
    case ECbmModuleId::kTof:
      fCurrentEvent->AddData(ECbmDataType::kTofDigi, _entry);
      break;
    case ECbmModuleId::kPsd:
      fCurrentEvent->AddData(ECbmDataType::kPsdDigi, _entry);
      break;
    case ECbmModuleId::kT0:
      fCurrentEvent->AddData(ECbmDataType::kT0Digi, _entry);
      break;
    default: break;
  }
}

Bool_t CbmMcbm2019TimeWinEventBuilderAlgo::HasTrigger(CbmEvent* event) {
  /// Check multiplicity trigger conditions
  if (CheckTriggerConditions(event, ECbmModuleId::kT0, ECbmDataType::kT0Digi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kSts, ECbmDataType::kStsDigi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kMuch, ECbmDataType::kMuchDigi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kTrd, ECbmDataType::kTrdDigi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kTof, ECbmDataType::kTofDigi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kRich, ECbmDataType::kRichDigi)
      && CheckTriggerConditions(
        event, ECbmModuleId::kPsd, ECbmDataType::kPsdDigi)) {
    return kTRUE;
  }  // if all trigger conditions fullfilled
  else {
    return kFALSE;
  }  // if at least one trigger condition failed
}

Bool_t CbmMcbm2019TimeWinEventBuilderAlgo::CheckTriggerConditions(
  CbmEvent* event,
  ECbmModuleId det,
  ECbmDataType dataType) {
  UInt_t uTrigMin  = 0;
  Int_t iTrigMax   = -1;
  std::string sDet = "";
  switch (det) {
    case ECbmModuleId::kSts: {
      uTrigMin = fuTriggerMinStsDigis;
      iTrigMax = fiTriggerMaxStsDigis;
      sDet     = "STS";
      break;
    }
    case ECbmModuleId::kRich: {
      uTrigMin = fuTriggerMinRichDigis;
      iTrigMax = fiTriggerMaxRichDigis;
      sDet     = "RICH";
      break;
    }
    case ECbmModuleId::kMuch: {
      uTrigMin = fuTriggerMinMuchDigis;
      iTrigMax = fiTriggerMaxMuchDigis;
      sDet     = "MUCH";
      break;
    }
    case ECbmModuleId::kTrd: {
      uTrigMin = fuTriggerMinTrdDigis;
      iTrigMax = fiTriggerMaxTrdDigis;
      sDet     = "TRD";
      break;
    }
    case ECbmModuleId::kTof: {
      uTrigMin = fuTriggerMinTofDigis;
      iTrigMax = fiTriggerMaxTofDigis;
      sDet     = "TOF";
      break;
    }
    case ECbmModuleId::kPsd: {
      uTrigMin = fuTriggerMinPsdDigis;
      iTrigMax = fiTriggerMaxPsdDigis;
      sDet     = "PSD";
      break;
    }
    case ECbmModuleId::kT0: {
      uTrigMin = fuTriggerMinT0Digis;
      iTrigMax = fiTriggerMaxT0Digis;
      sDet     = "T0";
      break;
    }
    default: {
      LOG(fatal)
        << "CbmMcbm2019TimeWinEventBuilderAlgo::CheckTriggerConditions => "
        << "Unsupported or unknow detector enum";
      break;
    }
  }  // switch( det )

  /// Check if both Trigger conditions disabled for this detector
  if (0 == uTrigMin && iTrigMax < 0) {
    return kTRUE;
  }  // if( 0 == uTrigMin && iTrigMax < 0 )

  /// Check if detector present
  if (ECbmModuleId::kT0 == det) {
    /// FIXME: special case to be removed once T0 supported by DigiManager
    if (!(fT0DigiVec)) {
      LOG(warning) << "Event does not have digis storage for T0"
                   << " while the following trigger minimum is defined: "
                   << uTrigMin;
      return kFALSE;
    }  // if( !(fT0DigiVec) )
  }    // if( ECbmDataType::kT0Digi == det )
  else {
    if (!fDigiMan->IsPresent(det)) {
      LOG(warning) << "Event does not have digis storage for " << sDet
                   << " while the following trigger minimum is defined: "
                   << uTrigMin;
      return kFALSE;
    }  // if( !fDigiMan->IsPresent( det ) )
  }    // else of if( ECbmDataType::kT0Digi == det )

  /// Check Minimal trigger acceptance by minimal number
  Int_t iNbDigis = event->GetNofData(dataType);
  if ((-1 != iNbDigis) && (uTrigMin <= static_cast<UInt_t>(iNbDigis))) {
    return kTRUE;
  }  // if( ( -1 != iNbDigis ) && ( uTrigMin <= static_cast< UInt_t >( iNbDigis )  )
  else {
    LOG(debug2) << "Event does not have enough digis: " << iNbDigis << " vs "
                << uTrigMin << " for " << sDet;
    return kFALSE;
  }  // else of if( ( -1 != iNbDigis ) && ( uTrigMin <= static_cast< UInt_t >( iNbDigis )  )

  /// Check trigger rejection by maximal number
  if (iNbDigis < iTrigMax) {
    return kTRUE;
  }  // if( iNbDigis < iTrigMax )
  else {
    LOG(debug2) << "Event Has too many digis: " << iNbDigis << " vs "
                << iTrigMax << " for " << sDet;
    return kFALSE;
  }  // else of if( iNbDigis < iTrigMax )
}

//----------------------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::CreateHistograms() {
  /// FIXME: Disable clang formatting for histograms declaration for now
  /* clang-format off */
  fhEventTime = new TH1F("hEventTime",
                         "seed time of the events; Seed time [s]; Events",
                         60000, 0, 600);
  fhEventDt   = new TH1F(
    "fhEventDt",
    "interval in seed time of consecutive events; Seed time [s]; Events",
    2100, -100.5, 1999.5);
  fhEventSize =
    new TH1F("hEventSize",
             "nb of all  digis in the event; Nb Digis []; Events []",
             10000, 0, 10000);
  fhNbDigiPerEvtTime =
    new TH2I("hNbDigiPerEvtTime",
             "nb of all  digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,   600,
             1000, 0, 10000);

  fhNbDigiPerEvtTimeT0 =
    new TH2I("hNbDigiPerEvtTimeT0",
             "nb of T0   digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimeSts =
    new TH2I("hNbDigiPerEvtTimeSts",
             "nb of STS  digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimeMuch =
    new TH2I("hNbDigiPerEvtTimeMuch",
             "nb of MUCH digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimeTrd =
    new TH2I("hNbDigiPerEvtTimeTrd",
             "nb of TRD  digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimeTof =
    new TH2I("hNbDigiPerEvtTimeTof",
             "nb of TOF  digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimeRich =
    new TH2I("hNbDigiPerEvtTimeRich",
             "nb of RICH digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);
  fhNbDigiPerEvtTimePsd =
    new TH2I("hNbDigiPerEvtTimePsd",
             "nb of PSD  digis per event vs seed time of the events; Seed time "
             "[s]; Nb Digis []; Events []",
              600, 0,  600,
             4000, 0, 4000);

  AddHistoToVector(fhEventTime,            "evtbuild");
  AddHistoToVector(fhEventDt,              "evtbuild");
  AddHistoToVector(fhEventSize,            "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTime,     "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeT0,   "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeSts,  "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeMuch, "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeTrd,  "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeTof,  "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimeRich, "evtbuild");
  AddHistoToVector(fhNbDigiPerEvtTimePsd,  "evtbuild");

  /// FIXME: Re-enable clang formatting after histograms declaration
  /* clang-format on */
}
void CbmMcbm2019TimeWinEventBuilderAlgo::FillHistos() {
  Double_t dPreEvtTime = -1.0;
  for (CbmEvent* evt : fEventVector) {
    fhEventTime->Fill(evt->GetStartTime() * 1e-9);
    if (0.0 <= dPreEvtTime) {
      fhEventDt->Fill(evt->GetStartTime() - dPreEvtTime);
    }  // if( 0.0 <= dPreEvtTime )
    fhEventSize->Fill(evt->GetNofData());
    fhNbDigiPerEvtTime->Fill(evt->GetStartTime() * 1e-9, evt->GetNofData());

    fhNbDigiPerEvtTimeT0->Fill(evt->GetStartTime() * 1e-9,
                               evt->GetNofData(ECbmDataType::kT0Digi));
    fhNbDigiPerEvtTimeSts->Fill(evt->GetStartTime() * 1e-9,
                                evt->GetNofData(ECbmDataType::kStsDigi));
    fhNbDigiPerEvtTimeMuch->Fill(evt->GetStartTime() * 1e-9,
                                 evt->GetNofData(ECbmDataType::kMuchDigi));
    fhNbDigiPerEvtTimeTrd->Fill(evt->GetStartTime() * 1e-9,
                                evt->GetNofData(ECbmDataType::kTrdDigi));
    fhNbDigiPerEvtTimeTof->Fill(evt->GetStartTime() * 1e-9,
                                evt->GetNofData(ECbmDataType::kTofDigi));
    fhNbDigiPerEvtTimeRich->Fill(evt->GetStartTime() * 1e-9,
                                 evt->GetNofData(ECbmDataType::kRichDigi));
    fhNbDigiPerEvtTimePsd->Fill(evt->GetStartTime() * 1e-9,
                                evt->GetNofData(ECbmDataType::kPsdDigi));

    dPreEvtTime = evt->GetStartTime();
  }  // for( CbmEvent * evt: fEventVector )
}
void CbmMcbm2019TimeWinEventBuilderAlgo::ResetHistograms(
  Bool_t /*bResetTime*/) {
  fhEventTime->Reset();
  fhEventDt->Reset();
  fhEventSize->Reset();
  fhNbDigiPerEvtTime->Reset();
  fhNbDigiPerEvtTimeT0->Reset();
  fhNbDigiPerEvtTimeSts->Reset();
  fhNbDigiPerEvtTimeMuch->Reset();
  fhNbDigiPerEvtTimeTrd->Reset();
  fhNbDigiPerEvtTimeTof->Reset();
  fhNbDigiPerEvtTimeRich->Reset();
  fhNbDigiPerEvtTimePsd->Reset();

  /*
   if( kTRUE == bResetTime )
   {
      /// Also reset the Start time for the evolution plots!
      fdStartTime = -1.0;
   } // if( kTRUE == bResetTime )
*/
}
//----------------------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::SetReferenceDetector(
  ECbmModuleId refDet) {
  for (std::vector<ECbmModuleId>::iterator det = fvDets.begin();
       det != fvDets.end();
       ++det) {
    if (*det == refDet) {