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>
 
/* basf2 headers */
#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>
 
/* C++ headers */
#include <cstdint>
 
namespace Belle2::HLTPrefilter {

  class TimingCutState {
  private:

    StoreObjPtr<EventLevelTriggerTimeInfo> m_TTDInfo;

    DBObjPtr<BunchStructure> m_bunchStructure; 

    DBObjPtr<HardwareClockSettings> m_clockSettings; 
 
  public:
    double LERtimeSinceLastInjectionMin = 0.0;
    double LERtimeSinceLastInjectionMax = 0.0;
    double HERtimeSinceLastInjectionMin = 0.0;
    double HERtimeSinceLastInjectionMax = 0.0;
    double LERtimeInBeamCycleMin        = 0.0;
    double LERtimeInBeamCycleMax        = 0.0;
    double HERtimeInBeamCycleMin        = 0.0;
    double HERtimeInBeamCycleMax        = 0.0;
    unsigned int prescale = 1000;
 
    bool computeDecision()
    {
      if (m_TTDInfo.isValid()) {
        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);
 
        // Tag events inside injection strip with a prescale
        return (LER_strip || HER_strip) && !SoftwareTrigger::makePreScale(prescale);
      } else
        return false;
    }
  };

  class CDCECLCutState {
  private:

    StoreArray<CDCHit> m_cdcHits;

    StoreArray<ECLDigit> m_eclDigits;
 
  public:
    uint32_t nCDCHitsMax   = 0.0;
    uint32_t nECLDigitsMax = 0.0;
    unsigned int prescale = 1000;
 
    bool computeDecision()
    {
      const uint32_t nCDCHits = m_cdcHits.isOptional() ? m_cdcHits.getEntries() : 0;
      const uint32_t nECLDigits = m_eclDigits.isOptional() ? m_eclDigits.getEntries() : 0;
 
      // Tag events having a large CDC and ECL occupancy with a prescale
      return (nCDCHits > nCDCHitsMax && nECLDigits > nECLDigitsMax) && !SoftwareTrigger::makePreScale(prescale);
    }
 
  };
 
}