L1ThrExtraInfo.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCONFDATA_L1THREXTRAINFO_H
#define TRIGCONFDATA_L1THREXTRAINFO_H
 
#include "TrigConfData/DataStructure.h"
#include "TrigConfData/L1ThresholdBase.h"
 
#include <map>
#include <vector>
#include <iostream>
 
namespace TrigConf {
 
   class L1ThrExtraInfoBase;
   class L1ThrExtraInfo_EMTAULegacy;
   class L1ThrExtraInfo_JETLegacy;
   class L1ThrExtraInfo_XSLegacy;
   class L1ThrExtraInfo_eEM;
   class L1ThrExtraInfo_jEM;
   class L1ThrExtraInfo_eTAU;
   class L1ThrExtraInfo_jTAU;
   class L1ThrExtraInfo_cTAU;
   class L1ThrExtraInfo_jJ;
   class L1ThrExtraInfo_jLJ;
   class L1ThrExtraInfo_gJ;
   class L1ThrExtraInfo_gLJ;
   class L1ThrExtraInfo_gXE;
   class L1ThrExtraInfo_jXE;
   class L1ThrExtraInfo_cXE;
   class L1ThrExtraInfo_gTE;
   class L1ThrExtraInfo_jTE;
   class L1ThrExtraInfo_MU;
 
   class L1ThrExtraInfo {
   public:
      static std::unique_ptr<L1ThrExtraInfoBase> createExtraInfo(const std::string & thrTypeName, const boost::property_tree::ptree & data);
 
      std::weak_ptr<TrigConf::L1ThrExtraInfoBase> addExtraInfo(const std::string & thrTypeName, const boost::property_tree::ptree & data);
 
      const L1ThrExtraInfo_EMTAULegacy & EM() const;
      const L1ThrExtraInfo_EMTAULegacy & TAU() const;
      const L1ThrExtraInfo_JETLegacy & JET() const;
      const L1ThrExtraInfo_XSLegacy & XS() const;
      const L1ThrExtraInfo_eEM & eEM() const;
      const L1ThrExtraInfo_jEM & jEM() const;
      const L1ThrExtraInfo_eTAU & eTAU() const;
      const L1ThrExtraInfo_jTAU & jTAU() const;
      const L1ThrExtraInfo_cTAU & cTAU() const;
      const L1ThrExtraInfo_jJ & jJ() const;
      const L1ThrExtraInfo_gJ & gJ() const;
      const L1ThrExtraInfo_gLJ & gLJ() const;
      const L1ThrExtraInfo_jLJ & jLJ() const;
      const L1ThrExtraInfo_gXE & gXE() const;
      const L1ThrExtraInfo_jXE & jXE() const;
      const L1ThrExtraInfo_gTE & gTE() const;
      const L1ThrExtraInfo_cXE & cXE() const;
      const L1ThrExtraInfo_jTE & jTE() const;
      const L1ThrExtraInfo_MU & MU() const;
 
      const L1ThrExtraInfoBase & thrExtraInfo(const std::string & thrTypeName) const;
 
      bool hasInfo(const std::string & typeName) const;
 
      void clear();
 
   private:
      // map from threshold type to L1ThrExtraInfo object
      std::map<std::string, std::shared_ptr<TrigConf::L1ThrExtraInfoBase>> m_thrExtraInfo{};
      std::shared_ptr<TrigConf::L1ThrExtraInfoBase> m_emptyInfo{ nullptr };
   };
 
 
 
