Cbm2021EventBuilderAlgo.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 "Cbm2021EventBuilderAlgo.h"

/// CBM headers
#include "CbmEvent.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmMuchDigi.h"
#include "CbmPsdDigi.h"
#include "CbmRichDigi.h"
#include "CbmStsDigi.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
#include "TimesliceMetaData.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 --------------------------------------------
Cbm2021EventBuilderAlgo::Cbm2021EventBuilderAlgo() {}

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

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

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

  /// Check if reference detector data are available
  if (kFALSE == CheckDataAvailable(fRefDet)) {
    LOG(fatal) << "No digi input for reference detector, stopping there!";
  }  // if( kFALSE == CheckDataAvailable( fRefDet ) )

  /// Check if data for detectors in selection list are available
  for (std::vector<EventBuilderDetector>::iterator det = fvDets.begin();
       det != fvDets.end();
       ++det) {
    if (kFALSE == CheckDataAvailable(*det)) {
      LOG(fatal)
        << "No digi input for one of selection detector, stopping there!";
    }  // if( kFALSE == CheckDataAvailable( *det ) )
  }  // for (std::vector<EventBuilderDetector>::iterator det = fvDets.begin(); det != fvDets.end(); ++det)

  /// Access the TS metadata to know TS start time if needed
  if (fdTsStartTime < 0 || fdTsLength < 0 || fdTsOverLength < 0) {
    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)
  }    // if ( fdTsStartTime < 0 || fdTsLength < 0 || fdTsOverLength < 0 )

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

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

  return kTRUE;
}

// ---- ProcessTs ------------------------------------------------------
void Cbm2021EventBuilderAlgo::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 Cbm2021EventBuilderAlgo::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 Cbm2021EventBuilderAlgo::Finish() {
  LOG(info) << "Total errors: " << fuErrors;
}

// ---------------------------------------------------------------------
Bool_t Cbm2021EventBuilderAlgo::CheckDataAvailable(
  EventBuilderDetector& det) {
  // Get a handle from the IO manager
  FairRootManager* ioman = FairRootManager::Instance();

  if (ECbmModuleId::kT0 == det.detId) {
    // T0 is not included in DigiManager
    fT0DigiVec = ioman->InitObjectAs<std::vector<CbmTofDigi> const*>("T0Digi");
    if (!fT0DigiVec) {
      LOG(info) << "No T0 digi input found.";
      return kFALSE;
    }    
  } 
  else if (ECbmModuleId::kSts == det.detId) {
    if (!fStsDigis) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  else if (ECbmModuleId::kMuch == det.detId) {
    if (!fMuchDigis && !fMuchBeamTimeDigis ) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  else if (ECbmModuleId::kTrd == det.detId) {
    if (!fTrdDigis) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  else if (ECbmModuleId::kTof == det.detId) {
    if (!fTofDigis) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  else if (ECbmModuleId::kRich == det.detId) {
    if (!fRichDigis) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  else if (ECbmModuleId::kPsd == det.detId) {
    if (!fPsdDigis) {
      LOG(info) << "No " << det.sName << " digi input found.";
      return kFALSE;
    }
  }
  return kTRUE;
}
// ---------------------------------------------------------------------
void Cbm2021EventBuilderAlgo::InitTs() {
  /// Reset TS based variables (analysis per TS = no building over the border)
  /// Reference detector
  fRefDet.fuStartIndex = 0;
  fRefDet.fuEndIndex   = 0;
  /// Loop on detectors in selection list
  for (std::vector<EventBuilderDetector>::iterator det = fvDets.begin();
       det != fvDets.end();
       ++det) {
    (*det).fuStartIndex = 0;
    (*det).fuEndIndex   = 0;
  }  // for (std::vector<EventBuilderDetector>::iterator det = fvDets.begin(); det != fvDets.end(); ++det)
}

void Cbm2021EventBuilderAlgo::BuildEvents() {
  /// Call LoopOnSeed with proper template argument
  switch (fRefDet.detId) {
    case ECbmModuleId::kSts: {
      LoopOnSeeds<CbmStsDigi>();
      break;