LVL1::L1TriggerTowerTool Class Reference

This is a tool to reconstruct the L1 EM/tau trigger sums for a particular RoI location from the stored TriggerTowers. More...

#include <L1TriggerTowerTool.h>

Inheritance diagram for LVL1::L1TriggerTowerTool:

Public Member Functions
	L1TriggerTowerTool (const std::string &, const std::string &, const IInterface *)
virtual	~L1TriggerTowerTool ()
	default destructor
virtual StatusCode	initialize ()
	standard Athena-Algorithm method
virtual StatusCode	finalize ()
	standard Athena-Algorithm method
virtual void	handle (const Incident &)
	catch begRun
virtual StatusCode	retrieveConditions ()
	Retrieve pointers to the L1Calo conditions containers.
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)
	Take in vector of ADC digits, return PPrASIC results.
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)
	All-in-one routine - give it the ADC counts and TT identifier, and it returns the results.
virtual void	simulateChannel (const xAOD::TriggerTower &tt, std::vector< int > &outCpLut, std::vector< int > &outJepLut, std::vector< int > &bcidResults, std::vector< int > &bcidDecisions)
	All-in-one routine - give it the TT identifier, and it returns the results.
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)
	This FIR simulation produces a vector of same length as digit vector, with peak positions corresponding.
virtual void	fir (const std::vector< int > &digits, const std::vector< int > &firCoeffs, std::vector< int > &output)
	This FIR simulation produces a vector of same length as digit vector, with peak positions corresponding.
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)
	Truncate FIR results for LUT input.
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)
	Identify BCID decision range.
virtual void	peakBcid (const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output)
	Peak finder BCID.
virtual void	peakBcid (const std::vector< int > &fir, unsigned int strategy, std::vector< int > &output)
	Peak finder BCID.
virtual void	satBcid (const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output)
	Saturated pulse BCID.
virtual void	satBcid (const std::vector< int > &digits, int satLow, int satHigh, int satLevel, std::vector< int > &output)
	Saturated pulse BCID.
virtual void	bcid (const std::vector< int > &fir, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output)
	Evaluate both peak-finder and saturated BCID algorithms and return vector of predicted BCID result words.
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)
	Evaluate both peak-finder and saturated BCID algorithms and return vector of predicted BCID result words.
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)
	Evaluate both peak-finder and saturated BCID algorithms and return vectors of predicted BCID result and decision words.
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)
	Evaluate BCID decision based on BCID word, ET range and decision mask.
virtual void	lut (const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output)
	LUT simulation: pedestal subtraction, energy calibration and threshold.
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)
	LUT simulation: pedestal subtraction, energy calibration and threshold.
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)
	Use ET range to return appropriate ET value Do not test BCID here, since no guarantee enough ADC samples to evaluate it reliably.
virtual void	firParams (const L1CaloCoolChannelId &channelId, std::vector< int > &firCoeffs)
	Return FIR filter parameters for a channel.
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)
	Return BCID parameters for a channel.
virtual void	lutParams (const L1CaloCoolChannelId &channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled)
	Return LUT parameters for a channel.
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)
	Return offline identifier for given tower coordinates.
virtual HWIdentifier	hwIdentifier (const Identifier &id)
	Return online identifier for given offline identifier.
virtual HWIdentifier	hwIdentifier (double eta, double phi, int layer)
	Return online identifier for given tower coordinates.
virtual L1CaloCoolChannelId	channelID (double eta, double phi, int layer)
	Return Cool channel identifier for given tower coordinates.
virtual L1CaloCoolChannelId	channelID (const Identifier &id)
	Return Cool channel identifier for given offline identifier.
virtual bool	satOverride (int range, const L1CaloCoolChannelId &channelId)
virtual bool	disabledChannel (const L1CaloCoolChannelId &channelId)
	Check for disabled channel.
virtual double	FCalTTeta (const L1CaloCoolChannelId &channelId)
	Return median eta of trigger tower from L1CaloCoolChannelId.
virtual double	FCalTTeta (double nominalEta, double phi, int layer)
	Calculate median eta of FCAL trigger tower from nominal eta and layer.
virtual void	setDebug (bool debug)
	Finer control of debug printing.
virtual std::pair< double, double >	refValues (const L1CaloCoolChannelId &channelId)
virtual StatusCode	loadFTRefs ()
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	isRun2 () const
template<typename T>
void	printVec (const std::vector< T > &vec)
	Print a vector to debug.
bool	disabledChannel (const L1CaloCoolChannelId &channelId, unsigned int &noiseCut)
	Get extra noise cut with disabled channel.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_debug = false
const CaloIdManager *	m_caloMgr
	Id managers.
const CaloLVL1_ID *	m_lvl1Helper
	and tools for computing identifiers
ToolHandle< LVL1::IL1CaloTTIdTools >	m_l1CaloTTIdTools
ToolHandle< CaloTriggerTowerService >	m_ttSvc
ToolHandle< LVL1::IL1CaloMappingTool >	m_mappingTool
	and mappings
SG::ReadCondHandleKey< L1CaloRunParametersContainer >	m_runParametersContainerKey { this, "InputKeyRunParameters", "L1CaloRunParametersContainer"}
	L1Calo conditions.
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
std::any	m_conditionsContainer
std::any	m_disabledChannelContainer
const L1CaloPpmFineTimeRefsContainer *	m_dbFineTimeRefsTowers = nullptr
	For the fine time monitoring.
std::vector< unsigned int >	m_idTable
	Mapping lookup table.
bool	m_correctFir
	Baseline correction Tool.
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" }
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const int	s_saturationValue = 255
	Parameters.
static const int	s_maxTowers = 7168
static const int	m_nBcid = 350

Detailed Description

This is a tool to reconstruct the L1 EM/tau trigger sums for a particular RoI location from the stored TriggerTowers.

Used for offline monitoring and trigger reconstruction.