   class L1ThrExtraInfo_EMTAULegacy final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_EMTAULegacy(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_EMTAULegacy() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_EMTAULegacy"; }
      unsigned int emScale() const { return 1000 / resolutionMeV(); }
      float ptMinToTopo() const { return m_ptMinToTopoMeV/1000.0f; }
      unsigned int ptMinToTopoMeV() const { return m_ptMinToTopoMeV; }
      unsigned int ptMinToTopoCounts() const { return energyInCounts( m_ptMinToTopoMeV, resolutionMeV() ); }
      const IsolationLegacy & isolation(const std::string & thrType, size_t bit) const;
   private:
      void load();
      unsigned int m_ptMinToTopoMeV{0}; // in MeV
      std::map<std::string,std::vector<IsolationLegacy>> m_isolation{};
   };
 
 
   class L1ThrExtraInfo_JETLegacy final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_JETLegacy(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_JETLegacy() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_JETLegacy"; }
      unsigned int jetScale() const { return 1000 / resolutionMeV(); }
      double ptMinToTopoLargeWindow() const { return m_ptMinToTopoLargeWindowMeV / 1000.0; }
      double ptMinToTopoSmallWindow() const { return m_ptMinToTopoSmallWindowMeV / 1000.0; }
      unsigned int ptMinToTopoLargeWindowMeV() const { return m_ptMinToTopoLargeWindowMeV; }
      unsigned int ptMinToTopoSmallWindowMeV() const { return m_ptMinToTopoSmallWindowMeV; }
      unsigned int ptMinToTopoLargeWindowCounts() const { return energyInCounts( m_ptMinToTopoLargeWindowMeV, resolutionMeV() ); }
      unsigned int ptMinToTopoSmallWindowCounts() const { return energyInCounts( m_ptMinToTopoSmallWindowMeV, resolutionMeV() ); }
   private:
      void load();
      unsigned int m_ptMinToTopoLargeWindowMeV{0};
      unsigned int m_ptMinToTopoSmallWindowMeV{0};
   };
 
 
   class L1ThrExtraInfo_XSLegacy final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_XSLegacy(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_XSLegacy() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_XSLegacy"; }
      unsigned int xeMin() const { return m_xeMin; };
      unsigned int xeMax() const { return m_xeMax; };
      unsigned int teSqrtMin() const { return m_teSqrtMin; };
      unsigned int teSqrtMax() const { return m_teSqrtMax; };
      unsigned int xsSigmaScale() const { return m_xsSigmaScale; };
      unsigned int xsSigmaOffset() const { return m_xsSigmaOffset; };
   private:
      void load();
      unsigned int m_xeMin{0};
      unsigned int m_xeMax{0};
      unsigned int m_teSqrtMin{0};
      unsigned int m_teSqrtMax{0};
      unsigned int m_xsSigmaScale{0}; 
      unsigned int m_xsSigmaOffset{0};
   };
 
 
   /***********************************
    * Extra info for new thresholds
    ***********************************/
   class L1ThrExtraInfo_eEM final : public L1ThrExtraInfoBase {
   public:
      class WorkingPoints_eEM {
      public:
         WorkingPoints_eEM() = default;
         WorkingPoints_eEM( const boost::property_tree::ptree & );
         bool isDefined() const { return m_isDefined; } 
         int reta_fw()       const { return m_reta_fw; } 
         int wstot_fw()      const { return m_wstot_fw; }
         int rhad_fw()       const { return m_rhad_fw; }
         float reta_d()       const { return m_reta_d; } 
         float wstot_d()     const { return m_wstot_d; }
         float rhad_d()       const { return m_rhad_d; }
      private:
         bool m_isDefined { false };
         float m_reta_d { 0 };
         float m_wstot_d { 0 };
         float m_rhad_d { 0 };
         int   m_reta_fw { 0 };
         int   m_wstot_fw { 0 };
         int   m_rhad_fw { 0 };
      };
      L1ThrExtraInfo_eEM(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_eEM() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_eEM"; }
      unsigned int maxEtMeV()  const { return m_maxEt; }
      unsigned int maxEtCounts(const unsigned int resolutionMeV)  const { return TrigConf::energyInCounts( m_maxEt, resolutionMeV ); }
      float maxEt()  const { return m_maxEt/1000.0f; }
      float ptMinToTopo() const { return m_ptMinToTopoMeV/1000.0f; }
      unsigned int ptMinToTopoMeV() const { return m_ptMinToTopoMeV; }
      unsigned int ptMinToTopoCounts() const { return energyInCounts( m_ptMinToTopoMeV, resolutionMeV() ); }
      const WorkingPoints_eEM & isolation(TrigConf::Selection::WP wp, int eta) const { return m_isolation.at(wp).at(eta); }
      const ValueWithEtaDependence<WorkingPoints_eEM> & isolation(TrigConf::Selection::WP wp) const { return m_isolation.at(wp); }
      unsigned int algoVersion() const { return m_algoVersion; }
   private:
      void load();
      unsigned int m_ptMinToTopoMeV{0};
      unsigned int m_maxEt { 0 };
      std::map<TrigConf::Selection::WP, ValueWithEtaDependence<WorkingPoints_eEM>> m_isolation{};
      unsigned int m_algoVersion { 0 };
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::L1ThrExtraInfo_eEM::WorkingPoints_eEM & iso);
 
