LVL1::L1TriggerTowerToolRun3 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 <L1TriggerTowerToolRun3.h>

Inheritance diagram for LVL1::L1TriggerTowerToolRun3:

Public Member Functions
	L1TriggerTowerToolRun3 (const std::string &, const std::string &, const IInterface *)
virtual	~L1TriggerTowerToolRun3 ()
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	finalize () override
	standard Athena-Algorithm method
virtual void	handle (const Incident &) override
	catch begRun
virtual void	process (const EventContext &ctx, 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) override
	Take in vector of ADC digits, return PPrASIC results.
virtual void	process (const EventContext &ctx, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &et, std::vector< int > &bcidResults, std::vector< int > &bcidDecisions, bool useJepLut=true) override
	All-in-one routine - give it the ADC counts and TT identifier, and it returns the results.
virtual void	simulateChannel (const EventContext &ctx, const xAOD::TriggerTower &tt, std::vector< int > &outCpLut, std::vector< int > &outJepLut, std::vector< int > &bcidResults, std::vector< int > &bcidDecisions) const override
	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) override
virtual void	fir (const EventContext &ctx, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
	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) const override
	This FIR simulation produces a vector of same length as digit vector, with peak positions corresponding.
virtual void	dropBits (const EventContext &ctx, const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
virtual void	dropBits (const std::vector< int > &fir, unsigned int first, std::vector< int > &output) const override
	Truncate FIR results for LUT input.
virtual void	etRange (const EventContext &ctx, const std::vector< int > &et, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
virtual void	etRange (const std::vector< int > &et, int energyLow, int energyHigh, std::vector< int > &output) const override
	Identify BCID decision range.
virtual void	peakBcid (const EventContext &ctx, const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
	Peak finder BCID.
virtual void	peakBcid (const std::vector< int > &fir, unsigned int strategy, std::vector< int > &output) const override
	Peak finder BCID.
virtual void	satBcid (const EventContext &ctx, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
	Saturated pulse BCID.
virtual void	satBcid (const std::vector< int > &digits, int satLow, int satHigh, int satLevel, std::vector< int > &output) const override
	Saturated pulse BCID.
virtual void	bcid (const EventContext &ctx, const std::vector< int > &fir, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
	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) const override
	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) const override
	Evaluate both peak-finder and saturated BCID algorithms and return vectors of predicted BCID result and decision words.
virtual void	bcidDecisionRange (const EventContext &ctx, const std::vector< int > &lutInput, const std::vector< int > &digits, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
virtual void	bcidDecision (const EventContext &ctx, const std::vector< int > &bcidResults, const std::vector< int > &range, std::vector< int > &output) const override
virtual void	cpLut (const EventContext &ctx, const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
virtual void	jepLut (const EventContext &ctx, const std::vector< int > &fir, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
virtual void	lut (const std::vector< int > &fir, int slope, int offset, int cut, int strategy, bool disabled, std::vector< int > &output) const override
	LUT simulation: pedestal subtraction, energy calibration and threshold.
virtual void	applyEtRange (const EventContext &ctx, const std::vector< int > &lut, const std::vector< int > &range, const L1CaloCoolChannelId &channelId, std::vector< int > &output) const override
	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 EventContext &ctx, const L1CaloCoolChannelId &channelId, std::vector< int > &firCoeffs) const override
	Return FIR filter parameters for a channel.
virtual void	bcidParams (const EventContext &ctx, const L1CaloCoolChannelId &channelId, int &energyLow, int &energyHigh, int &decisionSource, std::vector< unsigned int > &decisionConditions, unsigned int &peakFinderStrategy, int &satLow, int &satHigh, int &satLevel) const override
	Return BCID parameters for a channel.
virtual void	cpLutParams (const EventContext &ctx, const L1CaloCoolChannelId &channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled) override
virtual void	jepLutParams (const EventContext &ctx, const L1CaloCoolChannelId &channelId, int &startBit, int &slope, int &offset, int &cut, int &pedValue, float &pedMean, int &strategy, bool &disabled) override
virtual Identifier	identifier (double eta, double phi, int layer) override
	Return offline identifier for given tower coordinates.
virtual HWIdentifier	hwIdentifier (const Identifier &id) override
	Return online identifier for given offline identifier.
virtual HWIdentifier	hwIdentifier (double eta, double phi, int layer) override
	Return online identifier for given tower coordinates.
virtual L1CaloCoolChannelId	channelID (double eta, double phi, int layer) override
	Return Cool channel identifier for given tower coordinates.
virtual L1CaloCoolChannelId	channelID (const Identifier &id) override
	Return Cool channel identifier for given offline identifier.
virtual bool	satOverride (const EventContext &ctx, int range) const override
virtual bool	disabledChannel (const EventContext &ctx, const L1CaloCoolChannelId &channelId) const override
	Check for disabled channel.
virtual double	FCalTTeta (const L1CaloCoolChannelId &channelId) override
	Return median eta of trigger tower from L1CaloCoolChannelId.
virtual double	FCalTTeta (double nominalEta, double phi, int layer) override
	Calculate median eta of FCAL trigger tower from nominal eta and layer.
virtual std::pair< double, double >	refValues (const EventContext &ctx, const L1CaloCoolChannelId &channelId) override
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 EventContext &ctx) const
void	bcidDecision (const std::vector< int > &bcidResults, const std::vector< int > &range, const std::vector< unsigned int > &mask, std::vector< int > &output) const
	Evaluate BCID decision based on BCID word, ET range and decision mask.
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) const
bool	disabledChannel (const EventContext &ctx, const L1CaloCoolChannelId &channelId, unsigned int &noiseCut) const
	Get extra noise cut with disabled channel.
unsigned int	getLutOffset (const double &pedMean, const unsigned int &firStartBit, const std::vector< short int > &firCoeff, const unsigned int &lutSlope, const unsigned int &lutStrategy) const
const TrigConf::L1Menu *	getL1Menu (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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< L1CaloPprConditionsContainerRun2 >	m_pprConditionsContainerRun2 { this, "InputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"}
SG::ReadCondHandleKey< L1CaloPprDisabledChannelContainerRun2 >	m_pprDisabledChannelContainer { this, "InputKeyDisabledChannel", "L1CaloPprDisabledChannelContainerRun2"}
SG::ReadCondHandleKey< L1CaloPpmFineTimeRefsContainer >	m_ppmFineTimeRefsContainer { this, "InputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"}
SG::ReadCondHandleKey< L1CaloRunParametersContainer >	m_runParametersContainer { this, "InputKeyRunParameters", "L1CaloRunParametersContainer"}
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" }
ServiceHandle< TrigConf::ITrigConfigSvc >	m_configSvc {this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc"}
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: L1TriggerTowerToolRun3->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 56 of file L1TriggerTowerToolRun3.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

L1TriggerTowerToolRun3()

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

Definition at line 38 of file L1TriggerTowerToolRun3.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_correctFir(false),
  m_dynamicPedestalProvider("", this)
{
  declareInterface<IL1TriggerTowerToolRun3>(this);
 
  declareProperty( "BaselineCorrection", m_correctFir );
  declareProperty( "L1DynamicPedestalProvider", m_dynamicPedestalProvider );
}

~L1TriggerTowerToolRun3()

LVL1::L1TriggerTowerToolRun3::~L1TriggerTowerToolRun3 ( )

virtual

default destructor

Definition at line 59 of file L1TriggerTowerToolRun3.cxx.

{}

Member Function Documentation

applyEtRange()

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

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 902 of file L1TriggerTowerToolRun3.cxx.

{
  bool disabled = disabledChannel(ctx, 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(ctx, (*itrange))) output.push_back(s_saturationValue);
    else                                                 output.push_back(*itlut);
    ++itlut;
    ++itrange;
  }
  
  ATH_MSG_DEBUG( "::applyEtRange: output: " << output);
 
}

bcid() [1/3]

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

overridevirtual

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

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 330 of file L1TriggerTowerToolRun3.cxx.

{
  // Get decision flags for the 2 BCID algorithms
  std::vector<int> peak;
  peakBcid(ctx, filter, channelId, peak);
  std::vector<int> sat;
  satBcid(ctx, 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) );
  }
 
  ATH_MSG_DEBUG( "::bcid: bcidResults: " << output);
 
}

bcid() [2/3]

void LVL1::L1TriggerTowerToolRun3::bcid ( const std::vector< int > & fir, const std::vector< int > & digits, unsigned int strategy, int satLow, int satHigh, int satLevel, std::vector< int > & output ) const

overridevirtual

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

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 354 of file L1TriggerTowerToolRun3.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) );
  }
 
  ATH_MSG_DEBUG( "::bcid: bcidResults: " << output);
}

