CbmMcbm2019TimeWinEventBuilderAlgo.cxx

      LOG(warning)
        << "CbmMcbm2019TimeWinEventBuilderAlgo::SetReferenceDetector => "
           "Reference detector already in selection detector list!"
        << refDet;
      LOG(warning)
        << "                                                         => It will "
          "be automatically removed from selection detector list!";
      LOG(warning) << "                                                         "
                      "=> Please also remember to update the selection windows "
                      "to store clusters!";
      RemoveDetector( refDet );
    }  // if( *det  == selDet )
  }  // for( std::vector< ECbmModuleId >::iterator det = fvDets.begin(); det != fvDets.end(); ++det )

  if (fRefDet == refDet) {
    LOG(warning)
      << "CbmMcbm2019TimeWinEventBuilderAlgo::SetReferenceDetector => Doing "
         "nothing, identical reference detector already in use";
  }  // if( fRefDet == refDet )
  else {
    LOG(info) << "CbmMcbm2019TimeWinEventBuilderAlgo::SetReferenceDetector => "
                 "Replacing "
              << fRefDet << " with " << refDet << " as reference detector";
    LOG(warning)
      << "                                                         => You may "
         "want to use AddDetector after this command to add in selection "
      << fRefDet;
    LOG(warning) << "                                                         "
                    "=> Please also remember to update the selection windows!";
  }  // else of if( fRefDet == refDet )
  fRefDet = refDet;
}
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::SetTriggerMaxNumber(
  ECbmModuleId selDet,
  Int_t iVal) {
  /// Store in corresponding members
  std::string sDet = "";
  switch (selDet) {
    case ECbmModuleId::kSts: {
      fiTriggerMaxStsDigis = iVal;
      sDet                 = "STS";
      break;
    }
    case ECbmModuleId::kRich: {
      fiTriggerMaxRichDigis = iVal;
      sDet                  = "RICH";
      break;
    }
    case ECbmModuleId::kMuch: {
      fiTriggerMaxMuchDigis = iVal;
      sDet                  = "MUCH";
      break;
    }
    case ECbmModuleId::kTrd: {
      fiTriggerMaxTrdDigis = iVal;
      sDet                 = "TRD";
      break;
    }
    case ECbmModuleId::kTof: {
      fiTriggerMaxTofDigis = iVal;
      sDet                 = "TOF";
      break;
    }
    case ECbmModuleId::kPsd: {
      fiTriggerMaxPsdDigis = iVal;
      sDet                 = "PSD";
      break;
    }
    case ECbmModuleId::kT0: {
      fiTriggerMaxT0Digis = iVal;
      sDet                = "T0";
      break;
    }
    default: {
      LOG(fatal)
        << "CbmMcbm2019TimeWinEventBuilderAlgo::SetTriggerMaxNumber => "
        << "Unsupported or unknow detector enum";
      break;
    }
  }  // switch( det )

  LOG(debug) << "Set Trigger nax limit for " << sDet << " to " << iVal;
}
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)