L1TriggerTowerTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
// L1TriggerTowerTool.h, 
 
 /***************************************************************************
  *                                                                         *
  *                                                                         *
  ***************************************************************************/
 
#ifndef L1TRIGGERTOWERTOOL_H
#define L1TRIGGERTOWERTOOL_H
 
#include <any>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
#include "TrigT1CaloToolInterfaces/IL1TriggerTowerTool.h"
#include "xAODTrigL1Calo/TriggerTowerContainer.h"
#include "xAODEventInfo/EventInfo.h"
#include "StoreGate/ReadHandleKey.h"
#include "TrigConfData/L1Menu.h"
#include "CxxUtils/checker_macros.h"
 
#include "TrigT1CaloCalibConditions/L1CaloRunParametersContainer.h"
#include "TrigT1CaloCalibConditions/L1CaloPpmFineTimeRefsContainer.h"
#include "TrigT1CaloCalibConditions/L1CaloPprConditionsContainerRun2.h"
#include "TrigT1CaloCalibConditions/L1CaloPprDisabledChannelContainerRun2.h"
 
class CaloIdManager;
class CaloLVL1_ID;
class CaloTriggerTowerService;
class Incident;
 
 
 
 
namespace LVL1
{
  class IL1CaloMappingTool;
  class IL1CaloTTIdTools;
  class IL1DynamicPedestalProvider;
  
 
  class ATLAS_NOT_THREAD_SAFE L1TriggerTowerTool : virtual public IL1TriggerTowerTool, public IIncidentListener, public AthAlgTool
  {
    public:
      
      L1TriggerTowerTool(const std::string&,const std::string&,const IInterface*);

      virtual ~L1TriggerTowerTool ();
      
      virtual StatusCode initialize();
      virtual StatusCode finalize();
      virtual void handle(const Incident&);
      virtual StatusCode retrieveConditions();

      virtual void process(const std::vector<int> &digits,
                           double eta, double phi, int layer,
                           std::vector<int> &et, std::vector<int> &bcidResults,
                           std::vector<int> &bcidDecisions, bool useJepLut = true);
       
      virtual void process(const std::vector<int> &digits, const L1CaloCoolChannelId& channelId,
                           std::vector<int> &et, std::vector<int> &bcidResults,
                           std::vector<int> &bcidDecisions, bool useJepLut = true);
 
      virtual void simulateChannel(const xAOD::TriggerTower& tt, std::vector<int>& outCpLut, std::vector<int>& outJepLut, std::vector<int>& bcidResults, std::vector<int>& bcidDecisions);
 