bcid() [3/3]

void LVL1::L1TriggerTowerToolRun3::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 ) const

overridevirtual

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

evaluate BCID decisions

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 378 of file L1TriggerTowerToolRun3.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) );
  }
 
  ATH_MSG_DEBUG( "::bcid: bcidResults: " << result);
  
 

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

bcidDecision() [1/2]

void LVL1::L1TriggerTowerToolRun3::bcidDecision ( const EventContext & ctx, const std::vector< int > & bcidResults, const std::vector< int > & range, std::vector< int > & output ) const

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 640 of file L1TriggerTowerToolRun3.cxx.

{
  unsigned int decision1 = 0;
  unsigned int decision2 = 0;
  unsigned int decision3 = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if(!m_pprConditionsContainerRun2.empty()) {
    std::tie(decision1, decision2, decision3) = getBcidDecision<L1CaloPprConditionsContainerRun2>(pprConditionsRun2);
  } 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_DEBUG( "::bcidDecision: masks: " << MSG::hex
         << decision3 << " " << decision2 << " " << decision1 << MSG::dec );
 
  bcidDecision(bcidResults, range, mask, output);
}

bcidDecision() [2/2]

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

private

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

Definition at line 662 of file L1TriggerTowerToolRun3.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);
  }
 
  ATH_MSG_DEBUG( "::bcidDecision: output: " << output);
 
 
}

bcidDecisionRange()

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 614 of file L1TriggerTowerToolRun3.cxx.

{
  int decisionSource = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if (!m_pprConditionsContainerRun2.empty()) {
    decisionSource = getDecisionSource<L1CaloPprConditionsContainerRun2>(pprConditionsRun2);
    
  } else ATH_MSG_WARNING( "::bcidDecisionRange: No Conditions Container retrieved" );
 
  if (!(decisionSource&0x1)) etRange(ctx, digits, channelId, output);
  else                       etRange(ctx, lutInput, channelId, output);
  
  ATH_MSG_DEBUG( "::bcidDecisionRange: decisionSource: " << decisionSource);
  ATH_MSG_DEBUG( "::bcidDecisionRange: output: " << output);
 
 
}

