HLTPrefilter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
/* HLT headers */
#include <hlt/softwaretrigger/core/utilities.h>
#include <hlt/dbobjects/HLTPrefilterParameters.h>
 
/* basf2 headers */
#include <svd/dataobjects/SVDShaperDigit.h>
#include <cdc/dataobjects/CDCHit.h>
#include <ecl/dataobjects/ECLDigit.h>
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <framework/dbobjects/BunchStructure.h>
#include <framework/dbobjects/HardwareClockSettings.h>
#include <mdst/dataobjects/EventLevelTriggerTimeInfo.h>
#include <mdst/dataobjects/TRGSummary.h>
#include <reconstruction/dbobjects/EventsOfDoomParameters.h>
 
/* C++ headers */
#include <cstdint>
 
namespace Belle2::HLTPrefilter {

  class TimingCutState {
  private:

    StoreObjPtr<TRGSummary> m_l1Trigger;

    DBObjPtr<HLTPrefilterParameters> m_hltPrefilterParameters; 

    StoreObjPtr<EventLevelTriggerTimeInfo> m_TTDInfo;

    DBObjPtr<BunchStructure> m_bunchStructure; 

    DBObjPtr<HardwareClockSettings> m_clockSettings; 
 
  public:
 
    bool computeDecision()
    {
      if (m_TTDInfo.isValid() && m_hltPrefilterParameters.isValid() && m_l1Trigger.isValid()) {
 
        // Injection Timing mode thresholds
        const double LERtimeSinceLastInjectionMin = m_hltPrefilterParameters->getLERtimeSinceLastInjectionMin();
        const double LERtimeSinceLastInjectionMax = m_hltPrefilterParameters->getLERtimeSinceLastInjectionMax();
        const double HERtimeSinceLastInjectionMin = m_hltPrefilterParameters->getHERtimeSinceLastInjectionMin();
        const double HERtimeSinceLastInjectionMax = m_hltPrefilterParameters->getHERtimeSinceLastInjectionMax();
        const double LERtimeInBeamCycleMin        = m_hltPrefilterParameters->getLERtimeInBeamCycleMin();
        const double LERtimeInBeamCycleMax        = m_hltPrefilterParameters->getLERtimeInBeamCycleMax();
        const double HERtimeInBeamCycleMin        = m_hltPrefilterParameters->getHERtimeInBeamCycleMin();
        const double HERtimeInBeamCycleMax        = m_hltPrefilterParameters->getHERtimeInBeamCycleMax();

        const double revolutionTime = m_bunchStructure->getRFBucketsPerRevolution() * 1e-3 /
                                      m_clockSettings->getAcceleratorRF(); // [microsecond]
        const double globalClock = m_clockSettings->getGlobalClockFrequency() * 1e3; // [microsecond]
        // Calculate time since last injection
        const double timeSinceLastInj = m_TTDInfo->getTimeSinceLastInjection() / globalClock; // [microsecond]
        // Calculate time in beam cycle
        const double timeInBeamCycle = timeSinceLastInj - (int)(timeSinceLastInj / revolutionTime) * revolutionTime; // [microsecond]
 
        // Check if events are in injection strip of LER
        const bool LER_strip = (LERtimeSinceLastInjectionMin < timeSinceLastInj &&
                                timeSinceLastInj < LERtimeSinceLastInjectionMax &&
                                LERtimeInBeamCycleMin < timeInBeamCycle &&
                                timeInBeamCycle < LERtimeInBeamCycleMax);
 
        // Check if events are in injection strip of HER
        const bool HER_strip = (HERtimeSinceLastInjectionMin < timeSinceLastInj &&
                                timeSinceLastInj < HERtimeSinceLastInjectionMax &&
                                HERtimeInBeamCycleMin < timeInBeamCycle &&
                                timeInBeamCycle < HERtimeInBeamCycleMax);
 
        //find out if we are in the passive veto or in the active veto window
        bool inActiveInjectionVeto = false; //events accepted in the passive veto window but not in the active
        try {
          if (m_l1Trigger->testInput("passive_veto") == 1 &&  m_l1Trigger->testInput("cdcecl_veto") == 0)
            inActiveInjectionVeto = true; //events in active veto
        } catch (const std::exception&) {
        }
 
        if (inActiveInjectionVeto && (LER_strip || HER_strip))
          B2WARNING("Skip event if HLTPrefilter On --> Event tagged by HLTPrefilter as injection background");
 
        // Tag events from active veto inside injection strip with a prescale
        return inActiveInjectionVeto && (LER_strip || HER_strip);
      } else
        return false;
    }
  };