   class L1ThrExtraInfo_jEM final : public L1ThrExtraInfoBase {
   public:
      class WorkingPoints_jEM {
      public:
         WorkingPoints_jEM() = default;
         WorkingPoints_jEM( const boost::property_tree::ptree & );
         bool isDefined() const { return m_isDefined; }
         int iso_fw()       const { return m_iso_fw; }
         int frac_fw()      const { return m_frac_fw; }
         int frac2_fw()       const { return m_frac2_fw; }
         float iso_d()       const { return m_iso_d; }
         float frac_d()     const { return m_frac_d; }
         float frac2_d()       const { return m_frac2_d; }
      private:
         bool m_isDefined { false };
         float m_iso_d { 0 };
         float m_frac_d { 0 };
         float m_frac2_d { 0 };
         int   m_iso_fw { 0 };
         int   m_frac_fw { 0 };
         int   m_frac2_fw { 0 };
      };
      L1ThrExtraInfo_jEM(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jEM() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jEM"; }
      const WorkingPoints_jEM & isolation(TrigConf::Selection::WP wp, int eta) const { return m_isolation.at(wp).at(eta); }
      const ValueWithEtaDependence<WorkingPoints_jEM> & isolation(TrigConf::Selection::WP wp) const { return m_isolation.at(wp); }
      unsigned int maxEtMeV()  const { return m_maxEt; }
      unsigned int maxEtCounts(const unsigned int resolutionMeV)  const { return TrigConf::energyInCounts( m_maxEt, resolutionMeV ); }
      float maxEt()  const { return m_maxEt/1000.0f; }
      float ptMinToTopo(const std::string& module) const { return ptMinToTopoMeV(module)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const std::string& module) const { return energyInCounts(ptMinToTopoMeV(module), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinToTopoMeV1;
          if(module=="2C" || module=="2A") return m_ptMinToTopoMeV2;
          if(module=="3C" || module=="3A") return m_ptMinToTopoMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jEM ptMinToTopo");
      }
      float ptMinxTOB(const std::string& module) const { return ptMinxTOBMeV(module)/ 1000.0; }
      unsigned int ptMinxTOBCounts(const std::string& module) const { return energyInCounts(ptMinxTOBMeV(module), resolutionMeV()); }
      unsigned int ptMinxTOBMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinxTOBMeV1;
          if(module=="2C" || module=="2A") return m_ptMinxTOBMeV2;
          if(module=="3C" || module=="3A") return m_ptMinxTOBMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jEM ptMinxTOB");
      }
   private:
      void load();
      unsigned int m_maxEt { 0 };
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
      unsigned int m_ptMinToTopoMeV3{0};
      unsigned int m_ptMinxTOBMeV1{0};
      unsigned int m_ptMinxTOBMeV2{0};
      unsigned int m_ptMinxTOBMeV3{0};
      std::map<TrigConf::Selection::WP, ValueWithEtaDependence<WorkingPoints_jEM>> m_isolation{};
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::L1ThrExtraInfo_jEM::WorkingPoints_jEM & iso);
 