bcidParams()

void LVL1::L1TriggerTowerToolRun3::bcidParams ( const EventContext & ctx, const L1CaloCoolChannelId & channelId, int & energyLow, int & energyHigh, int & decisionSource, std::vector< unsigned int > & decisionConditions, unsigned int & peakFinderStrategy, int & satLow, int & satHigh, int & satLevel ) const

overridevirtual

Return BCID parameters for a channel.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1038 of file L1TriggerTowerToolRun3.cxx.

{
  energyLow          = 0;
  energyHigh         = 0;
  decisionSource     = 0;
  decisionConditions.clear();
  peakFinderStrategy = 0;
  satLevel           = 0;
  satLow             = 0;
  satHigh            = 0;
  
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
 
  if(!m_pprConditionsContainerRun2.empty()) {
    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;
    
    using Cont = L1CaloPprConditionsContainerRun2;
    bcidDecision = getBcidDecision<Cont>(pprConditionsRun2);
    peakFinderStrategy = getStrategy<Cont>(pprConditionsRun2);
    decisionSource = getDecisionSource<Cont>(pprConditionsRun2);
    bcidEnergyRange = getBcidEnergyRange<Cont>(channelId.id(), pprConditionsRun2);
    saturation = getSaturation<Cont>(channelId.id(), pprConditionsRun2);
    
    
    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_DEBUG( "::bcidParams: satLevel: " << satLevel
                   << " satLow: "  << satLow << " satHigh: " << satHigh << endmsg
                   << " energyLow: " << energyLow << " energyHigh: " << energyHigh << endmsg
                   << " decisionSource: " << decisionSource << " peakFinderStrategy: "
                   << peakFinderStrategy );
 
}

channelID() [1/2]

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

overridevirtual

Return Cool channel identifier for given offline identifier.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1261 of file L1TriggerTowerToolRun3.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::L1TriggerTowerToolRun3::channelID ( double eta, double phi, int layer )

overridevirtual

Return Cool channel identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1226 of file L1TriggerTowerToolRun3.cxx.

{
  // Use direct lookup table if possible
  const double absEta = std::abs(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::L1TriggerTowerToolRun3::cpLut ( const EventContext & ctx, const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output ) const

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 682 of file L1TriggerTowerToolRun3.cxx.

{   
  int startBit = 0;
  int strategy = 0;
  int offset   = 0;
  int slope    = 0;
  int cut      = 0;
  unsigned short scale_menu = 0;
  double pedMean = 0;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
 
 
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
 
  if(!m_pprConditionsContainerRun2.empty()) {
    auto settings = pprConditionsRun2->pprConditions(channelId.id());
    if (settings) {
      startBit = settings->firStartBit();
      strategy = settings->lutCpStrategy();
      slope    = settings->lutCpSlope();
      cut      = settings->lutCpNoiseCut();
      pedMean  = settings->pedMean();
 
      hwCoeffs =  getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), pprConditionsRun2);
    
      auto l1Menu = getL1Menu(ctx);
      scale_menu = l1Menu->thrExtraInfo().EM().emScale(); // Retrieve scale param from menu
    
      for( auto &coeffs :  *hwCoeffs) { 
    hwCoeffSum += coeffs;
      }
      
      offset = this->getLutOffset(pedMean, startBit, *hwCoeffs, slope, strategy);
      
    } else ATH_MSG_WARNING( "::cpLut: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::cpLut: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::cpLut: strategy/scale/offset/slope/cut/pedMean/firCoeffSum/startBit: "
         << strategy << "/" << scale_menu << "/" << offset << "/" << slope << "/" << cut << "/" << pedMean << "/" << hwCoeffSum << "/" << startBit );
 
  unsigned int noiseCut = 0;
  bool disabled = disabledChannel(ctx, 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_menu*slope, scale_menu*offset, scale_menu*cut, 1, disabled, output);
  } else if(strategy == 1 || strategy == 0){
    lut(fir, slope, offset, cut, strategy, disabled, output);
  } else if (strategy == 4) {
    // Run-3 FCAL LUT filling scheme (strategy 4) which is identical to
    // Run-2 strategy 2, but contains an additional fixed factor of 2.
    lut(fir, scale_menu*slope, scale_menu*offset, scale_menu*cut, 4, disabled, output);
 
  }
  
  else {
        ATH_MSG_WARNING(" ::cpLut: Unknown stragegy: " << strategy);
    output.push_back(0); //avoid crashing with Unknown stragegy
  }
}

cpLutParams()

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1086 of file L1TriggerTowerToolRun3.cxx.

{
  startBit = 0;
  strategy = 0;
  offset   = 0;
  slope    = 0;
  cut      = 0;
  pedValue = 0;
  pedMean  = 0.;
  disabled = true;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
 
  
  if(!isRun2(ctx)) {
    // assert instead ?!
    ATH_MSG_WARNING("::cpLutParams: Run-1 data - behaviour undefined!");
  }
 
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if(!m_pprConditionsContainerRun2.empty()) {
    const auto settings = pprConditionsRun2->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(), pprConditionsRun2);
      
      for( auto &coeffs :  *hwCoeffs) { 
    hwCoeffSum += coeffs;
      }
 
      offset  = this->getLutOffset(pedMean, startBit, *hwCoeffs, slope, strategy);
      
      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(ctx, 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::L1TriggerTowerToolRun3::disabledChannel ( const EventContext & ctx, const L1CaloCoolChannelId & channelId ) const

overridevirtual

Check for disabled channel.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1305 of file L1TriggerTowerToolRun3.cxx.

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

disabledChannel() [2/2]

bool LVL1::L1TriggerTowerToolRun3::disabledChannel ( const EventContext & ctx, const L1CaloCoolChannelId & channelId, unsigned int & noiseCut ) const

private

Get extra noise cut with disabled channel.

Check for disabled channel with noise cut.

Definition at line 1312 of file L1TriggerTowerToolRun3.cxx.

{
 
  SG::ReadCondHandle<L1CaloPprDisabledChannelContainerRun2>  pprDisabledChannel(m_pprDisabledChannelContainer, ctx);
  bool isDisabled = false;
  noiseCut = 0;
  if(!m_pprDisabledChannelContainer.empty()) {
    
    const auto disabledChan =  pprDisabledChannel->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_DEBUG( MSG::hex
              << "::disabledChannel: calibErrorCode: " << (disabledChan->calibErrorCode()).errorCode()
              << "  deadErrorCode: " << (disabledChan->deadErrorCode()).errorCode()
              << "  noiseCut: "      << disabledChan->noiseCut()
              << "  disabledBits: "  << disabledChan->disabledBits()
              << MSG::dec );
      
    } else {
      ATH_MSG_DEBUG( "::disabledChannel: No L1CaloPprDisabledChannel found" );
    }
  } else {
    ATH_MSG_WARNING( "::disabledChannel: No DisabledChannel Container retrieved" );
  }
  if (isDisabled) ATH_MSG_DEBUG( "::disabledChannel: Channel is disabled" );
 
  return isDisabled;
}

dropBits() [1/2]

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 975 of file L1TriggerTowerToolRun3.cxx.

{
  unsigned int start = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if(!m_pprConditionsContainerRun2.empty()) {
    bool available = false;
    std::tie(available, start) = getFirStartBit<L1CaloPprConditionsContainerRun2>(channelId.id(), pprConditionsRun2);
    if(!available)ATH_MSG_WARNING( "::dropBits: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::dropBits: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::dropBits: firStartBit: " << start );
  
  dropBits(fir, start, output);
}

dropBits() [2/2]

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

overridevirtual

Truncate FIR results for LUT input.

mask to select appropriate 10 bit range

overflow detection

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 993 of file L1TriggerTowerToolRun3.cxx.

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

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

  int max = 1<<(10+start);
 
  for( auto it :  fir) { 
    if (it>=max) output.push_back(0x3ff);
    else output.push_back((it&mask)>>start);
  }
 
  ATH_MSG_DEBUG( "::dropBits: output: " << output);
}

etRange() [1/2]

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 930 of file L1TriggerTowerToolRun3.cxx.

{
  int energyLow  = 0;
  int energyHigh = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if (!m_pprConditionsContainerRun2.empty()) {
    bool available = false;
    std::tie(available, energyLow, energyHigh) = getBcidEnergyRange<L1CaloPprConditionsContainerRun2>(channelId.id(), pprConditionsRun2);
    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::L1TriggerTowerToolRun3::etRange ( const std::vector< int > & et, int energyLow, int energyHigh, std::vector< int > & output ) const

overridevirtual

Identify BCID decision range.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 950 of file L1TriggerTowerToolRun3.cxx.

{
  output.clear();
  output.reserve(et.size()); // avoid frequent reallocations
  for( auto it :  et) { 
    if (it <= energyLow)       output.push_back(0);
    else if (it <= energyHigh) output.push_back(1);
    else                          output.push_back(2);
  }
  
  ATH_MSG_DEBUG( "::etRange: output: " << output);
  
 
}

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::L1TriggerTowerToolRun3::FCalTTeta ( const L1CaloCoolChannelId & channelId )

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 1385 of file L1TriggerTowerToolRun3.cxx.

{
  if ( !m_mappingTool.isValid() ) {
    throw GaudiException("No mapping tool configured",
                         "L1TriggerTowerToolRun3::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::L1TriggerTowerToolRun3::FCalTTeta ( double nominalEta, double phi, int layer )

overridevirtual

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

Hopefully this will be a short-term work-around

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1354 of file L1TriggerTowerToolRun3.cxx.

{
  double eta = nominalEta;
  float abseta = std::abs(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::L1TriggerTowerToolRun3::finalize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 116 of file L1TriggerTowerToolRun3.cxx.

{
  return StatusCode::SUCCESS;
}

fir() [1/2]

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

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 422 of file L1TriggerTowerToolRun3.cxx.

{   
  
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);

  std::vector<int> firCoeffs;
  if(!m_pprConditionsContainerRun2.empty()) {
    const std::vector<short int>* hwCoeffs;
    hwCoeffs =   getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(),  pprConditionsRun2);
    if(hwCoeffs) {
      firCoeffs.reserve(hwCoeffs->size()); // avoid frequent reallocations
      for (auto &i : std::views::reverse(*hwCoeffs)) {
    firCoeffs.push_back(i); 
      }
    } else ATH_MSG_WARNING( "::fir: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::fir: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::fir: FIR coefficients: " << firCoeffs);
    
 
  fir(digits, firCoeffs, output);
}

fir() [2/2]

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

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 453 of file L1TriggerTowerToolRun3.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);
  }
  
  ATH_MSG_DEBUG( "::fir: output: " << output);
 
}

firParams()

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

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 1013 of file L1TriggerTowerToolRun3.cxx.

{   
  firCoeffs.clear();
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  if(!m_pprConditionsContainerRun2.empty()) {
    const std::vector<short int>* hwCoeffs = nullptr;
    hwCoeffs = getFirCoefficients<L1CaloPprConditionsContainerRun2>(channelId.id(), pprConditionsRun2 );
    
    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" );
 
 
  ATH_MSG_DEBUG( "::fir: FIR coefficients: " << firCoeffs);
  
}

getL1Menu()

const TrigConf::L1Menu * LVL1::L1TriggerTowerToolRun3::getL1Menu ( const EventContext & ctx ) const

private

Definition at line 1497 of file L1TriggerTowerToolRun3.cxx.

                                                                                     {
  const TrigConf::L1Menu* menu = nullptr;
 
  StatusCode sc =   m_configSvc.retrieve();
  if (sc.isFailure()) {
    ATH_MSG_WARNING( "Cannot retrieve trigger configuration service" );
  } 
  
  if (detStore()->contains<TrigConf::L1Menu>(m_L1MenuKey.key())) {
    SG::ReadHandle<TrigConf::L1Menu>  l1MenuHandle = SG::makeHandle( m_L1MenuKey, ctx );
    if( l1MenuHandle.isValid() ){
      menu=l1MenuHandle.cptr();
    }
  } else {
    menu = &(m_configSvc->l1Menu(ctx)); 
  }
 
  return menu;
}

getLutOffset()

unsigned int LVL1::L1TriggerTowerToolRun3::getLutOffset ( const double & pedMean, const unsigned int & firStartBit, const std::vector< short int > & firCoeff, const unsigned int & lutSlope, const unsigned int & lutStrategy ) const

private

Definition at line 1471 of file L1TriggerTowerToolRun3.cxx.

{
  unsigned int lutOffset = 0;
  // essential to save in long long to avoid rounding errors
  long long int lutOffsetLong = 0;
  long long int lutSlopeLong = lutSlope;
  long long int firStartBitLong = firStartBit;
  long long int pedMeanLong = std::lround(pedMean * 10000.);
  long long int firCoeffSum = 0;
  
  for (unsigned int i=0; i<firCoeff.size(); i++) {
    firCoeffSum += firCoeff.at(i);
  }
  
  if ( lutStrategy == 0 ) {
    lutOffsetLong = ((pedMeanLong*firCoeffSum) >> firStartBitLong);
  }
  else {
    lutOffsetLong = ((pedMeanLong*firCoeffSum*lutSlopeLong) >> firStartBitLong) - ((lutSlopeLong * 10000) >> 1);    
  }
 
  lutOffsetLong = (lutOffsetLong + (10000-1))/10000;
  lutOffset = static_cast<unsigned int>( lutOffsetLong < 0 ? 0 : lutOffsetLong );
  return lutOffset;
}

handle()

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

overridevirtual

catch begRun

Definition at line 123 of file L1TriggerTowerToolRun3.cxx.

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

hwIdentifier() [1/2]

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

overridevirtual

Return online identifier for given offline identifier.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1206 of file L1TriggerTowerToolRun3.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::L1TriggerTowerToolRun3::hwIdentifier ( double eta, double phi, int layer )

overridevirtual

Return online identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1218 of file L1TriggerTowerToolRun3.cxx.

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

identifier()

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

overridevirtual

Return offline identifier for given tower coordinates.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1190 of file L1TriggerTowerToolRun3.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::L1TriggerTowerToolRun3::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 63 of file L1TriggerTowerToolRun3.cxx.

{
 
  // Reading the Condition Containers Run 3 style  
  ATH_CHECK( m_runParametersContainer.initialize() );
  ATH_CHECK( m_pprConditionsContainerRun2.initialize() );
  ATH_CHECK( m_pprDisabledChannelContainer.initialize() );
  ATH_CHECK( m_ppmFineTimeRefsContainer.initialize() );
 
  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::IL1TriggerTowerToolRun3::interfaceID ( )

inlinestaticinherited

Definition at line 91 of file IL1TriggerTowerToolRun3.h.

{
  return IID_IL1TriggerTowerToolRun3;
}

isRun2()

bool LVL1::L1TriggerTowerToolRun3::isRun2 ( const EventContext & ctx ) const

private

Definition at line 1462 of file L1TriggerTowerToolRun3.cxx.

{
  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::L1TriggerTowerToolRun3::jepLut ( const EventContext & ctx, const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output ) const

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 744 of file L1TriggerTowerToolRun3.cxx.

{   
  int startBit = 0;
  int strategy   = 0;
  int offset     = 0;
  int slope      = 0;
  int cut        = 0;
  unsigned short scale_db   = 0;
  unsigned short scale_menu = 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(ctx)) {
    // assert instead ?!
    ATH_MSG_WARNING("::jepLut: Run-1 data - behaviour undefined!");
  }
  
 
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx );
 
  if(! m_pprConditionsContainerRun2.empty()) {
    const auto settings = pprConditionsRun2->pprConditions(channelId.id());
    if (settings) {
      startBit =  settings->firStartBit();
      strategy   = settings->lutJepStrategy();
      slope      = settings->lutJepSlope();
      cut        = settings->lutJepNoiseCut();
      pedMean    = settings->pedMean();
      scale_db   = settings->lutJepScale();
 
      auto l1Menu = getL1Menu(ctx);
      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(), pprConditionsRun2);
      
      for( auto &coeffs :  *hwCoeffs) { 
     hwCoeffSum += coeffs;
      }
 
      offset = this->getLutOffset(pedMean, startBit, *hwCoeffs, slope, strategy);
 
    } else ATH_MSG_WARNING( "::jepLut: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::jepLut: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::jepLut: strategy/scale/offset/slope/cut/pedMean/firCoeffSum/startBit: "
         << strategy << "/" << scale_menu << "/" << offset << "/" << slope << "/" << cut << "/" << pedMean << "/" << hwCoeffSum << "/" << startBit );
 
  unsigned int noiseCut = 0;
  bool disabled = disabledChannel(ctx, 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, 1, disabled, output);
    
  }else if(strategy == 1 || strategy == 0) {
    lut(fir, slope, offset, cut, strategy, disabled, output);
  } 
  else if (strategy == 4) {
    // Run-3 FCAL LUT filling scheme (strategy 4) which is identical to
    // Run-2 strategy 2, but contains an additional fixed factor of 2.
    lut(fir, scale_menu*slope, scale_menu*offset, scale_menu*cut, 4, disabled, output);
    
  }
  
  else { 
    ATH_MSG_WARNING(" ::jepLut: Unknown stragegy: " << strategy);
    output.push_back(0);//avoid crashing with Unknown stragegy
  }
 
 
}

jepLutParams()

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1138 of file L1TriggerTowerToolRun3.cxx.

{
  startBit = 0;
  strategy = 0;
  offset   = 0;
  slope    = 0;
  cut      = 0;
  pedValue = 0;
  pedMean  = 0.;
  disabled = true;
  int hwCoeffSum = 0;
  const std::vector<short int>* hwCoeffs;
  
  if(!isRun2(ctx)) {
    // assert instead ?!
    ATH_MSG_WARNING("::jepLutParams: Run-1 data - behaviour undefined!");
  }
  
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx );
  if(!m_pprConditionsContainerRun2.empty()) {
    const auto settings = pprConditionsRun2->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(),pprConditionsRun2);
    
      for( auto &coeffs :  *hwCoeffs) { 
    hwCoeffSum += coeffs;
      }
 
      offset = this->getLutOffset(pedMean, startBit, *hwCoeffs, slope, strategy);
      
      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(ctx, channelId, noiseCut);
  if (noiseCut > 0) cut = noiseCut;
}

lut()

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

overridevirtual

LUT simulation: pedestal subtraction, energy calibration and threshold.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 833 of file L1TriggerTowerToolRun3.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations
  
  const int reScale = 2;
  for( auto it :  fir) { 
    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;
      }
      // Note: for strategy 2, the code is called with strategy=1
      else if (strategy == 4 && it*slope >= offset+ cut/reScale) { // FCAL
        out = (it*slope*reScale - offset*reScale + 2048)>>12;
      } 
      if (out < 0)                 out = 0;
      if (out > s_saturationValue) out = s_saturationValue;
    }
    output.push_back(out);
  }
 
  ATH_MSG_DEBUG( "::lut: output: " << output);
 
}

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::L1TriggerTowerToolRun3::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 ) const