  class CDCECLCutState {
  private:

    StoreObjPtr<TRGSummary> m_l1Trigger;

    DBObjPtr<HLTPrefilterParameters> m_hltPrefilterParameters; 

    StoreArray<CDCHit> m_cdcHits;

    StoreArray<ECLDigit> m_eclDigits;
 
  public:
 
    bool computeDecision()
    {
      if (m_hltPrefilterParameters.isValid() && m_l1Trigger.isValid()) {
 
        // CDC-ECL mode thresholds
        const uint32_t nCDCHitsMax = m_hltPrefilterParameters->getCDCHitsMax();
        const uint32_t nECLDigitsMax = m_hltPrefilterParameters->getECLDigitsMax();

        const uint32_t nCDCHits = m_cdcHits.isOptional() ? m_cdcHits.getEntries() : 0;
        const uint32_t nECLDigits = m_eclDigits.isOptional() ? m_eclDigits.getEntries() : 0;
 
        //find out if we are in the passive veto or in the active veto window
        bool inActiveInjectionVeto = false; //events accepted in the passive veto window but not in the active
        try {
          if (m_l1Trigger->testInput("passive_veto") == 1 &&  m_l1Trigger->testInput("cdcecl_veto") == 0)
            inActiveInjectionVeto = true; //events in active veto
        } catch (const std::exception&) {
        }
 
        if (inActiveInjectionVeto && (nCDCHits > nCDCHitsMax && nECLDigits > nECLDigitsMax))
          B2WARNING("Skip event if HLTPrefilter On --> Event tagged by HLTPrefilter as high CDC-ECL occupancy");
 
        // Tag events having a large CDC and ECL occupancy with a prescale
        return inActiveInjectionVeto && (nCDCHits > nCDCHitsMax && nECLDigits > nECLDigitsMax);
      } else
        return false;
    }
 
  };

  class EventsOfDoomBusterState {
  private:
    StoreArray<CDCHit> m_cdcHits;
    StoreArray<SVDShaperDigit> m_svdShaperDigits;
    DBObjPtr<EventsOfDoomParameters> m_eventsOfDoomParameters;
 
  public:
 
    bool computeDecision()
    {
      if (m_eventsOfDoomParameters.isValid()) {
 
        // EventsOfDoomBuster mode thresholds
        const uint32_t nCDCHitsMax = m_eventsOfDoomParameters->getNCDCHitsMax();
        const uint32_t nSVDShaperDigitsMax = m_eventsOfDoomParameters->getNSVDShaperDigitsMax();

        const uint32_t nCDCHits = m_cdcHits.isOptional() ? m_cdcHits.getEntries() : 0;
        const uint32_t nSVDShaperDigits = m_svdShaperDigits.isOptional() ? m_svdShaperDigits.getEntries() : 0;
 
        const bool doomCDC = nCDCHits > nCDCHitsMax;
        const bool doomSVD = nSVDShaperDigits > nSVDShaperDigitsMax;
 
        if (doomCDC) {
          B2ERROR("Skip event --> Too much occupancy from CDC for reconstruction!" <<
                  LogVar("nCDCHits", nCDCHits) <<
                  LogVar("nCDCHitsMax", nCDCHitsMax));
        }
 
        if (doomSVD) {
          B2ERROR("Skip event --> Too much occupancy from SVD for reconstruction!" <<
                  LogVar("nSVDShaperDigits", nSVDShaperDigits) <<
                  LogVar("nSVDShaperDigitsMax", nSVDShaperDigitsMax));
        }
 
        // Tag events having a large SVD or CDC occupancy
        return (doomCDC || doomSVD);
      } else
        return false;
    }
 
  };
 
}