   class L1ThrExtraInfo_eTAU final : public L1ThrExtraInfoBase {
   public:
      class WorkingPoints_eTAU {
      public:
         WorkingPoints_eTAU( const boost::property_tree::ptree & );
         bool isDefined() const { return m_isDefined; }
         int rCore_fw() const { return m_rCore_fw; }
         float rCore_d() const { return m_rCore_d; }
         int rHad_fw() const { return m_rHad_fw; }
         float rHad_d() const { return m_rHad_d; }
      private:
         bool m_isDefined { false };
         int m_rCore_fw {0};
         int m_rHad_fw {0};
         float m_rCore_d { 0 };
         float m_rHad_d { 0 };      
      };
      L1ThrExtraInfo_eTAU(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_eTAU() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_eTAU"; }
      unsigned int minIsoEtMeV() const { return m_minIsoEt; }
      unsigned int minIsoEtCounts(const unsigned int resolutionMeV) const { return TrigConf::energyInCounts( m_minIsoEt, resolutionMeV ); }
      float minIsoEt() const { return m_minIsoEt/1000.0f; }
      unsigned int maxEtMeV() const { return m_maxEt; }
      unsigned int maxEtCounts(const unsigned int resolutionMeV) const { return TrigConf::energyInCounts( m_maxEt, resolutionMeV ); }
      float maxEt() const { return m_maxEt/1000.0f; }
      float ptMinToTopo() const { return m_ptMinToTopoMeV/1000.0f; }
      unsigned int ptMinToTopoMeV() const { return m_ptMinToTopoMeV; }
      unsigned int ptMinToTopoCounts() const { return energyInCounts( m_ptMinToTopoMeV, resolutionMeV() ); }
      const WorkingPoints_eTAU & isolation(TrigConf::Selection::WP wp, int eta) const { return m_isolation.at(wp).at(eta); }
      const ValueWithEtaDependence<WorkingPoints_eTAU> & isolation(TrigConf::Selection::WP wp) const  { return m_isolation.at(wp); }
      unsigned int algoVersion() const { return m_algoVersion; }
   private:
      void load();
      unsigned int m_minIsoEt { 0 }; // In MeV
      unsigned int m_maxEt { 0 }; // In MeV
      unsigned int m_ptMinToTopoMeV{0};
      std::map<TrigConf::Selection::WP, ValueWithEtaDependence<WorkingPoints_eTAU>> m_isolation{};
      unsigned int m_algoVersion { 0 };
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::L1ThrExtraInfo_eTAU::WorkingPoints_eTAU & iso);
 
   class L1ThrExtraInfo_jTAU final : public L1ThrExtraInfoBase {
   public:
      class WorkingPoints_jTAU {
      public:
         WorkingPoints_jTAU( const boost::property_tree::ptree & );
         bool isDefined() const { return m_isDefined; }
         int isolation_fw() const { return m_isolation_fw; }
         float isolation_d() const { return m_isolation_d; }
      private:
         bool m_isDefined { false };
         int m_isolation_fw {0};
         float m_isolation_d { 0 };
      };
      L1ThrExtraInfo_jTAU(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jTAU() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jTAU"; }
      const WorkingPoints_jTAU & isolation(TrigConf::Selection::WP wp, int eta) const { return m_isolation.at(wp).at(eta); }
      const ValueWithEtaDependence<WorkingPoints_jTAU> & isolation(TrigConf::Selection::WP wp) const  { return m_isolation.at(wp); }
      unsigned int maxEtMeV()  const { return m_maxEt; }
      unsigned int maxEtCounts(const unsigned int resolutionMeV)  const { return TrigConf::energyInCounts( m_maxEt, resolutionMeV ); }
      float maxEt()  const { return m_maxEt/1000.0f; }
      float ptMinToTopo(const std::string& module) const { return ptMinToTopoMeV(module)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const std::string& module) const { return energyInCounts(ptMinToTopoMeV(module), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinToTopoMeV1;
          if(module=="2C" || module=="2A") return m_ptMinToTopoMeV2;
          if(module=="3C" || module=="3A") return m_ptMinToTopoMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jTAU ptMinToTopo");
      }
      float ptMinxTOB(const std::string& module) const { return ptMinxTOBMeV(module)/ 1000.0; }
      unsigned int ptMinxTOBCounts(const std::string& module) const { return energyInCounts(ptMinxTOBMeV(module), resolutionMeV()); }
      unsigned int ptMinxTOBMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinxTOBMeV1;
          if(module=="2C" || module=="2A") return m_ptMinxTOBMeV2;
          if(module=="3C" || module=="3A") return m_ptMinxTOBMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jTAU ptMinxTOB");
      }
   private:
      void load();
      unsigned int m_maxEt { 0 };
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
      unsigned int m_ptMinToTopoMeV3{0};
      unsigned int m_ptMinxTOBMeV1{0};
      unsigned int m_ptMinxTOBMeV2{0};
      unsigned int m_ptMinxTOBMeV3{0};
      std::map<TrigConf::Selection::WP, ValueWithEtaDependence<WorkingPoints_jTAU>> m_isolation{};
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::L1ThrExtraInfo_jTAU::WorkingPoints_jTAU & iso);
 