private

Definition at line 862 of file L1TriggerTowerToolRun3.cxx.

{
  output.clear();
  output.reserve(fir.size()); // avoid frequent reallocations
 
  
  for( auto it :  fir) { 
    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);
  }
  ATH_MSG_DEBUG( "::nonLinearLut: output: " << output);
 
}

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::L1TriggerTowerToolRun3::peakBcid ( const EventContext & ctx, const std::vector< int > & fir, const L1CaloCoolChannelId & channelId, std::vector< int > & output ) const

overridevirtual

Peak finder BCID.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 491 of file L1TriggerTowerToolRun3.cxx.

{
  unsigned int strategy = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
 
  if(!m_pprConditionsContainerRun2.empty()) {
    strategy = getStrategy<L1CaloPprConditionsContainerRun2>( pprConditionsRun2);
  } else ATH_MSG_WARNING( "::peakBcid: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::peakBcid: peak-finder strategy: " << strategy );
  
  peakBcid(fir, strategy, output);
}

peakBcid() [2/2]

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

overridevirtual

Peak finder BCID.

Cannot evaluate for first and last samples in vector

Select peak-finder strategy & test

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 507 of file L1TriggerTowerToolRun3.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);
  }
  
  ATH_MSG_DEBUG( "::peakBcid: output: " << output);
 
  
}

