CbmMcbm2019TimeWinEventBuilderAlgo.cxx

*/
}
//----------------------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::AddDetector( ECbmModuleId selDet )
{
  /// FIXME: This is not true in case TOF is used as reference !!!!!
  if( fRefDet == selDet )
  {
    LOG( fatal ) << "CbmMcbm2019TimeWinEventBuilderAlgo::AddDetector => Cannot add the reference detector as selection detector!";
  } // if( fRefDet == selDet )

  for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )
  {
    if( *det  == selDet )
    {
      LOG( warning ) << "CbmMcbm2019TimeWinEventBuilderAlgo::AddDetector => Doing nothing, selection detector already in list!" << selDet;
      return;
    } // if( *det  == selDet )
  } // for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )
  fvDets.push_back( selDet );
}
void CbmMcbm2019TimeWinEventBuilderAlgo::RemoveDetector( ECbmModuleId selDet )
{
  for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )
  {
    if( *det  == selDet )
    {
      fvDets.erase( det );
      return;
    } // if( *det  == selDet )
  } // for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )
  LOG( warning ) << "CbmMcbm2019TimeWinEventBuilderAlgo::RemoveDetector => Doing nothing, selection detector not in list!" << selDet;
}
//----------------------------------------------------------------------
void CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerMinNumber( ECbmModuleId selDet, UInt_t uVal )
{
  /// Store in corresponding members
  std::string sDet = "";
  switch( selDet )
  {
    case ECbmModuleId::kSts:
    {
      fuTriggerMinStsDigis  = uVal;
      sDet = "STS";
      break;
    }
    case ECbmModuleId::kRich:
    {
      fuTriggerMinRichDigis = uVal;
      sDet = "RICH";
      break;
    }
    case ECbmModuleId::kMuch:
    {
      fuTriggerMinMuchDigis  = uVal;
      sDet = "MUCH";
      break;
    }
    case ECbmModuleId::kTrd:
    {
      fuTriggerMinTrdDigis  = uVal;
      sDet = "TRD";
      break;
    }
    case ECbmModuleId::kTof:
    {
      fuTriggerMinTofDigis = uVal;
      sDet = "TOF";
      break;
    }
    case ECbmModuleId::kPsd:
    {
      fuTriggerMinPsdDigis  = uVal;
      sDet = "PSD";
      break;
    }
    case ECbmModuleId::kT0:
    {
      fuTriggerMinT0Digis   = uVal;
      sDet = "T0";
      break;
    }
    default:
    {
      LOG( fatal ) << "CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerMinNumber => "
                   << "Unsupported or unknow detector enum";
      break;
    }
  } // switch( det )

  LOG( debug ) << "Set Trigger min limit for " << sDet << " to " << uVal;
}
void CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerWindow( ECbmModuleId det, Double_t dWinBeg, Double_t dWinEnd )
{
  /// Check if valid time window: end strictly after beginning
  if( dWinEnd <= dWinBeg )
    LOG( fatal ) << "CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerWindow => Invalid time window: [ "
                 << dWinBeg << ", " << dWinEnd << " ]";

  std::string sDet = "";
  /// Store in corresponding members
  switch( det )
  {
    case ECbmModuleId::kSts:
    {
      fdStsTimeWinBeg  = dWinBeg;
      fdStsTimeWinEnd  = dWinEnd;
      sDet = "STS";
      break;
    }
    case ECbmModuleId::kRich:
    {
      fdRichTimeWinBeg = dWinBeg;
      fdRichTimeWinEnd = dWinEnd;
      sDet = "RICH";
      break;
    }
    case ECbmModuleId::kMuch:
    {
      fdMuchTimeWinBeg = dWinBeg;
      fdMuchTimeWinEnd = dWinEnd;
      sDet = "MUCH";
      break;
    }
    case ECbmModuleId::kTrd:
    {
      fdTrdTimeWinBeg  = dWinBeg;
      fdTrdTimeWinEnd  = dWinEnd;
      sDet = "TRD";
      break;
    }
    case ECbmModuleId::kTof:
    {
      fdTofTimeWinBeg  = dWinBeg;
      fdTofTimeWinEnd  = dWinEnd;
      sDet = "TOF";
      break;
    }
    case ECbmModuleId::kPsd:
    {
      fdPsdTimeWinBeg  = dWinBeg;
      fdPsdTimeWinEnd  = dWinEnd;
      sDet = "PSD";
      break;
    }
    case ECbmModuleId::kT0:
    {
      fdT0TimeWinBeg   = dWinBeg;
      fdT0TimeWinEnd   = dWinEnd;
      sDet = "T0";
      break;
    }
    default:
    {
      LOG( fatal ) << "CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerWindow => "
                   << "Unsupported or unknow detector enum";
      break;
    }
  } // switch( det )

  LOG( debug ) << "Set Trigger window for " << sDet
               << " to [ " << dWinBeg << "; " << dWinEnd << " ]";

  /// Update the variables storing the earliest and latest time window boundaries
  UpdateTimeWinBoundariesExtrema();
  /// Update the variable storing the size if widest time window for overlap detection
  UpdateWidestTimeWinRange();
}
void CbmMcbm2019TimeWinEventBuilderAlgo::UpdateTimeWinBoundariesExtrema()
{
  fdEarliestTimeWinBeg = std::min( fdStsTimeWinBeg,  std::min(
                                   fdMuchTimeWinBeg, std::min(
                                   fdTrdTimeWinBeg,  std::min(
                                   fdTofTimeWinBeg,  std::min(
                                   fdRichTimeWinBeg, std::min(
                                   fdPsdTimeWinBeg,
                                   fdT0TimeWinBeg    ) ) ) ) ) );
  fdLatestTimeWinEnd = std::max( fdStsTimeWinEnd,  std::max(
                                   fdMuchTimeWinEnd, std::max(
                                   fdTrdTimeWinEnd,  std::max(
                                   fdTofTimeWinEnd,  std::max(
                                   fdRichTimeWinEnd, std::max(
                                   fdPsdTimeWinEnd,
                                   fdT0TimeWinEnd    ) ) ) ) ) );
}
void CbmMcbm2019TimeWinEventBuilderAlgo::UpdateWidestTimeWinRange()
{
  Double_t fdStsTimeWinRange  = fdStsTimeWinEnd  - fdStsTimeWinBeg;
  Double_t fdMuchTimeWinRange = fdMuchTimeWinEnd - fdMuchTimeWinBeg;
  Double_t fdTrdTimeWinRange  = fdTrdTimeWinEnd  - fdTrdTimeWinBeg;
  Double_t fdTofTimeWinRange  = fdTofTimeWinEnd  - fdTofTimeWinBeg;
  Double_t fdRichTimeWinRange = fdRichTimeWinEnd - fdRichTimeWinBeg;
  Double_t fdPsdTimeWinRange  = fdPsdTimeWinEnd  - fdPsdTimeWinBeg;
  Double_t fdT0TimeWinRange   = fdT0TimeWinEnd   - fdT0TimeWinBeg;

  fdWidestTimeWinRange = std::max( fdStsTimeWinRange,  std::max(
                                   fdMuchTimeWinRange, std::max(
                                   fdTrdTimeWinRange,  std::max(
                                   fdTofTimeWinRange,  std::max(
                                   fdRichTimeWinRange, std::max(
                                   fdPsdTimeWinRange,
                                   fdT0TimeWinRange    ) ) ) ) ) );
}
//----------------------------------------------------------------------

ClassImp(CbmMcbm2019TimeWinEventBuilderAlgo)