L1ThresholdBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCONFDATA_L1THRESHOLDBASE_H
#define TRIGCONFDATA_L1THRESHOLDBASE_H
 
#include "TrigConfData/DataStructure.h"
 
#include <map>
#include <vector>
#include <optional>
 
namespace TrigConf {
 
   unsigned int energyInCounts(unsigned int energyMeV, unsigned int energyResolutionMeV);
 
   template<class T>
   class ValueWithEtaDependence {
      class RangeValue {
      public:
         RangeValue(const T & value, int etaMin, int etaMax, unsigned int priority, bool symmetric);
         const T & value() const { return m_value; }
         int etaMin() const { return m_etaMin; };
         int etaMax() const { return m_etaMax; };
         unsigned int priority() const { return m_priority; }
         bool symmetric() const { return m_symmetric; }
      private:
         T m_value {}; // the value (energy, set of isolation variables) 
         int m_etaMin { -49 }; // range boundaries, always inclusive
         int m_etaMax {  49 }; // etaMin is always smaller than etaMax, e.g. on the negative side: etaMin=-49, etaMax=-31
         unsigned int m_priority {0}; // higher number has higher priority when resolving overlapping regions 
         bool m_symmetric { true }; // if true, also applies to the opposity side ( requires etaMax to be positive )
      };
   public:
      typedef typename std::vector<RangeValue>::const_iterator const_iterator;
      ValueWithEtaDependence(const std::string& name) : m_name(name) {};
      const std::string & name() const { return m_name; }
      bool empty() const;
      size_t size() const;
      const T & at(int eta) const;
      std::optional<std::reference_wrapper<const T>> outsideRangeValue() const;
      const_iterator begin() const noexcept;
      const_iterator end() const noexcept;
      void addRangeValue(const T & value, int etaMin, int etaMax, unsigned int priority, bool symmetric = true);
      void setOutsideRangeValue(const T & value);
   private:
      const std::string m_name {""};
      std::vector<RangeValue> m_rangeValues{};
      std::optional<T> m_outsideRangeValue {std::nullopt};
   };
 
 
 
   class L1ThrExtraInfoBase : public DataStructure {
   public:
 
      static std::unique_ptr<L1ThrExtraInfoBase> createExtraInfo(const std::string & thrTypeName, const ptree & data);
 
      // Constructors
      L1ThrExtraInfoBase() = delete;
      L1ThrExtraInfoBase(const L1ThrExtraInfoBase &) = delete;
      L1ThrExtraInfoBase& operator=(const L1ThrExtraInfoBase&) = delete;
      L1ThrExtraInfoBase(L1ThrExtraInfoBase&&) = default;
      L1ThrExtraInfoBase& operator=(L1ThrExtraInfoBase&&) = default;
      virtual ~L1ThrExtraInfoBase() override = default;
 
      // Constructor initialized with configuration data 
      // @param data The data containing the L1 menu 
      //
      L1ThrExtraInfoBase(const std::string & thrTypeName, const ptree & data);
 
      virtual std::string className() const override {
         return "L1ThrExtraInfoBase";
      }
 
      const std::string & thresholdTypeName() const;
 
      bool hasExtraInfo( const std::string & key = "") const;
 
      std::optional<std::reference_wrapper<const TrigConf::DataStructure>>
      getExtraInfo( const std::string & key) const;
 
      unsigned int resolutionMeV() const { 
         return m_resolutionMeV;
      }
 
   protected:
      virtual void update() override {
         load();
      } 
      std::map<std::string, DataStructure> m_extraInfo{};
 
   private:
      // load the internal members
      void load();
 
      unsigned int m_resolutionMeV { 1000 }; // default resolution is 1 GeV
   };
 
 
 
   class L1Threshold : public DataStructure {
   public:
      
      static std::shared_ptr<L1Threshold> createThreshold( const std::string & name, const std::string & type, 
                                                           std::weak_ptr<L1ThrExtraInfoBase> extraInfo, const ptree & data );
 
      L1Threshold() = default;
      
      L1Threshold( const std::string & name, const std::string & type,
                   std::weak_ptr<L1ThrExtraInfoBase> extraInfo, const ptree & data);
 
      virtual ~L1Threshold() override = default;
 
      virtual std::string className() const override
      { return "L1Threshold"; }
 
      const std::string & type() const
      { return m_type; }
 