pedestalCorrection()

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

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1444 of file L1TriggerTowerToolRun3.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;
  }
 
  ATH_MSG_DEBUG( "::pedestalCorrection(BCID=" << bcid << ", mu = " << mu << "): " << correctionOut);
 
} 

process() [1/2]

void LVL1::L1TriggerTowerToolRun3::process ( const EventContext & ctx, const std::vector< int > & digits, const L1CaloCoolChannelId & channelId, std::vector< int > & et, std::vector< int > & bcidResults, std::vector< int > & bcidDecisions, bool useJepLut = true )

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 151 of file L1TriggerTowerToolRun3.cxx.

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

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

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

  std::vector<int> lutOutput;
  if(useJepLut) jepLut(ctx, lutInput, channelId, lutOutput);
  else cpLut(ctx, lutInput, channelId, lutOutput);
  
 
  ATH_MSG_DEBUG( "::process: ---- use ET range ----" );

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

process() [2/2]

void LVL1::L1TriggerTowerToolRun3::process ( const EventContext & ctx, 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 )

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 136 of file L1TriggerTowerToolRun3.cxx.

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

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

refValues()

std::pair< double, double > LVL1::L1TriggerTowerToolRun3::refValues ( const EventContext & ctx, const L1CaloCoolChannelId & channelId )

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1413 of file L1TriggerTowerToolRun3.cxx.