Useage: L1TriggerTowerTool->process(digits, eta, phi, EmHad, //inputs et, bcid, bcidresult) //outputs

Author

Alan Watson Alan..nosp@m.Wats.nosp@m.on@ce.nosp@m.rn.c.nosp@m.h

Definition at line 60 of file L1TriggerTowerTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

L1TriggerTowerTool()

LVL1::L1TriggerTowerTool::L1TriggerTowerTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 57 of file L1TriggerTowerTool.cxx.

  :
  AthAlgTool(t,n,p),
  m_caloMgr(0),
  m_lvl1Helper(0),
  m_l1CaloTTIdTools("LVL1::L1CaloTTIdTools/L1CaloTTIdTools", this),
  m_ttSvc("CaloTriggerTowerService/CaloTriggerTowerService", this),
  m_mappingTool("", this),
  m_dbFineTimeRefsTowers(0),
  m_correctFir(false),
  m_dynamicPedestalProvider("", this)
{
  declareInterface<IL1TriggerTowerTool>(this);
 
  declareProperty( "BaselineCorrection", m_correctFir );
  declareProperty( "L1DynamicPedestalProvider", m_dynamicPedestalProvider );
}

~L1TriggerTowerTool()

LVL1::L1TriggerTowerTool::~L1TriggerTowerTool ( )

virtual

default destructor

Definition at line 79 of file L1TriggerTowerTool.cxx.

{
}

Member Function Documentation

applyEtRange()

void LVL1::L1TriggerTowerTool::applyEtRange ( const std::vector< int > & lut, const std::vector< int > & range, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Use ET range to return appropriate ET value Do not test BCID here, since no guarantee enough ADC samples to evaluate it reliably.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1015 of file L1TriggerTowerTool.cxx.

{
  bool disabled = disabledChannel(channelId);
  std::vector<int>::const_iterator itlut   = lut.begin();
  std::vector<int>::const_iterator itrange = range.begin();
  while ( itlut != lut.end() && itrange != range.end() ) {
    if (!disabled && satOverride((*itrange), channelId)) output.push_back(s_saturationValue);
    else                                                 output.push_back(*itlut);
    ++itlut;
    ++itrange;
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::applyEtRange: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

bcid() [1/3]

void LVL1::L1TriggerTowerTool::bcid ( const std::vector< int > & fir, const std::vector< int > & digits, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Evaluate both peak-finder and saturated BCID algorithms and return vector of predicted BCID result words.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 388 of file L1TriggerTowerTool.cxx.

{
  // Get decision flags for the 2 BCID algorithms
  std::vector<int> peak;
  peakBcid(filter, channelId, peak);
  std::vector<int> sat;
  satBcid(digits, channelId, sat);
 
  output.clear();
  output.reserve(sat.size()); // avoid frequent reallocations
 
  std::vector<int>::iterator itpeak = peak.begin();
  std::vector<int>::iterator itsat = sat.begin();
  for ( ; itpeak!=peak.end() && itsat!=sat.end(); ++itpeak, ++itsat ) {
   output.push_back( (*itpeak<<2) + (*itsat<<1) );
  }
  if (m_debug) {
   ATH_MSG_VERBOSE( "::bcid: bcidResults: ");
   printVec(output);
  ATH_MSG_VERBOSE(" ");
  }
}

bcid() [2/3]

void LVL1::L1TriggerTowerTool::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

Evaluate both peak-finder and saturated BCID algorithms and return vector of predicted BCID result words.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 414 of file L1TriggerTowerTool.cxx.

{
  // Get decision flags for the 2 BCID algorithms
  std::vector<int> peak;
  peakBcid(filter, strategy, peak);
  std::vector<int> sat;
  satBcid(digits, satLow, satHigh, satLevel, sat);
 
  output.clear();
  output.reserve(sat.size()); // avoid frequent reallocations
 
  std::vector<int>::iterator itpeak = peak.begin();
  std::vector<int>::iterator itsat = sat.begin();
  for ( ; itpeak!=peak.end() && itsat!=sat.end(); ++itpeak, ++itsat ) {
   output.push_back( (*itpeak<<2) + (*itsat<<1) );
  }
  if (m_debug) {
   ATH_MSG_VERBOSE( "::bcid: bcidResults: ");
   printVec(output);
  ATH_MSG_VERBOSE(" ");
  }
}

bcid() [3/3]

void LVL1::L1TriggerTowerTool::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

Evaluate both peak-finder and saturated BCID algorithms and return vectors of predicted BCID result and decision words.

evaluate BCID decisions

Implements LVL1::IL1TriggerTowerTool.

Definition at line 441 of file L1TriggerTowerTool.cxx.

{
  // Get decision flags for the 2 BCID algorithms
  std::vector<int> peak;
  peakBcid(filter, strategy, peak);
  std::vector<int> sat;
  satBcid(digits, satLow, satHigh, satLevel, sat);
 
  result.clear();
  result.reserve(sat.size()); // avoid frequent reallocations
  decision.clear();
 
  std::vector<int>::iterator itpeak = peak.begin();
  std::vector<int>::iterator itsat = sat.begin();
  for ( ; itpeak!=peak.end() && itsat!=sat.end(); ++itpeak, ++itsat ) {
   result.push_back( (*itpeak<<2) + (*itsat<<1) );
  }
  if (m_debug) {
   ATH_MSG_VERBOSE( "::bcid: bcidResults: ");
   printVec(result);
  ATH_MSG_VERBOSE(" ");
  }

  std::vector<int> decisionRange;
  if (!(decisionSource&0x1)) etRange(digits, energyLow, energyHigh, decisionRange);
  else                     etRange(lutInput, energyLow, energyHigh, decisionRange);
  bcidDecision(result, decisionRange, decisionConditions, decision);
  if (m_debug) {
   ATH_MSG_VERBOSE( "::bcid: bcidDecisions: ");
   printVec(decision);
  ATH_MSG_VERBOSE(" ");
  }
}

bcidDecision() [1/2]

void LVL1::L1TriggerTowerTool::bcidDecision ( const std::vector< int > & bcidResults, const std::vector< int > & range, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 716 of file L1TriggerTowerTool.cxx.

{
  unsigned int decision1 = 0;
  unsigned int decision2 = 0;
  unsigned int decision3 = 0;
  if(m_conditionsContainer.has_value()) {
    if(isRun2())
      std::tie(decision1, decision2, decision3) = getBcidDecision<L1CaloPprConditionsContainerRun2>(m_conditionsContainer);
    else
      std::tie(decision1, decision2, decision3) = getBcidDecision<L1CaloPprConditionsContainer>(m_conditionsContainer);
  } else ATH_MSG_WARNING( "::bcidDecision: No Conditions Container retrieved" );
 
  // Reverse the order! (see elog 97082 9/06/10)
  std::vector<unsigned int> mask = { decision3, decision2, decision1 };
  
  ATH_MSG_VERBOSE( "::bcidDecision: masks: " << MSG::hex
         << decision3 << " " << decision2 << " " << decision1 << MSG::dec );
 
  bcidDecision(bcidResults, range, mask, output);
}

bcidDecision() [2/2]

void LVL1::L1TriggerTowerTool::bcidDecision ( const std::vector< int > & bcidResults, const std::vector< int > & range, const std::vector< unsigned int > & mask, std::vector< int > & output )

virtual

Evaluate BCID decision based on BCID word, ET range and decision mask.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 739 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(bcidResults.size()); // avoid frequent reallocations
 
  std::vector<int>::const_iterator itBcid  = bcidResults.begin();
  std::vector<int>::const_iterator itRange = range.begin();
  int nRange = mask.size();
 
  for ( ; itBcid != bcidResults.end() && itRange != range.end(); ++itBcid, ++itRange) {
   if ((*itRange) < nRange && (mask[*itRange]&(0x1<<*itBcid))) output.push_back(1);
   else                                                        output.push_back(0);
  }
  if (m_debug) {
   ATH_MSG_VERBOSE( "::bcidDecision: output: ");
   printVec(output);
  ATH_MSG_VERBOSE(" ");
  }
}

bcidDecisionRange()

void LVL1::L1TriggerTowerTool::bcidDecisionRange ( const std::vector< int > & lutInput, const std::vector< int > & digits, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 689 of file L1TriggerTowerTool.cxx.

{
  int decisionSource = 0;
  if (m_conditionsContainer.has_value()) {
    if(isRun2()) decisionSource = getDecisionSource<L1CaloPprConditionsContainerRun2>(m_conditionsContainer);
    else decisionSource = getDecisionSource<L1CaloPprConditionsContainer>(m_conditionsContainer);
 
  } else ATH_MSG_WARNING( "::bcidDecisionRange: No Conditions Container retrieved" );
 
  if (!(decisionSource&0x1)) etRange(digits, channelId, output);
  else                     etRange(lutInput, channelId, output);
  if (m_debug) {
    ATH_MSG_VERBOSE( "::bcidDecisionRange: decisionSource: " << decisionSource);
    ATH_MSG_VERBOSE( " output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

bcidParams()

void LVL1::L1TriggerTowerTool::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

Return BCID parameters for a channel.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1162 of file L1TriggerTowerTool.cxx.

{
  energyLow          = 0;
  energyHigh         = 0;
  decisionSource     = 0;
  decisionConditions.clear();
  peakFinderStrategy = 0;
  satLevel           = 0;
  satLow             = 0;
  satHigh            = 0;
  
  if(m_conditionsContainer.has_value()) {
    using std::get;
    std::tuple<unsigned int, unsigned int, unsigned int> bcidDecision;
    std::tuple<bool, int, int> bcidEnergyRange;
    std::tuple<bool, int, int, int> saturation;
    if(isRun2()) {
      using Cont = L1CaloPprConditionsContainerRun2;
      bcidDecision = getBcidDecision<Cont>(m_conditionsContainer);
      peakFinderStrategy = getStrategy<Cont>(m_conditionsContainer);
      decisionSource = getDecisionSource<Cont>(m_conditionsContainer);
      bcidEnergyRange = getBcidEnergyRange<Cont>(channelId.id(), m_conditionsContainer);
      saturation = getSaturation<Cont>(channelId.id(), m_conditionsContainer);
    } else {
      using Cont = L1CaloPprConditionsContainer;
      bcidDecision = getBcidDecision<Cont>(m_conditionsContainer);
      peakFinderStrategy = getStrategy<Cont>(m_conditionsContainer);
      decisionSource = getDecisionSource<Cont>(m_conditionsContainer);
      bcidEnergyRange = getBcidEnergyRange<Cont>(channelId.id(), m_conditionsContainer);
      saturation = getSaturation<Cont>(channelId.id(), m_conditionsContainer);
    }
 
    decisionConditions = { get<2>(bcidDecision), 
                           get<1>(bcidDecision),
                           get<0>(bcidDecision) }; // reverse order
    if(get<0>(bcidEnergyRange)) {
      std::tie(std::ignore, energyLow, energyHigh) = bcidEnergyRange;
    } else ATH_MSG_WARNING( "::bcidParams: No BcidEnergyRange found" );
 
    if(get<0>(saturation)) {
      std::tie(std::ignore, satLevel, satLow, satHigh) = saturation;
    } else ATH_MSG_WARNING( "::bcidParams: No Saturation found" );
  } else ATH_MSG_WARNING( "::bcid:Params No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::bcidParams: satLevel: " << satLevel
                   << " satLow: "  << satLow << " satHigh: " << satHigh << endmsg
                   << " energyLow: " << energyLow << " energyHigh: " << energyHigh << endmsg
                   << " decisionSource: " << decisionSource << " peakFinderStrategy: "
                   << peakFinderStrategy );
 
}

channelID() [1/2]

L1CaloCoolChannelId LVL1::L1TriggerTowerTool::channelID ( const Identifier & id )

virtual

Return Cool channel identifier for given offline identifier.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1442 of file L1TriggerTowerTool.cxx.

{
  L1CaloCoolChannelId coolId(0);
  if (m_ttSvc) {
    try {
      HWIdentifier hwId = hwIdentifier(id);
      coolId = m_ttSvc->createL1CoolChannelId(hwId);
    }
    catch (const CaloID_Exception&) { coolId = L1CaloCoolChannelId(0); }
  }
  return coolId;
}

channelID() [2/2]

L1CaloCoolChannelId LVL1::L1TriggerTowerTool::channelID ( double eta, double phi, int layer )

virtual

Return Cool channel identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1407 of file L1TriggerTowerTool.cxx.

{
  // Use direct lookup table if possible
  const double absEta = fabs(eta);
  int index = 0;
  if (absEta < 2.5) {
    const int etaBin = 10.*absEta;
    const int phiBin = phi*(32/M_PI);
    index = (etaBin<<6) + phiBin;
  } else if (absEta < 3.2) {
    const int etaBin = 5.*(absEta - 2.5);
    const int phiBin = phi*(16./M_PI);
    index = 1600 + (etaBin<<5) + phiBin;
  } else {
    const int etaBin = (absEta - 3.2)*(1./0.425);
    const int phiBin = phi*(8./M_PI);
    index = 1728 + (etaBin<<4) + phiBin;
  }
  if (eta < 0.)  index += 1792;
  if (layer > 0) index += 3584;
  if (index >= s_maxTowers) return L1CaloCoolChannelId(0);
  if (m_idTable.empty()) {
    m_idTable.reserve(s_maxTowers);
    m_idTable.assign(s_maxTowers, 0);
  }
  if (m_idTable[index] == 0) {
    Identifier id = identifier(eta, phi, layer);
    L1CaloCoolChannelId coolID = channelID(id);
    m_idTable[index] = coolID.id();
  }
  return L1CaloCoolChannelId(m_idTable[index]);
}

cpLut()

void LVL1::L1TriggerTowerTool::cpLut ( const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 796 of file L1TriggerTowerTool.cxx.

{   
  int startBit = 0;
  int strategy = 0;
  int offset   = 0;
  double offsetReal = 0;
  int slope    = 0;
  int cut      = 0;
  unsigned short scale = 0;
  double pedMean = 0;
  int ped      = 0;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
 
  if(!isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::cpLut: Run-1 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainerRun2*>(m_conditionsContainer);
    const L1CaloPprConditionsRun2* settings = conditionsContainer->pprConditions(channelId.id());
    if (settings) {
      startBit = settings->firStartBit();
      strategy = settings->lutCpStrategy();
      slope    = settings->lutCpSlope();
      cut      = settings->lutCpNoiseCut();
      scale    = settings->lutCpScale();
      ped      = settings->pedValue();
      pedMean  = settings->pedMean();
 
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
 
      for (unsigned int i = 0; i < hwCoeffs->size(); i++){
        hwCoeffSum += hwCoeffs->at(i);
      }
      
      if (strategy == 0){
        offsetReal = pedMean * hwCoeffSum / pow(2.,startBit);
      }
      else{
        offsetReal = pedMean * hwCoeffSum * slope / pow(2.,startBit) - slope/2.;
      }
      offset = static_cast<unsigned short>( offsetReal < 0. ? 0 : offsetReal + 0.5 );
 
      ATH_MSG_VERBOSE( "::cpLut: Offset: offset/strategy/pedMean/firCoeffSum/startBit/slope: "
               << offset << " " << strategy << " " << " " << pedMean << " " << hwCoeffSum << " " << startBit << " " << slope );
      
    } else ATH_MSG_WARNING( "::cpLut: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::cpLut: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::cpLut: LUT strategy/offset/slope/cut/ped: "
          << strategy << " " << offset << " " << slope << " " << cut << " " << ped << " " );
 
  unsigned int noiseCut = 0;
  bool disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
  if(strategy == 2) {
    // take the global scale into account - translate strategy to 1 for Run-1 compatible treatment
    lut(fir, scale*slope, scale*offset, scale*cut, ped, 1, disabled, output);
  } else if(strategy == 1 || strategy == 0){
    lut(fir, slope, offset, cut, ped, strategy, disabled, output);
  } else ATH_MSG_WARNING(" ::cpLut: Unknown stragegy: " << strategy);
}

cpLutParams()

void LVL1::L1TriggerTowerTool::cpLutParams ( const L1CaloCoolChannelId & channelId, int & startBit, int & slope, int & offset, int & cut, int & pedValue, float & pedMean, int & strategy, bool & disabled )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1254 of file L1TriggerTowerTool.cxx.

{
  startBit = 0;
  strategy = 0;
  offset   = 0;
  double offsetReal = 0;
  slope    = 0;
  cut      = 0;
  pedValue = 0;
  pedMean  = 0.;
  disabled = true;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
  
  if(!isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::cpLutParams: Run-1 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainerRun2*>(m_conditionsContainer);
 
    const L1CaloPprConditionsRun2* settings = conditionsContainer->pprConditions(channelId.id());
    if(settings) {
      startBit = settings->firStartBit();
      strategy = settings->lutCpStrategy();
      slope    = settings->lutCpSlope();
      cut      = settings->lutCpNoiseCut();
      pedValue = settings->pedValue();
      pedMean  = settings->pedMean();
 
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
      for (unsigned int i = 0; i < hwCoeffs->size(); i++){
    hwCoeffSum += hwCoeffs->at(i);
      }
      
      if (strategy == 0){
    offsetReal = pedMean * hwCoeffSum / pow(2.,startBit);
      }
      else{
    offsetReal = pedMean * hwCoeffSum * slope / pow(2.,startBit) - slope/2.;
      }
      offset = static_cast<unsigned short>( offsetReal < 0. ? 0 : offsetReal + 0.5 );
      
      ATH_MSG_VERBOSE( "::jepLutParams: Offset: offset/strategy/pedMean/firCoeffSum/startBit/slope: "
             << offset << " " << strategy << " " << " " << pedMean << " " << hwCoeffSum << " " << startBit << " " << slope );
 
    } else ATH_MSG_WARNING( "::cpLutParams: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::cpLutParams: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::cpLutParams: LUT startBit/strategy/offset/slope/cut/pedValue/pedMean: "
          << startBit << " " << strategy << " " << offset << " " << slope << " " << cut << " " << pedValue << " " << pedMean );
  unsigned int noiseCut = 0;
  disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

disabledChannel() [1/2]

bool LVL1::L1TriggerTowerTool::disabledChannel ( const L1CaloCoolChannelId & channelId )

virtual

Check for disabled channel.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1487 of file L1TriggerTowerTool.cxx.

{
  unsigned int noiseCut = 0;
  return disabledChannel(channelId, noiseCut);
}

disabledChannel() [2/2]

bool LVL1::L1TriggerTowerTool::disabledChannel ( const L1CaloCoolChannelId & channelId, unsigned int & noiseCut )

private

Get extra noise cut with disabled channel.

Check for disabled channel with noise cut.

Definition at line 1494 of file L1TriggerTowerTool.cxx.

{
  bool isDisabled = false;
  noiseCut = 0;
  if(m_disabledChannelContainer.has_value()) {
    const L1CaloPprDisabledChannel* disabledChan = nullptr;
    if(isRun2()) disabledChan = std::any_cast<L1CaloPprDisabledChannelContainerRun2*>(m_disabledChannelContainer)->pprDisabledChannel(channelId.id());
    else disabledChan = std::any_cast<L1CaloPprDisabledChannelContainer*>(m_disabledChannelContainer)->pprDisabledChannel(channelId.id());
 
    if (disabledChan) {
      if (!disabledChan->disabledBits()) {
        ChanCalibErrorCode calibError(disabledChan->calibErrorCode());
        if (calibError.chanValid()) {
          ChanDeadErrorCode deadError(disabledChan->deadErrorCode());
          if (deadError.chanValid()) noiseCut = disabledChan->noiseCut();
      //else isDisabled = true;
        } //else isDisabled = true;
      } else isDisabled = true;
      
      ATH_MSG_VERBOSE( MSG::hex
              << "::disabledChannel: calibErrorCode: " << (disabledChan->calibErrorCode()).errorCode()
              << "  deadErrorCode: " << (disabledChan->deadErrorCode()).errorCode()
              << "  noiseCut: "      << disabledChan->noiseCut()
              << "  disabledBits: "  << disabledChan->disabledBits()
              << MSG::dec );
      
    } else {
      ATH_MSG_VERBOSE( "::disabledChannel: No L1CaloPprDisabledChannel found" );
    }
  } else {
    ATH_MSG_WARNING( "::disabledChannel: No DisabledChannel Container retrieved" );
  }
  if (isDisabled && m_debug) ATH_MSG_VERBOSE( "::disabledChannel: Channel is disabled" );
 
  return isDisabled;
}

dropBits() [1/2]

void LVL1::L1TriggerTowerTool::dropBits ( const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1091 of file L1TriggerTowerTool.cxx.

{
  unsigned int start = 0;
  if(m_conditionsContainer.has_value()) {
    bool available = false;
    if(isRun2())
      std::tie(available, start) = getFirStartBit<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
    else
      std::tie(available, start) = getFirStartBit<L1CaloPprConditionsContainer>(channelId.id(), m_conditionsContainer);
    if(!available)ATH_MSG_WARNING( "::dropBits: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::dropBits: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::dropBits: firStartBit: " << start );
  
  dropBits(fir, start, output);
}

dropBits() [2/2]

void LVL1::L1TriggerTowerTool::dropBits ( const std::vector< int > & fir, unsigned int first, std::vector< int > & output )

virtual

Truncate FIR results for LUT input.

mask to select appropriate 10 bit range

overflow detection

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1110 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations

  unsigned int mask = (0x3ff<<start);

  int max = 1<<(10+start);
 
  for (std::vector<int>::const_iterator it = fir.begin(); it != fir.end(); ++it) {
     if ((*it)>=max) output.push_back(0x3ff);
     else output.push_back(((*it)&mask)>>start);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::dropBits: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

etRange() [1/2]

void LVL1::L1TriggerTowerTool::etRange ( const std::vector< int > & et, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1043 of file L1TriggerTowerTool.cxx.

{
  int energyLow  = 0;
  int energyHigh = 0;
  if (m_conditionsContainer.has_value()) {
    bool available = false;
    if(isRun2())
      std::tie(available, energyLow, energyHigh) = getBcidEnergyRange<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
    else
      std::tie(available, energyLow, energyHigh) = getBcidEnergyRange<L1CaloPprConditionsContainer>(channelId.id(), m_conditionsContainer);
    
    if(!available) ATH_MSG_WARNING("::etRange: No L1CaloPprConditions found");
  } else ATH_MSG_WARNING("::etRange: No Conditions Container retrieved");
 
  ATH_MSG_VERBOSE( "::etRange: energyLow: " << energyLow
                          << " energyHigh: "          << energyHigh);
 
  etRange(et, energyLow, energyHigh, output);
}

etRange() [2/2]

void LVL1::L1TriggerTowerTool::etRange ( const std::vector< int > & et, int energyLow, int energyHigh, std::vector< int > & output )

virtual

Identify BCID decision range.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1065 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(et.size()); // avoid frequent reallocations
  for (std::vector<int>::const_iterator it = et.begin(); it != et.end(); ++it) {
    if ((*it) <= energyLow)       output.push_back(0);
    else if ((*it) <= energyHigh) output.push_back(1);
    else                          output.push_back(2);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::etRange: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

FCalTTeta() [1/2]

double LVL1::L1TriggerTowerTool::FCalTTeta ( const L1CaloCoolChannelId & channelId )

virtual

Return median eta of trigger tower from L1CaloCoolChannelId.

For FCAL towers this is the physical centre of the eta range - for other towers the normal tower eta will be returned

Get crate/module/submodule/channel from the CoolId

use these with mapping tool to get eta

for FCAL, convert nominal eta to physical

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1572 of file L1TriggerTowerTool.cxx.

{
  if ( !m_mappingTool.isValid() ) {
    throw GaudiException("No mapping tool configured",
                         "L1TriggerTowerTool::FCalTTeta", StatusCode::FAILURE);
  }

  unsigned int crate   = channelId.crate();
  unsigned int module  = channelId.module();
  unsigned int mcm     = channelId.subModule();
  unsigned int pin     = channelId.channel();
  int channel = pin*16 + mcm;

  double eta;
  double phi;
  int layer;
  if(!m_mappingTool->mapping(crate, module, channel, eta, phi, layer)) {
    ATH_MSG_WARNING("::FCalTTeta: could not map 0x" << std::hex << channelId.id() << std::dec);
  }

  return FCalTTeta(eta, phi, layer);
}

FCalTTeta() [2/2]

double LVL1::L1TriggerTowerTool::FCalTTeta ( double nominalEta, double phi, int layer )

virtual

Calculate median eta of FCAL trigger tower from nominal eta and layer.

Hopefully this will be a short-term work-around

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1541 of file L1TriggerTowerTool.cxx.

{
  double eta = nominalEta;
  float abseta = fabs(eta);
  if (abseta<3.2) return eta; // If called for non-FCAL TT return input value
  if (layer == 0) {
    int sign = ((eta > 0) ? 1 : -1);
    if (abseta < 3.6)      eta = 3.15 * sign;
    else if (abseta < 4.0) eta = 3.33 * sign;
    else if (abseta < 4.5) eta = 3.72 * sign;
    else                   eta = 4.41 * sign;
  }
  else if (eta > 0) {
    if (abseta < 3.6)      eta = 3.36;
    else if (abseta < 4.0) eta = 3.45;
    else if (abseta < 4.5) eta = 4.17;
    else                   eta = 4.19;    
  }
  else {
    if (abseta < 3.6)      eta = -3.45;
    else if (abseta < 4.0) eta = -3.36;
    else if (abseta < 4.5) eta = -4.19;
    else                   eta = -4.17;    
  }
  return eta;
} 

finalize()

StatusCode LVL1::L1TriggerTowerTool::finalize ( )

virtual

standard Athena-Algorithm method

Definition at line 136 of file L1TriggerTowerTool.cxx.

{
  return StatusCode::SUCCESS;
}

fir() [1/2]

void LVL1::L1TriggerTowerTool::fir ( const std::vector< int > & digits, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

This FIR simulation produces a vector of same length as digit vector, with peak positions corresponding.

However, first 2 and last 2 FIR sums will be incomplete, and so are zeroed here

Get coefficients from COOL DB

Ordering of coeffs in hw makes sense for hw implementation, but is not most natural for processing vectors in software. So reverse order here before using

Implements LVL1::IL1TriggerTowerTool.

Definition at line 489 of file L1TriggerTowerTool.cxx.

{   
  std::vector<int> firCoeffs;
  if(m_conditionsContainer.has_value()) {
    const std::vector<short int>* hwCoeffs;
    if(isRun2())
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
    else
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainer>(channelId.id(), m_conditionsContainer);
    if(hwCoeffs) {
      firCoeffs.reserve(hwCoeffs->size()); // avoid frequent reallocations
      for (int i = hwCoeffs->size()-1; i >= 0; --i) firCoeffs.push_back((*hwCoeffs)[i]);
 
    } else ATH_MSG_WARNING( "::fir: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::fir: No Conditions Container retrieved" );
 
  if (m_debug) {
    ATH_MSG_VERBOSE( "::fir: FIR coefficients: ");
    printVec(firCoeffs);
    ATH_MSG_VERBOSE(" ");
  }
 
  fir(digits, firCoeffs, output);
}

fir() [2/2]

void LVL1::L1TriggerTowerTool::fir ( const std::vector< int > & digits, const std::vector< int > & firCoeffs, std::vector< int > & output )

virtual

This FIR simulation produces a vector of same length as digit vector, with peak positions corresponding.

However, since there are less FIR coefficients than digits the first and last few sums will be incomplete, and so are zeroed here

need to know first and last non-zero coefficient to know how which outputs can be calculated from supplied input digits

Only calculate where enough informations

Implements LVL1::IL1TriggerTowerTool.

Definition at line 522 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(digits.size()); // avoid frequent reallocations
  int firstFIR = -1;
  int lastFIR = 0;
  for (unsigned int i = 0; i < firCoeffs.size(); ++i) {
    if (firstFIR < 0 && firCoeffs[i] != 0) firstFIR = i;
    if (firCoeffs[i] != 0) lastFIR = i;
  }
  if (firstFIR < 0) firstFIR = lastFIR + 1;
  
  for (int i = 0; i < (int)digits.size(); i++) {
    int sum = 0;
    if (i >= 2-firstFIR && i < (int)digits.size()+2-lastFIR) {
      for (int j = firstFIR; j <= lastFIR; ++j) {
        sum += digits[i+j-2]*firCoeffs[j];
      }
    }
    if (sum < 0) sum = 0;
    output.push_back(sum);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::fir: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

firParams()

void LVL1::L1TriggerTowerTool::firParams ( const L1CaloCoolChannelId & channelId, std::vector< int > & firCoeffs )

virtual

Return FIR filter parameters for a channel.

Get coefficients from COOL DB

Ordering of coeffs in hw makes sense for hw implementation, but is not most natural for processing vectors in software. So reverse order here before using

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1133 of file L1TriggerTowerTool.cxx.

{   
  firCoeffs.clear();
  if(m_conditionsContainer.has_value()) {
    const std::vector<short int>* hwCoeffs = nullptr;
    if(isRun2())
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
    else
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainer>(channelId.id(), m_conditionsContainer);
 
    if(hwCoeffs) {
      firCoeffs.reserve(hwCoeffs->size()); // avoid frequent reallocations
      for (int i = hwCoeffs->size()-1; i >= 0; --i) firCoeffs.push_back((*hwCoeffs)[i]);
 
    } else ATH_MSG_WARNING( "::firParams: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::firParams: No Conditions Container retrieved" );
 
  if (m_debug) {
    ATH_MSG_VERBOSE( "::fir: FIR coefficients: ");
    printVec(firCoeffs);
   ATH_MSG_VERBOSE(" ");
  }
}

handle()

void LVL1::L1TriggerTowerTool::handle ( const Incident & inc )

virtual

catch begRun

Definition at line 143 of file L1TriggerTowerTool.cxx.

{
  if (inc.type()=="BeginRun") {
    ATH_MSG_DEBUG( "Resetting mapping table at start of run" );
   
    m_idTable.clear();
  }
}

hwIdentifier() [1/2]

HWIdentifier LVL1::L1TriggerTowerTool::hwIdentifier ( const Identifier & id )

virtual

Return online identifier for given offline identifier.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1387 of file L1TriggerTowerTool.cxx.

{
   HWIdentifier hwId(0);
   if (m_ttSvc) {
     try   { hwId = m_ttSvc->createTTChannelID(id, false); }
     catch (const CaloID_Exception&) { hwId = HWIdentifier(0); }
   }
   return hwId;
}

hwIdentifier() [2/2]

HWIdentifier LVL1::L1TriggerTowerTool::hwIdentifier ( double eta, double phi, int layer )

virtual

Return online identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1399 of file L1TriggerTowerTool.cxx.

{
   Identifier id = identifier(eta, phi, layer);
   return hwIdentifier(id);
}

identifier()

Identifier LVL1::L1TriggerTowerTool::identifier ( double eta, double phi, int layer )

virtual

Return offline identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1371 of file L1TriggerTowerTool.cxx.

{
   Identifier id(0);
   if (m_l1CaloTTIdTools && m_lvl1Helper) {
     int pos_neg_z = m_l1CaloTTIdTools->pos_neg_z(eta);
     int region    = m_l1CaloTTIdTools->regionIndex(eta);
     int ieta      = m_l1CaloTTIdTools->etaIndex(eta);
     int iphi      = m_l1CaloTTIdTools->phiIndex(eta, phi);
   
     id = m_lvl1Helper->tower_id(pos_neg_z, layer, region, ieta, iphi);
   }
   return id;
} 

initialize()

StatusCode LVL1::L1TriggerTowerTool::initialize ( )

virtual

standard Athena-Algorithm method

Definition at line 85 of file L1TriggerTowerTool.cxx.

{
  m_debug = msgLvl(MSG::VERBOSE); // May want to make this VERBOSE!
 
  ATH_CHECK( m_runParametersContainerKey.initialize(SG::AllowEmpty) );
  ATH_CHECK( m_conditionsContainerKeyRun2.initialize(SG::AllowEmpty) );
  ATH_CHECK( m_disabledChannelContainerKeyRun2.initialize(SG::AllowEmpty) );
  ATH_CHECK( m_dbFineTimeRefsTowersKey.initialize(SG::AllowEmpty) );
 
 
  ATH_CHECK(m_l1CaloTTIdTools.retrieve());
 
  if(!m_ttSvc.retrieve().isSuccess()) {
    ATH_MSG_WARNING( "Could not retrieve CaloTriggerTowerService Tool" );
  } else {
    ATH_MSG_INFO("Retrieved Tool " << m_ttSvc);
  }
  
  StatusCode scID = detStore()->retrieve(m_caloMgr);
  if (scID.isFailure()) {
    ATH_MSG_WARNING( "Cannot retrieve m_caloMgr" );
  } else {
    m_lvl1Helper = m_caloMgr->getLVL1_ID();
  }
 
  if (!m_mappingTool.empty()) {
    ATH_CHECK( m_mappingTool.retrieve() );
  }
 
  // Incident Service:
  SmartIF<IIncidentSvc> incSvc{service("IncidentSvc")};
  ATH_CHECK( incSvc.isValid() );
  incSvc->addListener(this, "BeginRun");
 
  // Pedestal Correction
  if (m_correctFir) {
    ATH_CHECK(m_dynamicPedestalProvider.retrieve());
    ATH_MSG_INFO( "Retrieved L1DynamicPedestalProvider: " << m_dynamicPedestalProvider ); 
  }
 
  ATH_CHECK( m_eventInfoKey.initialize() );
 
  ATH_CHECK( m_L1MenuKey.initialize() );
  
  ATH_MSG_INFO( "Initialization completed" );
  
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & LVL1::IL1TriggerTowerTool::interfaceID ( )

inlinestaticinherited

Definition at line 95 of file IL1TriggerTowerTool.h.

{
  return IID_IL1TriggerTowerTool;
}

isRun2()

bool LVL1::L1TriggerTowerTool::isRun2 ( ) const

private

Definition at line 1682 of file L1TriggerTowerTool.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
  if (ctx.eventID().run_number() >= 253377) return true;
 
  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
  if (eventInfo->eventType (xAOD::EventInfo::IS_SIMULATION)) return true;
  return false;
}

jepLut()

void LVL1::L1TriggerTowerTool::jepLut ( const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 861 of file L1TriggerTowerTool.cxx.

{   
  int startBit = 0;
  int strategy   = 0;
  int offset     = 0;
  double offsetReal = 0;
  int slope      = 0;
  int cut        = 0;
  unsigned short scale_db   = 0;
  unsigned short scale_menu = 0;
  int ped        = 0;
  double pedMean = 0;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
  short par1     = 0;
  short par2     = 0;
  short par3     = 0;
  short par4     = 0;
 
  if(!isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::jepLut: Run-1 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainerRun2*>(m_conditionsContainer);
    const L1CaloPprConditionsRun2* settings = conditionsContainer->pprConditions(channelId.id());
    if (settings) {
      startBit = settings->firStartBit();
      strategy   = settings->lutJepStrategy();
      slope      = settings->lutJepSlope();
      cut        = settings->lutJepNoiseCut();
      ped        = settings->pedValue();
      pedMean    = settings->pedMean();
      scale_db   = settings->lutJepScale();
      
      auto l1Menu = SG::makeHandle( m_L1MenuKey );
      scale_menu = l1Menu->thrExtraInfo().JET().jetScale(); // Retrieve scale param from menu
      if (strategy == 3) {
        par1  = settings->lutJepPar1();
        par2  = settings->lutJepPar2();
        par3  = settings->lutJepPar3();
        par4  = settings->lutJepPar4();
      }
 
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
 
      for (unsigned int i = 0; i < hwCoeffs->size(); i++){
        hwCoeffSum += hwCoeffs->at(i);
      }
      
      if (strategy == 0){
        offsetReal = pedMean * hwCoeffSum / pow(2.,startBit);
      }
      else{
        offsetReal = pedMean * hwCoeffSum * slope / pow(2.,startBit) - slope/2.;
      }
      offset = static_cast<unsigned short>( offsetReal < 0. ? 0 : offsetReal + 0.5 );
 
      ATH_MSG_VERBOSE( "::jepLut: Offset: offset/strategy/pedMean/firCoeffSum/startBit/slope: "
               << offset << " " << strategy << " " << " " << pedMean << " " << hwCoeffSum << " " << startBit << " " << slope );
 
    } else ATH_MSG_WARNING( "::jepLut: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::jepLut: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::jepLut: LUT strategy/offset/slope/cut/ped: "
          << strategy << " " << offset << " " << slope << " " << cut << " " << ped << " " );
 
  unsigned int noiseCut = 0;
  bool disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
 
  if(strategy == 3) {
    nonLinearLut(fir, slope, offset, cut, scale_db, par1, par2, par3, par4, disabled, output);
  } 
  else if(strategy == 2) {
    // take the global scale into account - translate strategy to 1 for Run-1 compatible treatment
    lut(fir, scale_menu*slope, scale_menu*offset, scale_menu*cut, ped, 1, disabled, output);
  }else if(strategy == 1 || strategy == 0) {
    lut(fir, slope, offset, cut, ped, strategy, disabled, output);
  } else ATH_MSG_WARNING(" ::jepLut: Unknown stragegy: " << strategy);
}

jepLutParams()

void LVL1::L1TriggerTowerTool::jepLutParams ( const L1CaloCoolChannelId & channelId, int & startBit, int & slope, int & offset, int & cut, int & pedValue, float & pedMean, int & strategy, bool & disabled )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1311 of file L1TriggerTowerTool.cxx.

{
  startBit = 0;
  strategy = 0;
  offset   = 0;
  double offsetReal = 0;
  slope    = 0;
  cut      = 0;
  pedValue = 0;
  pedMean  = 0.;
  disabled = true;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
  
  if(!isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::jepLutParams: Run-1 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainerRun2*>(m_conditionsContainer);
 
    const L1CaloPprConditionsRun2* settings = conditionsContainer->pprConditions(channelId.id());
    if(settings) {
      startBit = settings->firStartBit();
      strategy = settings->lutJepStrategy();
      slope    = settings->lutJepSlope();
      cut      = settings->lutJepNoiseCut();
      pedValue = settings->pedValue();
      pedMean  = settings->pedMean();
 
      hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
 
      for (unsigned int i = 0; i < hwCoeffs->size(); i++){
    hwCoeffSum += hwCoeffs->at(i);
      }
      
      if (strategy == 0){
    offsetReal = pedMean * hwCoeffSum / pow(2.,startBit);
      }
      else{
    offsetReal = pedMean * hwCoeffSum * slope / pow(2.,startBit) - slope/2.;
      }
      offset = static_cast<unsigned short>( offsetReal < 0. ? 0 : offsetReal + 0.5 );
      
      ATH_MSG_VERBOSE( "::jepLutParams: Offset: offset/strategy/pedMean/firCoeffSum/startBit/slope: "
             << offset << " " << strategy << " " << " " << pedMean << " " << hwCoeffSum << " " << startBit << " " << slope );
 
    } else ATH_MSG_WARNING( "::jepLutParams: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::jepLutParams: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::jepLutParams: LUT startBit/strategy/offset/slope/cut/pedValue/pedMean: "
          << startBit << " " << strategy << " " << offset << " " << slope << " " << cut << " " << pedValue << " " << pedMean );
  unsigned int noiseCut = 0;
  disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
}

loadFTRefs()

StatusCode LVL1::L1TriggerTowerTool::loadFTRefs ( )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1612 of file L1TriggerTowerTool.cxx.

{
    //method to load the FineTimeReferences Folder from COOL or an sqlite file (needs to be included in the job options)
    //implementation very similar to L1TriggerTowerTool::retrieveConditions
    //calling this method outside of fillHistograms() can result in Errors
 
    // this method new requires L1CalCondAlg to be scheduled
    m_dbFineTimeRefsTowers = nullptr;
    bool verbose = msgLvl(MSG::VERBOSE);
    SG::ReadCondHandle <L1CaloPpmFineTimeRefsContainer> rh(m_dbFineTimeRefsTowersKey);
    CHECK_WITH_CONTEXT(rh.isValid(), "L1TriggerTowerTool");
    m_dbFineTimeRefsTowers = (*rh);
    if (verbose) {
        ATH_MSG_VERBOSE( "Retrieved FineTimeReferences Container" );
        rh->dump();
    }
    return StatusCode::SUCCESS;
}

lut() [1/2]

void LVL1::L1TriggerTowerTool::lut ( const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

LUT simulation: pedestal subtraction, energy calibration and threshold.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 760 of file L1TriggerTowerTool.cxx.

{   
  int strategy = 0;
  int offset   = 0;
  int slope    = 0;
  int cut      = 0;
  int ped      = 0;
 
  if(isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::lut: Run-2 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainer*>(m_conditionsContainer);
    const L1CaloPprConditions* settings = conditionsContainer->pprConditions(channelId.id());
    if (settings) {
      strategy = settings->lutStrategy();
      offset   = settings->lutOffset();
      slope    = settings->lutSlope();
      cut      = settings->lutNoiseCut();
      ped      = settings->pedValue();
    } else ATH_MSG_WARNING( "::lut: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::lut: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::lut: LUT strategy/offset/slope/cut/ped: "
          << strategy << " " << offset << " " << slope << " " << cut << " " << ped << " " );
 
  unsigned int noiseCut = 0;
  bool disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
 
  lut(fir, slope, offset, cut, ped, strategy, disabled, output);
}

lut() [2/2]

void LVL1::L1TriggerTowerTool::lut ( const std::vector< int > & fir, int slope, int offset, int cut, int ped, int strategy, bool disabled, std::vector< int > & output )

virtual

LUT simulation: pedestal subtraction, energy calibration and threshold.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 946 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations
  
  std::vector<int>::const_iterator it = fir.begin();
  for ( ; it != fir.end(); ++it) {
    int out = 0;
    if (!disabled) {
      if (strategy == 0 && (*it) >= offset+cut) { // Original scheme
        out = (((*it)-offset)*slope + 2048)>>12;
      } else if (strategy == 1 && (*it)*slope >= offset+cut) { // New scheme
        out = ((*it)*slope - offset + 2048)>>12;
      }
      if (out < 0)                 out = 0;
      if (out > s_saturationValue) out = s_saturationValue;
    }
    output.push_back(out);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::lut: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  } 
}

lutParams()

void LVL1::L1TriggerTowerTool::lutParams ( const L1CaloCoolChannelId & channelId, int & startBit, int & slope, int & offset, int & cut, int & pedValue, float & pedMean, int & strategy, bool & disabled )

virtual

Return LUT parameters for a channel.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1216 of file L1TriggerTowerTool.cxx.

{
  startBit = 0;
  strategy = 0;
  offset   = 0;
  slope    = 0;
  cut      = 0;
  pedValue = 0;
  pedMean  = 0.;
  disabled = true;
  
  if(isRun2()) {
    // assert instead ?!
    ATH_MSG_WARNING("::lutParams: Run-2 data - behaviour undefined!");
  }
 
  if(m_conditionsContainer.has_value()) {
    auto conditionsContainer = std::any_cast<L1CaloPprConditionsContainer*>(m_conditionsContainer);
 
    const L1CaloPprConditions* settings = conditionsContainer->pprConditions(channelId.id());
    if (settings) {
      startBit = settings->firStartBit();
      strategy = settings->lutStrategy();
      offset   = settings->lutOffset();
      slope    = settings->lutSlope();
      cut      = settings->lutNoiseCut();
      pedValue = settings->pedValue();
      pedMean  = settings->pedMean();
    } else ATH_MSG_WARNING( "::lutParams: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::lutParams: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::lutParams: LUT startBit/strategy/offset/slope/cut/pedValue/pedMean: "
          << startBit << " " << strategy << " " << offset << " " << slope << " " << cut << " " << pedValue << " " << pedMean );
  unsigned int noiseCut = 0;
  disabled = disabledChannel(channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nonLinearLut()

void LVL1::L1TriggerTowerTool::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

Definition at line 972 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations
 
  std::vector<int>::const_iterator it = fir.begin();
  for ( ; it != fir.end(); ++it) {
    int out = 0;
    if (!disabled) {
      // turn shorts into double
      double nll_slope = 0.001 * scale;
      double nll_offset = 0.001 * par1;
      double nll_ampl = 0.001 * par2;
      double nll_expo = 0.;
      if(par3) {
        nll_expo = -1. / (4096 * 0.001*par3);
      } else {
        nll_ampl = 0.;
      }
      double nll_noise = 0.001 * par4;
      
      // noise cut
      if ((*it) * slope < offset + nll_noise * cut) {
        output.push_back(0);
        continue;
      }
      // actual calculation
      out = int((((int)(2048 + nll_slope * ((*it) * slope - offset)))>>12) + nll_offset + nll_ampl * std::exp(nll_expo * ((*it) * slope - offset)));
 
      if(out > s_saturationValue) out = s_saturationValue;
      if(out < 0)                 out = 0;
    }
    output.push_back(out);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::nonLinearLut: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  } 
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

peakBcid() [1/2]

void LVL1::L1TriggerTowerTool::peakBcid ( const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Peak finder BCID.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 562 of file L1TriggerTowerTool.cxx.

{
  unsigned int strategy = 0;
  if(m_conditionsContainer.has_value()) {
    if(isRun2())
      strategy = getStrategy<L1CaloPprConditionsContainerRun2>(m_conditionsContainer);
    else
      strategy = getStrategy<L1CaloPprConditionsContainer>(m_conditionsContainer);
  } else ATH_MSG_WARNING( "::peakBcid: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::peakBcid: peak-finder strategy: " << strategy );
  
  peakBcid(fir, strategy, output);
}

peakBcid() [2/2]

void LVL1::L1TriggerTowerTool::peakBcid ( const std::vector< int > & fir, unsigned int strategy, std::vector< int > & output )

virtual

Peak finder BCID.

Cannot evaluate for first and last samples in vector

Select peak-finder strategy & test

Implements LVL1::IL1TriggerTowerTool.

Definition at line 578 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations
 
  for (unsigned int i = 0; i < fir.size(); i++) {
    int result = 0;
    if (i > 0 && i < fir.size()-1) {
      if (strategy&0x1) {
        if ( (fir[i-1]<fir[i]) && (fir[i+1]<fir[i]) ) result = 1;
      } else {
        if ( (fir[i-1]<fir[i]) && (fir[i+1]<=fir[i]) ) result = 1;
      }
    }
    output.push_back(result);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::peakBcid: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

pedestalCorrection()

void LVL1::L1TriggerTowerTool::pedestalCorrection ( std::vector< int > & firInOut, int firPed, int iElement, int layer, int bcid, float mu, std::vector< int_least16_t > & correctionOut )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1661 of file L1TriggerTowerTool.cxx.

                                                                                                                                                                      {
  unsigned nFIR = firInOut.size();
  correctionOut.assign(nFIR, 0u);
 
  if(!m_correctFir) return;
 
  // apply the pedestal correction
  for(unsigned i = 0; i != nFIR; ++i) {
    correctionOut[i] = (m_dynamicPedestalProvider->dynamicPedestal(iElement, layer, firPed, bcid + i - nFIR/2, mu) - firPed);
    firInOut[i] -= correctionOut[i];
 
    if(firInOut[i] < 0) firInOut[i] = 0;
  }
 
  if(m_debug) {
    ATH_MSG_VERBOSE( "::pedestalCorrection(BCID=" << bcid << ", mu = " << mu << "): ");
    printVec(correctionOut);
    ATH_MSG_VERBOSE(" ");
  }
}

printVec()

template<typename T>

void LVL1::L1TriggerTowerTool::printVec ( const std::vector< T > & vec )

private

Print a vector to debug.

Definition at line 1600 of file L1TriggerTowerTool.cxx.

{
  if (m_debug) {
    if (vec.empty()) ATH_MSG_VERBOSE( " empty ");
    else {
      for(auto v : vec) {
        ATH_MSG_VERBOSE( v << " ");
      }
    }
  }
}

process() [1/2]

void LVL1::L1TriggerTowerTool::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

All-in-one routine - give it the ADC counts and TT identifier, and it returns the results.

Initialise

emulate FIR filter

emulate the two BCID algorithms

evaluate BCID decisions

LUT ET calculation

Use ET range to return appropriate ET value do not test BCID here, since no guarantee enough ADC samples to evaluate it reliably

Implements LVL1::IL1TriggerTowerTool.

Definition at line 210 of file L1TriggerTowerTool.cxx.

{
  if (m_debug) {
    ATH_MSG_VERBOSE( "::process: ==== Entered Process ====" );
    ATH_MSG_VERBOSE( "::process: digits: ");
    printVec(digits);
    ATH_MSG_VERBOSE( " channelID: " << MSG::hex << channelId.id() << MSG::dec );
  }
 
  et.clear();
  bcidResults.clear();
  bcidDecisions.clear();
 
  ATH_MSG_VERBOSE( "::process: ---- FIR filter ----" );
     
  std::vector<int> filter;
  fir(digits, channelId, filter);
  std::vector<int> lutInput;
  dropBits(filter, channelId, lutInput);
 
  ATH_MSG_VERBOSE( "::process: ---- BCID algorithms ----" );

  bcid(filter, digits, channelId, bcidResults);
 
  ATH_MSG_VERBOSE( "::process: ---- BCID decisions ----" );

  std::vector<int> decisionRange;
  bcidDecisionRange(lutInput, digits, channelId, decisionRange);
  bcidDecision(bcidResults, decisionRange, channelId, bcidDecisions);
 
  ATH_MSG_VERBOSE( "::process: ---- LUT ET calculation ----" );

  std::vector<int> lutOutput;
  if(isRun2()) {
    if(useJepLut) jepLut(lutInput, channelId, lutOutput);
    else cpLut(lutInput, channelId, lutOutput);
  } else {
    lut(lutInput, channelId, lutOutput);
  }
 
  ATH_MSG_VERBOSE( "::process: ---- use ET range ----" );

  applyEtRange(lutOutput, decisionRange, channelId, et);
 
  ATH_MSG_VERBOSE( "::process: ==== Leaving Process ====" );
}

process() [2/2]

void LVL1::L1TriggerTowerTool::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

Take in vector of ADC digits, return PPrASIC results.

All-in-one routine - give it the ADC counts and TT identifier, and it returns the results.

Find channelID for this tower

then process the tower

Implements LVL1::IL1TriggerTowerTool.

Definition at line 196 of file L1TriggerTowerTool.cxx.

{
  L1CaloCoolChannelId id = channelID(eta, phi, layer);

  process(digits, id, et, bcidResults, bcidDecisions, useJepLut);
}

refValues()

std::pair< double, double > LVL1::L1TriggerTowerTool::refValues ( const L1CaloCoolChannelId & channelId )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1631 of file L1TriggerTowerTool.cxx.

{
  //method returning the fine time reference and calibration value
  //the fineTimeReference folder has to be loaded first using the method L1TriggerTowerTool::loadFTRefs
  double reference = 0;
  double calib = 0;
  
  if (m_dbFineTimeRefsTowers) {
    const L1CaloPpmFineTimeRefs* ftref = m_dbFineTimeRefsTowers->ppmFineTimeRefs(channelId.id());
    if (ftref) {
      FineTimeErrorCode errorCode(ftref->errorCode());
//        if (errorCode.chanValid()) { //this should be changed at some point, at the moment the error code is ignored
      reference = ftref->refValue();
      calib = ftref->calibValue();
//        }
      
      ATH_MSG_VERBOSE( MSG::hex
              << "::refValues: errorCode: " << (ftref->errorCode()).errorCode()
             << MSG::dec << "  reference: " << ftref->refValue() << "  calib: "  << ftref->calibValue() );
  
    } else {
      ATH_MSG_VERBOSE( "::refValue: No FineTimeRefsTowers found" );
    }
  } else {
    ATH_MSG_VERBOSE( "::refValue: No FineTimeRefs Container retrieved" );
  }
  
  return std::make_pair(reference, calib);
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieveConditions()

StatusCode LVL1::L1TriggerTowerTool::retrieveConditions ( )

virtual

Retrieve pointers to the L1Calo conditions containers.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 155 of file L1TriggerTowerTool.cxx.

{
    ATH_MSG_VERBOSE("L1TriggerTowerTool::retrieveConditions");
 
    // retrieving direct from detector store, requires L1CaloCondAlg to have been scheduled
    // strategy logic etc is now done inside the L1CaloCondAlg too
    // so we just need to retrieve three containers (runpars, conditions, disabledchannels) ...
    bool verbose = msgLvl(MSG::VERBOSE);
 
    SG::ReadCondHandle <L1CaloRunParametersContainer> rh_rp(m_runParametersContainerKey);
    CHECK_WITH_CONTEXT(rh_rp.isValid(), "L1TriggerTowerTool");
    m_runParametersContainer = (*rh_rp);
    if (verbose) {
        ATH_MSG_VERBOSE( "Retrieved RunParametersContainer" );
        rh_rp->dump();
    }
 
    if(isRun2()) {
        SG::ReadCondHandle <L1CaloPprConditionsContainerRun2> rh_c(m_conditionsContainerKeyRun2);
        CHECK_WITH_CONTEXT(rh_c.isValid(), "L1TriggerTowerTool");
        m_conditionsContainer = (*rh_c);
        if (verbose) {
            ATH_MSG_VERBOSE( "Retrieved ConditionsContainer" );
            rh_c->dump();
        }
        SG::ReadCondHandle <L1CaloPprDisabledChannelContainerRun2> rh_dc(m_disabledChannelContainerKeyRun2);
        CHECK_WITH_CONTEXT(rh_dc.isValid(), "L1TriggerTowerTool");
        m_disabledChannelContainer = (*rh_dc);
        if (verbose) {
            ATH_MSG_VERBOSE( "Retrieved DisabledChannelContainer" );
            rh_dc->dump();
        }
    } else {
        ATH_MSG_ERROR("non-Run2 no longer supported ... requires update to L1CaloCondAlg to create non-Run2 versions of containers");
        return StatusCode::FAILURE;
    }
  return StatusCode::SUCCESS;
}

satBcid() [1/2]

void LVL1::L1TriggerTowerTool::satBcid ( const std::vector< int > & digits, const L1CaloCoolChannelId & channelId, std::vector< int > & output )

virtual

Saturated pulse BCID.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 614 of file L1TriggerTowerTool.cxx.

{  
  int satLevel = 0;
  int satLow   = 0;
  int satHigh  = 0;
  if (m_conditionsContainer.has_value()) {
    bool available = false;
    if(isRun2())
      std::tie(available, satLevel, satLow, satHigh) = getSaturation<L1CaloPprConditionsContainerRun2>(channelId.id(), m_conditionsContainer);
    else
      std::tie(available, satLevel, satLow, satHigh) = getSaturation<L1CaloPprConditionsContainer>(channelId.id(), m_conditionsContainer);
    if(!available) ATH_MSG_WARNING( "::satBcid: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::satBcid: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::satBcid: satLevel: " << satLevel
      << " satLow: "  << satLow
      << " satHigh: " << satHigh );
 
  satBcid(digits, satLow, satHigh, satLevel, output);
}

satBcid() [2/2]

void LVL1::L1TriggerTowerTool::satBcid ( const std::vector< int > & digits, int satLow, int satHigh, int satLevel, std::vector< int > & output )

virtual

Saturated pulse BCID.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 637 of file L1TriggerTowerTool.cxx.

{
  output.clear();
  output.reserve(digits.size()); // avoid frequent reallocations
  
  bool enabled = true;
  int flag[2] = {0,0};
 
  for (unsigned int i = 0; i<digits.size(); i++) {
    // Algorithm can set flag for following sample. So here we
    // propagate such flags into the current sample.
    flag[0] = flag[1];
    flag[1] = 0;
    
    if (digits[i]>=satLevel) {   // do we have saturation?
      if (enabled && i>1) {        // is algorithm active?
        bool low  = (digits[i-2]>satLow);
        bool high = (digits[i-1]>satHigh);
        if (high) {                             // flag current or next sample?
          if (low) {
            flag[0] = 1;
          }
          else {
            flag[1] = 1;
          }
        }
        else {
          flag[1] = 1;
        }
      }
      enabled = false;             // after first saturation, disable algorithm
    }
    else {
      enabled = true;              // unsaturated sample reenables algorithm
    }
    output.push_back(flag[0]);
  }
  if (m_debug) {
    ATH_MSG_VERBOSE( "::satBcid: output: ");
    printVec(output);
   ATH_MSG_VERBOSE(" ");
  }
}

satOverride()

bool LVL1::L1TriggerTowerTool::satOverride ( int range, const L1CaloCoolChannelId & channelId )

virtual

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1464 of file L1TriggerTowerTool.cxx.

{
  bool override = false;
  if(m_conditionsContainer.has_value()) {
    std::tuple<bool, bool, bool> satOverride;
    if(isRun2())
      satOverride = getSatOverride<L1CaloPprConditionsContainerRun2>(m_conditionsContainer);
    else
      satOverride = getSatOverride<L1CaloPprConditionsContainer>(m_conditionsContainer);
    // NB Reverse order as for bcidDecision1/2/3
    if (range == 0) override = std::get<2>(satOverride);
    if (range == 1) override = std::get<1>(satOverride);
    if (range == 2) override = std::get<0>(satOverride);
  } else ATH_MSG_WARNING( "::satOverride: No Conditions Container retrieved" );
 
  ATH_MSG_VERBOSE( "::satOverride: range " << range
          << " has saturation override flag " << override );
  
  return override;
}

setDebug()

void LVL1::L1TriggerTowerTool::setDebug ( bool debug )

virtual

Finer control of debug printing.

Implements LVL1::IL1TriggerTowerTool.

Definition at line 1533 of file L1TriggerTowerTool.cxx.

{
  m_debug = (debug && msgLvl(MSG::VERBOSE));
}

simulateChannel()

void LVL1::L1TriggerTowerTool::simulateChannel ( const xAOD::TriggerTower & tt, std::vector< int > & outCpLut, std::vector< int > & outJepLut, std::vector< int > & bcidResults, std::vector< int > & bcidDecisions )

virtual

All-in-one routine - give it the TT identifier, and it returns the results.

Initialise

emulate FIR filter

apply pedestal correction

emulate the two BCID algorithms

evaluate BCID decisions

LUT ET calculation

Use ET range to return appropriate ET value do not test BCID here, since no guarantee enough ADC samples to evaluate it reliably

Implements LVL1::IL1TriggerTowerTool.

Definition at line 278 of file L1TriggerTowerTool.cxx.

{
 
  //If we have 80 MHz readout, we need to extract the 40 MHz samples. The central 80 MHz sample is always a 40 MHz sample. We use the cool database (runParameters folder) to understand if we are in 80MHz readout
 
  unsigned int readoutConfigID   = std::cbegin(*m_runParametersContainer)->readoutConfigID();
 
  if(m_debug){
    ATH_MSG_VERBOSE("ReadoutConfigID = " << readoutConfigID );
  }
 
  std::vector<uint16_t> digits40;
 
  if(readoutConfigID == 5 or readoutConfigID == 6){
 
    if(m_debug){
      ATH_MSG_VERBOSE("80 MHz readout detected, emulating 40 MHz samples");
    }
 
    int nSlices = tt.adc().size();
 
    if((nSlices%4)==3){
      for (int i=0 ; i < (nSlices-1)/2 ; i++ ){
    digits40.push_back(tt.adc().at(2*i+1));
      }
    }
    else if((nSlices%4)==1){
      for (int i=0 ; i <= (nSlices-1)/2 ; i++){
    digits40.push_back(tt.adc().at(2*i));
      }
    }
 
 
  }else{
    if(m_debug){
      ATH_MSG_VERBOSE("40 MHz readout detected");
    }
    digits40 = tt.adc();
  }
  
  const auto& digits = convertVectorType<int>(digits40);
 
  L1CaloCoolChannelId channelId {tt.coolId()}; 
 
  if (m_debug) {
    ATH_MSG_VERBOSE( "::simulateChannel: ==== Entered Process ====" );
    ATH_MSG_VERBOSE( "::simulateChannel: digits: ");
    printVec(digits);
    ATH_MSG_VERBOSE( "::simulateChannel: channelID: " << MSG::hex << channelId.id() << MSG::dec );
  }
  
  outCpLut.clear();
  outJepLut.clear();
  bcidResults.clear();
  bcidDecisions.clear();
      
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- FIR filter ----" );
  std::vector<int> filter;
  fir(digits, channelId, filter);
  if (m_debug) printVec(filter);
 

  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- pedestalCorrection ----" );
  // the correction is only available for each LUT slice in the read-out (not ADC/Filter slice)
  // therefore we can only apply it to the #LUT central filter slices
  const std::size_t nCorr = tt.correctionEnabled().size();
  const std::size_t filterOffset = filter.size()/2 - nCorr/2;
  for(std::size_t iCorr = 0; iCorr < nCorr; ++iCorr) {
    filter[filterOffset + iCorr] -= tt.correction()[iCorr] * tt.correctionEnabled()[iCorr];
  }
  if (m_debug)  printVec(filter);
 
  std::vector<int> lutInput;
  dropBits(filter, channelId, lutInput);
 
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- BCID algorithms ----" );

  bcid(filter, digits, channelId, bcidResults);
 
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- BCID decisions ----" );

  std::vector<int> decisionRange;
  bcidDecisionRange(lutInput, digits, channelId, decisionRange);
  bcidDecision(bcidResults, decisionRange, channelId, bcidDecisions);
 
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- LUT ET calculation ----" );

  std::vector<int> cpLutOutput, jepLutOutput;
  cpLut(lutInput, channelId, cpLutOutput);
  jepLut(lutInput, channelId, jepLutOutput);
 
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ---- use ET range ----" );

  applyEtRange(cpLutOutput, decisionRange, channelId, outCpLut);
  applyEtRange(jepLutOutput, decisionRange, channelId, outJepLut);
 
  if (m_debug) ATH_MSG_VERBOSE( "::simulateChannel: ==== Leaving Process ====" );
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_caloMgr

const CaloIdManager* LVL1::L1TriggerTowerTool::m_caloMgr

private

Id managers.

Definition at line 147 of file L1TriggerTowerTool.h.

m_conditionsContainer

std::any LVL1::L1TriggerTowerTool::m_conditionsContainer

private

Definition at line 168 of file L1TriggerTowerTool.h.

m_conditionsContainerKeyRun2

SG::ReadCondHandleKey<L1CaloPprConditionsContainerRun2> LVL1::L1TriggerTowerTool::m_conditionsContainerKeyRun2 { this, "InputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"}

private

Definition at line 160 of file L1TriggerTowerTool.h.

{ this, "InputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"};

m_correctFir

bool LVL1::L1TriggerTowerTool::m_correctFir

private

Baseline correction Tool.

Definition at line 179 of file L1TriggerTowerTool.h.

m_dbFineTimeRefsTowers

const L1CaloPpmFineTimeRefsContainer* LVL1::L1TriggerTowerTool::m_dbFineTimeRefsTowers = nullptr

private

For the fine time monitoring.

Definition at line 172 of file L1TriggerTowerTool.h.

m_dbFineTimeRefsTowersKey

SG::ReadCondHandleKey<L1CaloPpmFineTimeRefsContainer> LVL1::L1TriggerTowerTool::m_dbFineTimeRefsTowersKey { this, "InputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"}

private

Definition at line 162 of file L1TriggerTowerTool.h.

{ this, "InputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"};

m_debug

bool LVL1::L1TriggerTowerTool::m_debug = false

private

Definition at line 144 of file L1TriggerTowerTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_disabledChannelContainer

std::any LVL1::L1TriggerTowerTool::m_disabledChannelContainer

private

Definition at line 169 of file L1TriggerTowerTool.h.

m_disabledChannelContainerKeyRun2

SG::ReadCondHandleKey<L1CaloPprDisabledChannelContainerRun2> LVL1::L1TriggerTowerTool::m_disabledChannelContainerKeyRun2 { this, "InputKeyDisabledChannelRun2", "L1CaloPprDisabledChannelContainerRun2"}

private

Definition at line 161 of file L1TriggerTowerTool.h.

{ this, "InputKeyDisabledChannelRun2", "L1CaloPprDisabledChannelContainerRun2"};

m_dynamicPedestalProvider

ToolHandle<LVL1::IL1DynamicPedestalProvider> LVL1::L1TriggerTowerTool::m_dynamicPedestalProvider

private

Definition at line 180 of file L1TriggerTowerTool.h.

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> LVL1::L1TriggerTowerTool::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }

private

Definition at line 182 of file L1TriggerTowerTool.h.

{ this, "EventInfoKey", "EventInfo", "" };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idTable

std::vector<unsigned int> LVL1::L1TriggerTowerTool::m_idTable

private

Mapping lookup table.

Definition at line 176 of file L1TriggerTowerTool.h.

m_l1CaloTTIdTools

ToolHandle<LVL1::IL1CaloTTIdTools> LVL1::L1TriggerTowerTool::m_l1CaloTTIdTools

private

Definition at line 152 of file L1TriggerTowerTool.h.

m_L1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> LVL1::L1TriggerTowerTool::m_L1MenuKey { this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" }

private

Definition at line 184 of file L1TriggerTowerTool.h.

{ this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu" };

m_lvl1Helper

const CaloLVL1_ID* LVL1::L1TriggerTowerTool::m_lvl1Helper

private

and tools for computing identifiers

Definition at line 150 of file L1TriggerTowerTool.h.

m_mappingTool

ToolHandle<LVL1::IL1CaloMappingTool> LVL1::L1TriggerTowerTool::m_mappingTool

private

and mappings

Definition at line 156 of file L1TriggerTowerTool.h.

m_nBcid

const int LVL1::L1TriggerTowerTool::m_nBcid = 350

staticprivate

Definition at line 190 of file L1TriggerTowerTool.h.

m_runParametersContainer

const L1CaloRunParametersContainer* LVL1::L1TriggerTowerTool::m_runParametersContainer = nullptr

private

Definition at line 164 of file L1TriggerTowerTool.h.

m_runParametersContainerKey

SG::ReadCondHandleKey<L1CaloRunParametersContainer> LVL1::L1TriggerTowerTool::m_runParametersContainerKey { this, "InputKeyRunParameters", "L1CaloRunParametersContainer"}

private

L1Calo conditions.

Definition at line 159 of file L1TriggerTowerTool.h.

{ this, "InputKeyRunParameters", "L1CaloRunParametersContainer"};

m_ttSvc

ToolHandle<CaloTriggerTowerService> LVL1::L1TriggerTowerTool::m_ttSvc

private

Definition at line 153 of file L1TriggerTowerTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_maxTowers

const int LVL1::L1TriggerTowerTool::s_maxTowers = 7168

staticprivate

Definition at line 189 of file L1TriggerTowerTool.h.

s_saturationValue

const int LVL1::L1TriggerTowerTool::s_saturationValue = 255

staticprivate

Parameters.

Definition at line 188 of file L1TriggerTowerTool.h.

---

The documentation for this class was generated from the following files:

• L1TriggerTowerTool.h
• L1TriggerTowerTool.cxx