      unsigned int mapping() const
      { return m_mapping; }
 
      virtual float thrValue(int eta = 0) const;
 
   protected:
 
      virtual void update() override;
 
      std::weak_ptr<L1ThrExtraInfoBase> m_extraInfo;
 
   private:
 
      void load();
 
      std::string m_type{""}; 
      unsigned int m_mapping{0}; 
   };
 
 
   class L1Threshold_Calo : public L1Threshold {
   public:
 
      L1Threshold_Calo() = delete;
      
      L1Threshold_Calo( const std::string & name, const std::string & type,
                        std::weak_ptr<L1ThrExtraInfoBase> extraInfo, const ptree & data);
 
      virtual ~L1Threshold_Calo() override = default;
 
      // Accessors to the threshold value for eta-dependent threholds
 
      /* @brief Accessor to the threshold value in GeV
       * @param eta the eta value should be given for potentially eta-dependent thresholds
       * @returns threshold in GeV
       */
      virtual float thrValue(int eta = 0) const override;
 
      /* @brief Accessor to the threshold value in energy units
       * @param eta the eta value should be given for potentially eta-dependent thresholds
       * @returns threshold in energy units
       */
      virtual unsigned int thrValueCounts(int eta = 0) const;
 
      /* @brief Accessor to the threshold value in MeV
       * @param eta the eta value should be given for potentially eta-dependent thresholds
       * @returns threshold in MeV
       */
      virtual unsigned int thrValueMeV(int eta = 0) const;
 
      virtual unsigned int thrValue100MeV(int eta = 0) const;
 
      virtual ValueWithEtaDependence<float> thrValues() const;
 
      virtual const ValueWithEtaDependence<unsigned int> & thrValuesMeV() const;      
 
      virtual ValueWithEtaDependence<unsigned int> thrValues100MeV() const;
 
      virtual ValueWithEtaDependence<unsigned int> thrValuesCounts() const;      
 
   protected:
 
      virtual void update() override;
 
      std::string m_input{""};
 
      // internally the threshold cuts are represented in MeV
      // - it is human readible
      // - integer are preferred over float by the L1Calo/L1Calo firmware experts
      // - GeV is not possible as we would like to support cuts with finer granularity than GeV
 
      unsigned int m_thrValue {0}; 
 
      ValueWithEtaDependence<unsigned int> m_etaDepThrValue{""}; 
 
   private:
      void load();
   };
 
   /******************************************
    * Isolation for legacy L1Calo thresholds
    ******************************************/
   class IsolationLegacy {
   public:
      IsolationLegacy() = default;
      IsolationLegacy( const boost::property_tree::ptree & );
      bool isDefined()   const { return m_isDefined; } 
      int isobit()       const { return m_isobit; } 
      int offset()       const { return m_offset; }
      int slope()        const { return m_slope; }
      int mincut()       const { return m_mincut; }
      int upperlimit()   const { return m_upperlimit; }
      int etamin()       const { return m_etamin; }
      int etamax()       const { return m_etamax; }
      int priority()     const { return m_priority; }
   private:
      bool m_isDefined { false };
      int m_isobit { 0 };
      int m_offset { 0 };
      int m_slope { 0 };
      int m_mincut { 0 };
      int m_upperlimit { 0 };
      int m_etamin { 0 };
      int m_etamax { 0 };
      int m_priority { 0 };
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::IsolationLegacy & iso);
 
 
   /**************************************
    * Selection points for L1Calo thresholds
    **************************************/
   class Selection {
   public:
      enum class WP { 
         NONE = 0,
     LOOSE = 1, MEDIUM = 2, TIGHT = 3, 
     HADLOOSE = 4, HADMEDIUM = 5, HADTIGHT = 6, HAD = 7, // HAD = HADMEDIUM for backward compatibility
 
     // cTAU-specific WPs
         LOOSE12 = 8, LOOSE20 = 9, LOOSE30 = 10, LOOSE35 = 11,
         MEDIUM12 = 12, MEDIUM20 = 13, MEDIUM30 = 14, MEDIUM35 = 15,
         TIGHT12 = 16, TIGHT20 = 17, TIGHT30 = 18, TIGHT35 = 19
      };
      static std::string wpToString(WP);
      static WP stringToWP(const std::string &);
   };
}
 
#include "TrigConfData/L1ThresholdBase.icc"
 
#endif