{
  //method returning the fine time reference and calibration value
  //the fineTimeReference folder has to be loaded first using the method L1TriggerTowerToolRun3::loadFTRefs
  double reference = 0;
  double calib = 0;
  SG::ReadCondHandle<L1CaloPpmFineTimeRefsContainer> ppmFineTimeRefs(m_ppmFineTimeRefsContainer, ctx);
  
  if (!m_ppmFineTimeRefsContainer.empty()) {
    const L1CaloPpmFineTimeRefs* ftref = ppmFineTimeRefs->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();
  }

satBcid() [1/2]

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

overridevirtual

Saturated pulse BCID.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 542 of file L1TriggerTowerToolRun3.cxx.

{  
  int satLevel = 0;
  int satLow   = 0;
  int satHigh  = 0;
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx);
  
  if (!m_pprConditionsContainerRun2.empty()) {
    bool available = false;
    std::tie(available, satLevel, satLow, satHigh) = getSaturation<L1CaloPprConditionsContainerRun2>(channelId.id(),  pprConditionsRun2);
    if(!available) ATH_MSG_WARNING( "::satBcid: No L1CaloPprConditions found" );
  } else ATH_MSG_WARNING( "::satBcid: No Conditions Container retrieved" );
 
  ATH_MSG_DEBUG( "::satBcid: satLevel: " << satLevel
      << " satLow: "  << satLow
      << " satHigh: " << satHigh );
 
  satBcid(digits, satLow, satHigh, satLevel, output);
}