      virtual void pedestalCorrection(std::vector<int>& firInOut, int firPed, int iElement, int layer,
                                      int bcid, float mu, std::vector<int_least16_t>& correctionOut);
      virtual void fir(const std::vector<int> &digits, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void fir(const std::vector<int> &digits, const std::vector<int> &firCoeffs, std::vector<int> &output);
      virtual void dropBits(const std::vector<int> &fir, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void dropBits(const std::vector<int> &fir, unsigned int first, std::vector<int> &output);
      virtual void etRange(const std::vector<int> &et, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void etRange(const std::vector<int> &et, int energyLow, int energyHigh, std::vector<int> &output);
      virtual void peakBcid(const std::vector<int> &fir, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void peakBcid(const std::vector<int> &fir, unsigned int strategy, std::vector<int> &output);
      virtual void satBcid(const std::vector<int> &digits, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void satBcid(const std::vector<int> &digits, int satLow, int satHigh, int satLevel, std::vector<int> &output);
      virtual void bcid(const std::vector<int> &fir, const std::vector<int> &digits, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void bcid(const std::vector<int> &fir, const std::vector<int> &digits, unsigned int strategy, int satLow, int satHigh, int satLevel, std::vector<int> &output);
      virtual void bcid(const std::vector<int> &fir, const std::vector<int> &lutInput, const std::vector<int> &digits, int energyLow, int energyHigh, int decisionSource, std::vector<unsigned int> &decisionConditions,
                        unsigned int strategy, int satLow, int satHigh, int satLevel, std::vector<int> &result, std::vector<int> &decision);
      virtual void bcidDecisionRange(const std::vector<int>& lutInput, const std::vector<int>& digits, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void bcidDecision(const std::vector<int> &bcidResults, const std::vector<int> &range, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void bcidDecision(const std::vector<int> &bcidResults, const std::vector<int> &range, const std::vector<unsigned int> &mask, std::vector<int> &output);
      virtual void lut(const std::vector<int> &fir, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void cpLut(const std::vector<int> &fir, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void jepLut(const std::vector<int> &fir, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void lut(const std::vector<int> &fir, int slope, int offset, int cut, int ped, int strategy, bool disabled, std::vector<int> &output);
      virtual void nonLinearLut(const std::vector<int> &fir, int slope, int offset, int cut, int scale, short par1, short par2, short par3, short par4, bool disabled, std::vector<int> &output);
      virtual void applyEtRange(const std::vector<int>& lut, const std::vector<int>& range, const L1CaloCoolChannelId& channelId, std::vector<int> &output);
      virtual void firParams(const L1CaloCoolChannelId& channelId, std::vector<int> &firCoeffs);
      virtual void bcidParams(const L1CaloCoolChannelId& channelId, int &energyLow, int &energyHigh, int &decisionSource, std::vector<unsigned int> &decisionConditions,
                              unsigned int &peakFinderStrategy, int &satLow, int &satHigh, int &satLevel);
      virtual void lutParams(const L1CaloCoolChannelId& channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled);
      virtual void cpLutParams(const L1CaloCoolChannelId& channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled);
      virtual void jepLutParams(const L1CaloCoolChannelId& channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled);
      virtual Identifier identifier(double eta, double phi, int layer);
      virtual HWIdentifier hwIdentifier(const Identifier& id);
      virtual HWIdentifier hwIdentifier(double eta, double phi, int layer);
      virtual L1CaloCoolChannelId channelID(double eta, double phi, int layer);
      virtual L1CaloCoolChannelId channelID(const Identifier& id);
      virtual bool satOverride(int range, const L1CaloCoolChannelId& channelId);
      virtual bool disabledChannel(const L1CaloCoolChannelId& channelId);
      virtual double FCalTTeta(const L1CaloCoolChannelId& channelId);
      virtual double FCalTTeta(double nominalEta, double phi, int layer);
      virtual void setDebug(bool debug);
      virtual std::pair<double, double> refValues(const L1CaloCoolChannelId& channelId); 
      virtual StatusCode loadFTRefs();
    
    private:
      bool isRun2() const;
  
      template <typename T>
      void printVec(const std::vector<T>& vec);

      bool disabledChannel(const L1CaloCoolChannelId& channelId, unsigned int& noiseCut);
 
      bool              m_debug = false;

      const CaloIdManager* m_caloMgr;
      
      const CaloLVL1_ID* m_lvl1Helper;
//       L1CaloTTIdTools* m_l1CaloTTIdTools;
      ToolHandle<LVL1::IL1CaloTTIdTools> m_l1CaloTTIdTools;
      ToolHandle<CaloTriggerTowerService> m_ttSvc;
      
      ToolHandle<LVL1::IL1CaloMappingTool> m_mappingTool;

      SG::ReadCondHandleKey<L1CaloRunParametersContainer>  m_runParametersContainerKey{ this, "InputKeyRunParameters", "L1CaloRunParametersContainer"};
      SG::ReadCondHandleKey<L1CaloPprConditionsContainerRun2> m_conditionsContainerKeyRun2{ this, "InputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"};
      SG::ReadCondHandleKey<L1CaloPprDisabledChannelContainerRun2> m_disabledChannelContainerKeyRun2{ this, "InputKeyDisabledChannelRun2", "L1CaloPprDisabledChannelContainerRun2"};
      SG::ReadCondHandleKey<L1CaloPpmFineTimeRefsContainer> m_dbFineTimeRefsTowersKey{ this, "InputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"};
 
      const L1CaloRunParametersContainer* m_runParametersContainer = nullptr;
 
      // - Note: 2024, dropped support for non-Run2 case
      // this is why these were std::any, to allow for both possibilities when it was previously supported
      std::any m_conditionsContainer; // one of L1CaloPprConditionsContainer{,Run2}*
      std::any m_disabledChannelContainer;  // one of L1CaloPprDisabledChannelContainer{,Run2}*
      
      const L1CaloPpmFineTimeRefsContainer* m_dbFineTimeRefsTowers = nullptr;
      

      std::vector<unsigned int> m_idTable;

      bool m_correctFir;
      ToolHandle<LVL1::IL1DynamicPedestalProvider> m_dynamicPedestalProvider;
 
      SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey
      { this, "EventInfoKey", "EventInfo", "" };
      SG::ReadHandleKey<TrigConf::L1Menu>  m_L1MenuKey{ this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" };
 

      static const int s_saturationValue = 255;
      static const int s_maxTowers = 7168;     
      static const int m_nBcid = 350; // mc12: max 350 // all: 3564
  }; 
    
} // end of namespace
 
#endif