   class L1ThrExtraInfo_cTAU final : public L1ThrExtraInfoBase {
   public:
      class WorkingPoints_cTAU {
      public:
         WorkingPoints_cTAU( const boost::property_tree::ptree & );
         bool isDefined() const { return m_isDefined; }
         unsigned int isolation_fw() const { return m_isolation_fw; }
         float isolation_d() const { return m_isolation_d; }
         unsigned int isolation_jTAUCoreScale_fw() const { return m_isolation_jTAUCoreScale_fw; }
         float isolation_jTAUCoreScale_d() const { return m_isolation_jTAUCoreScale_d; }
         float eTAU_rCoreMin_WP_d() const { return m_eTAU_rCoreMin_WP_d; }
         unsigned int eTAU_rCoreMin_WP_fw() const { return m_eTAU_rCoreMin_WP_fw; }
         Selection::WP eTAU_rCoreMin_WP() const { return static_cast<Selection::WP>(m_eTAU_rCoreMin_WP_fw); }
         float eTAU_rHadMin_WP_d() const { return m_eTAU_rHadMin_WP_d; }
         unsigned int eTAU_rHadMin_WP_fw() const { return m_eTAU_rHadMin_WP_fw; }
         Selection::WP eTAU_rHadMin_WP() const { return static_cast<Selection::WP>(m_eTAU_rHadMin_WP_fw); }
      private:
         bool m_isDefined {false};
         unsigned int m_isolation_fw {0};
         float m_isolation_d {0};
         unsigned int m_isolation_jTAUCoreScale_fw {0};
         float m_isolation_jTAUCoreScale_d {0};
         float m_eTAU_rCoreMin_WP_d {0};
         unsigned int m_eTAU_rCoreMin_WP_fw {0};
         float m_eTAU_rHadMin_WP_d {0};
         unsigned int m_eTAU_rHadMin_WP_fw {0};
      };
      L1ThrExtraInfo_cTAU(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_cTAU() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_cTAU"; }
      const WorkingPoints_cTAU & isolation(TrigConf::Selection::WP wp, int eta) const { return m_isolation.at(wp).at(eta); }
      const ValueWithEtaDependence<WorkingPoints_cTAU> & isolation(TrigConf::Selection::WP wp) const  { return m_isolation.at(wp); }
   private:
      void load();
      std::map<TrigConf::Selection::WP, ValueWithEtaDependence<WorkingPoints_cTAU>> m_isolation{};
   };
   std::ostream & operator<<(std::ostream & os, const TrigConf::L1ThrExtraInfo_cTAU::WorkingPoints_cTAU & iso);
 
   class L1ThrExtraInfo_jJ final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_jJ(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jJ() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jJ"; }
      float ptMinToTopo(const std::string& module) const { return ptMinToTopoMeV(module)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const std::string& module) const { return energyInCounts(ptMinToTopoMeV(module), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinToTopoMeV1;
          if(module=="2C" || module=="2A") return m_ptMinToTopoMeV2;
          if(module=="3C" || module=="3A") return m_ptMinToTopoMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jJ ptMinToTopo");
      }
      float ptMinxTOB(const std::string& module) const { return ptMinxTOBMeV(module)/ 1000.0; }
      unsigned int ptMinxTOBCounts(const std::string& module) const { return energyInCounts(ptMinxTOBMeV(module), resolutionMeV()); }
      unsigned int ptMinxTOBMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinxTOBMeV1;
          if(module=="2C" || module=="2A") return m_ptMinxTOBMeV2;
          if(module=="3C" || module=="3A") return m_ptMinxTOBMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jJ ptMinxTOB");
      }
      float seedThreshold(const std::string& module) const { return seedThresholdMeV(module)/ 1000.0; }
      unsigned int seedThresholdCounts(const std::string& module) const { return energyInCounts(seedThresholdMeV(module), 25 /*jFEX internal resolution!*/); }
      unsigned int seedThresholdMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_seedThresholdMeV1;
          if(module=="2C" || module=="2A") return m_seedThresholdMeV2;
          if(module=="3C" || module=="3A") return m_seedThresholdMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jJ seedThreshold");
      }
   private:
      void load();
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
      unsigned int m_ptMinToTopoMeV3{0};
      unsigned int m_ptMinxTOBMeV1{0};
      unsigned int m_ptMinxTOBMeV2{0};
      unsigned int m_ptMinxTOBMeV3{0};
      int m_seedThresholdMeV1{-1}; //signed to allow effectively turning off seed thresholding via negative values
      int m_seedThresholdMeV2{-1};
      int m_seedThresholdMeV3{-1};
   };
 