satBcid() [2/2]

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

overridevirtual

Saturated pulse BCID.

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 564 of file L1TriggerTowerToolRun3.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]);
  }
  
  ATH_MSG_DEBUG( "::satBcid: output: " << output);
 
}

satOverride()

bool LVL1::L1TriggerTowerToolRun3::satOverride ( const EventContext & ctx, int range ) const

overridevirtual

Implements LVL1::IL1TriggerTowerToolRun3.

Definition at line 1282 of file L1TriggerTowerToolRun3.cxx.

{
 
  SG::ReadCondHandle<L1CaloPprConditionsContainerRun2>  pprConditionsRun2(m_pprConditionsContainerRun2, ctx );
  
  bool override = false;
  if(!m_pprConditionsContainerRun2.empty()) {
    std::tuple<bool, bool, bool> satOverride;
    satOverride = getSatOverride<L1CaloPprConditionsContainerRun2>(pprConditionsRun2);
    // NB Reverse order as for bcidDecision1/2/3
    if (range == 0) override = std::get<2>(satOverride);
    else if (range == 1) override = std::get<1>(satOverride);
    else 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;
}

simulateChannel()

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

overridevirtual

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::IL1TriggerTowerToolRun3.

Definition at line 216 of file L1TriggerTowerToolRun3.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
  
  SG::ReadCondHandle<L1CaloRunParametersContainer> runParameters(m_runParametersContainer, ctx);
  unsigned int readoutConfigID   = runParameters->runParameters(1)->readoutConfigID(); 
  ATH_MSG_DEBUG("RunParameters:: readoutConfigID " <<  readoutConfigID);
  
  std::vector<uint16_t> digits40;
 
  if(readoutConfigID == 5 or readoutConfigID == 6){
    
    
    ATH_MSG_DEBUG("::simulateChannel: 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{
    ATH_MSG_DEBUG("::simulateChannel: 40 MHz readout detected");
    digits40 = tt.adc();
  }
  
  const auto& digits = convertVectorType<int>(digits40);
 
  L1CaloCoolChannelId channelId {tt.coolId()}; 
 
  ATH_MSG_DEBUG( "::simulateChannel: ==== Entered Process ====" );
  ATH_MSG_DEBUG( "::simulateChannel: digits: " << digits );
  ATH_MSG_DEBUG( "::simulateChannel: channelID: " << MSG::hex << channelId.id() << MSG::dec );
  
  
  outCpLut.clear();
  outJepLut.clear();
  bcidResults.clear();
  bcidDecisions.clear();
      
  ATH_MSG_DEBUG( "::simulateChannel: ---- FIR filter ----" );
  std::vector<int> filter;
  fir(ctx, digits, channelId, filter);
  

  ATH_MSG_DEBUG( "::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];
  }
  
  ATH_MSG_DEBUG("::simulateChannel: filter: " << filter);
 
 
  std::vector<int> lutInput;
  dropBits(ctx, filter, channelId, lutInput);
 
  ATH_MSG_DEBUG( "::simulateChannel: ---- BCID algorithms ---- ");

  bcid(ctx, filter, digits, channelId, bcidResults);
 

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

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

  applyEtRange(ctx, cpLutOutput, decisionRange, channelId, outCpLut);
  applyEtRange(ctx, jepLutOutput, decisionRange, channelId, outJepLut);
  
  ATH_MSG_DEBUG( "::simulateChannel: cpLut applyETRange "  <<  outCpLut);
  ATH_MSG_DEBUG( "::simulateChannel: jepLut applyETRange "  <<  outJepLut);
 
  
  ATH_MSG_DEBUG( "::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 >, and AthCheckedComponent<::AthAlgTool >.

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::L1TriggerTowerToolRun3::m_caloMgr

private

Id managers.

Definition at line 135 of file L1TriggerTowerToolRun3.h.

m_configSvc

ServiceHandle<TrigConf::ITrigConfigSvc> LVL1::L1TriggerTowerToolRun3::m_configSvc {this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc"}

private

Definition at line 163 of file L1TriggerTowerToolRun3.h.

{this, "TrigConfigSvc", "TrigConf::xAODConfigSvc/xAODConfigSvc"};  

m_correctFir

bool LVL1::L1TriggerTowerToolRun3::m_correctFir

private

Baseline correction Tool.

Definition at line 156 of file L1TriggerTowerToolRun3.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_dynamicPedestalProvider

ToolHandle<LVL1::IL1DynamicPedestalProvider> LVL1::L1TriggerTowerToolRun3::m_dynamicPedestalProvider

private

Definition at line 157 of file L1TriggerTowerToolRun3.h.

m_eventInfoKey

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

private

Definition at line 159 of file L1TriggerTowerToolRun3.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::L1TriggerTowerToolRun3::m_idTable

private

Mapping lookup table.

Definition at line 153 of file L1TriggerTowerToolRun3.h.

m_l1CaloTTIdTools

ToolHandle<LVL1::IL1CaloTTIdTools> LVL1::L1TriggerTowerToolRun3::m_l1CaloTTIdTools

private

Definition at line 139 of file L1TriggerTowerToolRun3.h.

m_L1MenuKey

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

private

Definition at line 160 of file L1TriggerTowerToolRun3.h.

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

m_lvl1Helper

const CaloLVL1_ID* LVL1::L1TriggerTowerToolRun3::m_lvl1Helper

private

and tools for computing identifiers

Definition at line 138 of file L1TriggerTowerToolRun3.h.

m_mappingTool

ToolHandle<LVL1::IL1CaloMappingTool> LVL1::L1TriggerTowerToolRun3::m_mappingTool

private

and mappings

Definition at line 143 of file L1TriggerTowerToolRun3.h.

m_nBcid

const int LVL1::L1TriggerTowerToolRun3::m_nBcid = 350

staticprivate

Definition at line 169 of file L1TriggerTowerToolRun3.h.

m_ppmFineTimeRefsContainer

SG::ReadCondHandleKey<L1CaloPpmFineTimeRefsContainer> LVL1::L1TriggerTowerToolRun3::m_ppmFineTimeRefsContainer { this, "InputKeyTimeRefs", "L1CaloPpmFineTimeRefsContainer"}

private

Definition at line 148 of file L1TriggerTowerToolRun3.h.

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

m_pprConditionsContainerRun2

SG::ReadCondHandleKey<L1CaloPprConditionsContainerRun2> LVL1::L1TriggerTowerToolRun3::m_pprConditionsContainerRun2 { this, "InputKeyPprConditionsRun2", "L1CaloPprConditionsContainerRun2"}

private

Definition at line 146 of file L1TriggerTowerToolRun3.h.

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

m_pprDisabledChannelContainer

SG::ReadCondHandleKey<L1CaloPprDisabledChannelContainerRun2> LVL1::L1TriggerTowerToolRun3::m_pprDisabledChannelContainer { this, "InputKeyDisabledChannel", "L1CaloPprDisabledChannelContainerRun2"}

private

Definition at line 147 of file L1TriggerTowerToolRun3.h.

{ this, "InputKeyDisabledChannel", "L1CaloPprDisabledChannelContainerRun2"};

m_runParametersContainer

SG::ReadCondHandleKey<L1CaloRunParametersContainer> LVL1::L1TriggerTowerToolRun3::m_runParametersContainer { this, "InputKeyRunParameters", "L1CaloRunParametersContainer"}

private

Definition at line 149 of file L1TriggerTowerToolRun3.h.

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

m_ttSvc

ToolHandle<CaloTriggerTowerService> LVL1::L1TriggerTowerToolRun3::m_ttSvc

private

Definition at line 140 of file L1TriggerTowerToolRun3.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::L1TriggerTowerToolRun3::s_maxTowers = 7168

staticprivate

Definition at line 168 of file L1TriggerTowerToolRun3.h.

s_saturationValue

const int LVL1::L1TriggerTowerToolRun3::s_saturationValue = 255

staticprivate

Parameters.

Definition at line 167 of file L1TriggerTowerToolRun3.h.

---

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

• L1TriggerTowerToolRun3.h
• L1TriggerTowerToolRun3.cxx