   class L1ThrExtraInfo_jLJ final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_jLJ(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jLJ() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jLJ"; }
      float ptMinToTopo(const std::string& module) const { return ptMinToTopoMeV(module)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const std::string& module) const { return energyInCounts(ptMinToTopoMeV(module), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinToTopoMeV1;
          if(module=="2C" || module=="2A") return m_ptMinToTopoMeV2;
          if(module=="3C" || module=="3A") return m_ptMinToTopoMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jLJ ptMinToTopo");
      }
      float ptMinxTOB(const std::string& module) const { return ptMinxTOBMeV(module)/ 1000.0; }
      unsigned int ptMinxTOBCounts(const std::string& module) const { return energyInCounts(ptMinxTOBMeV(module), resolutionMeV()); }
      unsigned int ptMinxTOBMeV(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_ptMinxTOBMeV1;
          if(module=="2C" || module=="2A") return m_ptMinxTOBMeV2;
          if(module=="3C" || module=="3A") return m_ptMinxTOBMeV3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jLJ ptMinxTOB");
      }
   private:
      void load();
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
      unsigned int m_ptMinToTopoMeV3{0};
      unsigned int m_ptMinxTOBMeV1{0};
      unsigned int m_ptMinxTOBMeV2{0};
      unsigned int m_ptMinxTOBMeV3{0};
   };
 
   class L1ThrExtraInfo_gJ final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_gJ(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_gJ() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_gJ"; }
      float ptMinToTopo(const unsigned int eta_range) const { return ptMinToTopoMeV(eta_range)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const unsigned int eta_range) const { return energyInCounts(ptMinToTopoMeV(eta_range), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const unsigned int eta_range) const {
          if(eta_range==1) return m_ptMinToTopoMeV1;
          if(eta_range==2) return m_ptMinToTopoMeV2;
          throw std::runtime_error("L1ThrExtraInfo: Eta range " + std::to_string(eta_range) + " not valid for gJ ptMinToTopo");
      }
   private:
      void load();
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
   };
 
   class L1ThrExtraInfo_gLJ final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_gLJ(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_gLJ() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_gLJ"; }
      float ptMinToTopo(const unsigned int eta_range) const { return ptMinToTopoMeV(eta_range)/ 1000.0; }
      unsigned int ptMinToTopoCounts(const unsigned int eta_range) const { return energyInCounts(ptMinToTopoMeV(eta_range), resolutionMeV()); }
      unsigned int ptMinToTopoMeV(const unsigned int eta_range) const {
          if(eta_range==1) return m_ptMinToTopoMeV1;
          if(eta_range==2) return m_ptMinToTopoMeV2;
          throw std::runtime_error("L1ThrExtraInfo: Eta range " + std::to_string(eta_range) + " not valid for gLJ ptMinToTopo");
      }
      float seedThr(const char fpga) const { return seedThrMeV(fpga)/ 1000.0; }
      unsigned int seedThrCounts(const char fpga) const { return energyInCounts(seedThrMeV(fpga), resolutionMeV()); }
      unsigned int seedThrMeV(const char fpga) const {
          if(fpga=='A') return m_seedThrMeVA;
          if(fpga=='B') return m_seedThrMeVB;
          if(fpga=='C') return m_seedThrMeVC;
          throw std::runtime_error(std::string("L1ThrExtraInfo: FPGA ") + fpga + " not recongnised for gLJ seedThr");
      }
      float rhoTowerMin(const char fpga) const { return rhoTowerMinMeV(fpga)/ 1000.0; }
      int rhoTowerMinMeV(const char fpga) const {
          if(fpga=='A') return m_rhoTowerMinMeVA;
          if(fpga=='B') return m_rhoTowerMinMeVB;
          if(fpga=='C') return m_rhoTowerMinMeVC;
          throw std::runtime_error(std::string("L1ThrExtraInfo: FPGA ") + fpga + " not recongnised for gLJ rhoTowerMin");
      }
      float rhoTowerMax(const char fpga) const { return rhoTowerMaxMeV(fpga)/ 1000.0; }
      int rhoTowerMaxMeV(const char fpga) const {
          if(fpga=='A') return m_rhoTowerMaxMeVA;
          if(fpga=='B') return m_rhoTowerMaxMeVB;
          if(fpga=='C') return m_rhoTowerMaxMeVC;
          throw std::runtime_error(std::string("L1ThrExtraInfo: FPGA ") + fpga + " not recongnised for gLJ rhoTowerMax");
      }
   private:
      void load();
      unsigned int m_ptMinToTopoMeV1{0};
      unsigned int m_ptMinToTopoMeV2{0};
      unsigned int m_seedThrMeVA{0};
      unsigned int m_seedThrMeVB{0};
      unsigned int m_seedThrMeVC{0};
      int m_rhoTowerMaxMeVA{0};
      int m_rhoTowerMaxMeVB{0};
      int m_rhoTowerMaxMeVC{0};
      int m_rhoTowerMinMeVA{0};
      int m_rhoTowerMinMeVB{0};
      int m_rhoTowerMinMeVC{0};
   };
 
   class L1ThrExtraInfo_jXE final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_jXE(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jXE() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jXE"; }
   private:
      void load();
   };
 
   class L1ThrExtraInfo_jTE final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_jTE(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_jTE() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_jTE"; }
      unsigned int etaBoundary_fw(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_etaBoundary1_fw;
          if(module=="2C" || module=="2A") return m_etaBoundary2_fw;
          if(module=="3C" || module=="3A") return m_etaBoundary3_fw; 
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jTE etaBoundary_fw"); 
      }
      unsigned int etaBoundary(const std::string& module) const {
          if(module=="1C" || module=="1A") return m_etaBoundary1;
          if(module=="2C" || module=="2A") return m_etaBoundary2;
          if(module=="3C" || module=="3A") return m_etaBoundary3;
          throw std::runtime_error("L1ThrExtraInfo: Module" + module + " not recongnised for jTE etaBoundary");
      }
   private:
      void load();
      unsigned int m_etaBoundary1{0}; // eta for module 1A, 1C
      unsigned int m_etaBoundary1_fw{0}; // tower number for module 1A, 1C
      unsigned int m_etaBoundary2{0}; // eta for module 2A, 2C
      unsigned int m_etaBoundary2_fw{0}; // tower number for module 2A, 2C
      unsigned int m_etaBoundary3{0}; // eta for module 3A, 3C
      unsigned int m_etaBoundary3_fw{0}; // tower number for module 3A, 3C
   };
 
   class L1ThrExtraInfo_gXE final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_gXE(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_gXE() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_gXE"; }
      float seedThr(const char fpga) const { return energyInCounts(seedThrMeV(fpga), resolutionMeV()); }//seedThr is defined in counts
      unsigned int seedThrCounts(const char fpga) const { return energyInCounts(seedThrMeV(fpga), resolutionMeV()); }
      unsigned int seedThrMeV(const char fpga) const {
          if(fpga=='A') return m_seedThrMeVA;
          if(fpga=='B') return m_seedThrMeVB;
          if(fpga=='C') return m_seedThrMeVC;
          throw std::runtime_error(std::string("L1ThrExtraInfo: FPGA ") + fpga + " not recongnised for gXE seedThr");
      }
      unsigned int XERHO_param(const char fpga, const bool sigmapos) const {
          if(fpga=='A' && sigmapos==true) return m_XERHO_sigmaPosA;
          if(fpga=='B' && sigmapos==true) return m_XERHO_sigmaPosB;
          if(fpga=='C' && sigmapos==true) return m_XERHO_sigmaPosC;
          if(fpga=='A' && sigmapos==false) return m_XERHO_sigmaNegA;
          if(fpga=='B' && sigmapos==false) return m_XERHO_sigmaNegB;
          if(fpga=='C' && sigmapos==false) return m_XERHO_sigmaNegC;
          throw std::runtime_error(std::string("L1ThrExtraInfo: ") + fpga + " and " + (sigmapos ? "pos" : "neg") + " not recongnised for gXE XERHO_param");
      }
      unsigned int JWOJ_param(const char fpga, const char param) const {
          if(fpga=='A' && param=='a') return m_XEJWOJ_a_A;
          if(fpga=='B' && param=='a') return m_XEJWOJ_a_B;
          if(fpga=='C' && param=='a') return m_XEJWOJ_a_C;
          if(fpga=='A' && param=='b') return m_XEJWOJ_b_A;
          if(fpga=='B' && param=='b') return m_XEJWOJ_b_B;
          if(fpga=='C' && param=='b') return m_XEJWOJ_b_C;
          if(fpga=='A' && param=='c') return m_XEJWOJ_c_A;
          if(fpga=='B' && param=='c') return m_XEJWOJ_c_B;
          if(fpga=='C' && param=='c') return m_XEJWOJ_c_C;
          throw std::runtime_error(std::string("L1ThrExtraInfo: ") + fpga + " and " + param  + " not recongnised for gXE JWOJ_param");
      }
   private:
      void load();
      unsigned int m_XERHO_sigmaPosA{0};
      unsigned int m_XERHO_sigmaPosB{0};
      unsigned int m_XERHO_sigmaPosC{0};
      unsigned int m_XERHO_sigmaNegA{0};
      unsigned int m_XERHO_sigmaNegB{0};
      unsigned int m_XERHO_sigmaNegC{0};
      unsigned int m_seedThrMeVA{0};
      unsigned int m_seedThrMeVB{0};
      unsigned int m_seedThrMeVC{0};
      unsigned int m_XEJWOJ_a_A{0};
      unsigned int m_XEJWOJ_a_B{0};
      unsigned int m_XEJWOJ_a_C{0};
      unsigned int m_XEJWOJ_b_A{0};
      unsigned int m_XEJWOJ_b_B{0};
      unsigned int m_XEJWOJ_b_C{0};
      unsigned int m_XEJWOJ_c_A{0};
      unsigned int m_XEJWOJ_c_B{0};
      unsigned int m_XEJWOJ_c_C{0};
   };
 
   class L1ThrExtraInfo_gTE final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_gTE(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_gTE() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_gTE"; }
   private:
      void load();
   };
   
   class L1ThrExtraInfo_cXE final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_cXE(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_cXE() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_cXE"; }
      float jXeWeight() const { return m_jXeWeight; }
      float gXeWeight() const { return m_gXeWeight; }
   private:
      void load();
      // weights/coefficients for jXE and gXE contributions to cXE
      float m_jXeWeight{0.}; 
      float m_gXeWeight{0.};
   };
   
   class L1ThrExtraInfo_MU final : public L1ThrExtraInfoBase {
   public:
      L1ThrExtraInfo_MU(const std::string & thrTypeName, const ptree & data) :
         L1ThrExtraInfoBase(thrTypeName, data) { load(); }
      virtual ~L1ThrExtraInfo_MU() override = default;
      virtual std::string className() const override { return "L1ThrExtraInfo_MU"; }
      unsigned int rpcIdxForPt(unsigned int pt) const;
      unsigned int tgcIdxForPt(unsigned int pt) const;
      unsigned int ptForRpcIdx(unsigned int idx) const;
      unsigned int ptForTgcIdx(unsigned int idx) const;
      unsigned int tgcIdxForRpcIdx(unsigned int rpcIdx) const; // this maps the rpc idx to the tgc idx for the same pt value
      std::vector<unsigned int> knownRpcPtValues() const;
      std::vector<unsigned int> knownTgcPtValues() const;
      std::vector<std::string> exclusionListNames() const;
      const std::map<std::string, std::vector<unsigned int>> & exclusionList(const std::string & listName) const;
   private:
      void load();
      std::map<unsigned int, unsigned int> m_rpcPtMap; // map of pt value (1..~20) to road index (0..5)
      std::map<unsigned int, unsigned int> m_tgcPtMap; // map of pt value (1..~30) to road index (0..15)
      std::map<std::string, std::map<std::string, std::vector<unsigned int>>> m_roiExclusionLists; // named lists of excluded rois
   };
 
}
 
#endif