#include <Run2TriggerTowerMaker.h>

Inheritance diagram for LVL1::Run2TriggerTowerMaker:

Collaboration diagram for LVL1::Run2TriggerTowerMaker:

Public Member Functions
	Run2TriggerTowerMaker (const std::string &name, ISvcLocator *pSvcLocator)

virtual	~Run2TriggerTowerMaker ()

	Run2TriggerTowerMaker (const Run2TriggerTowerMaker &)=delete

Run2TriggerTowerMaker &	operator= (const Run2TriggerTowerMaker &)=delete

StatusCode	initialize ()

StatusCode	execute ()
	Checks that the Cell Type is supported (terminates with errors if not) and calls relevant routine to look for the cells. More...

StatusCode	finalize ()

void	handle (const Incident &)
	Best if initialisation which uses COOL-derived values is done here rather than in initialize() More...

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
enum	CellTypes { CELL =1, TRIGGERTOWERS =2, TTL1 =3, SIZE =4 }

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
L1CaloCoolChannelId	channelId (double eta, double phi, int layer)
	Compute L1CaloCoolChannelId (including support for old geometries) More...

StatusCode	getTriggerTowers ()
	gets collection of input TriggerTowers for reprocessing More...

StatusCode	getCaloTowers ()
	fetch Calorimeter Towers More...

void	digitize (const EventContext &ctx)
	Convert analogue pulses to digits. More...

StatusCode	preProcess (int bcid, float mu)
	Simulate PreProcessing on analogue amplitudes. More...

StatusCode	preProcessTower (int bcid, float mu, xAOD::TriggerTower *tower)

virtual StatusCode	addOverlay (int bcid, float mu)
	Add overlay data. More...

virtual StatusCode	addOverlay (int bcid, float mu, xAOD::TriggerTower sigTT, xAOD::TriggerTower ovTT)
	Add the overlay TriggerTower to the signal TriggerTower. More...

StatusCode	preProcessTower_getLutIn (int bcid, float mu, xAOD::TriggerTower tower, const L1CaloPprChanCalib db, const std::vector< int > &digits, std::vector< int > &output)
	PreProcess up to LUT in. More...

StatusCode	calcLutOutCP (const std::vector< int > &sigLutIn, const L1CaloPprChanCalib sigDB, const std::vector< int > &ovLutIn, const L1CaloPprChanCalib ovDB, std::vector< int > &output)
	calculate LUT out More...

StatusCode	calcLutOutJEP (const std::vector< int > &sigLutIn, const L1CaloPprChanCalib sigDB, const std::vector< int > &ovLutIn, const L1CaloPprChanCalib ovDB, std::vector< int > &output)

void	calcCombinedLUT (const std::vector< int > &sigIN, const int sigSlope, const int sigOffset, const std::vector< int > &ovIN, const int ovSlope, const int ovOffset, const int ovNoiseCut, std::vector< int > &output)

bool	IsDeadChannel (const L1CaloPpmDeadChannels *db) const
	Database helper functions for dead and disabled towers. More...

bool	IsDisabledChannel (const L1CaloDisabledTowers *db) const

bool	IsGoodTower (const xAOD::TriggerTower tt, const L1CaloPpmDeadChannelsContainer dead, const L1CaloDisabledTowersContainer *disabled) const

void	normaliseDigits (const std::vector< int > &sigDigits, const std::vector< int > &ovDigits, std::vector< int > &normDigits)
	normalise the number of ADC digits for overlay More...

StatusCode	store ()
	Stores Trigger Towers in the TES, at a location defined in m_outputLocation. More...

void	processLArTowers (const LArTTL1Container *)
	extract amplitudes from TTL1 More...

void	processTileTowers (const TileTTL1Container *)

double	IDeta (const Identifier &id, const CaloLVL1_ID *caloId)
	functions to extract eta, phi coordinates from calo tower identifiers More...

double	IDphi (const Identifier &id, const CaloLVL1_ID *caloId)

std::vector< int >	ADC (CLHEP::HepRandomEngine *rndmADCs, L1CaloCoolChannelId channel, const std::vector< double > &amps) const
	Functions to simulate processing of tower signals. More...

int	EtRange (int et, unsigned short bcidEnergyRangeLow, unsigned short bcidEnergyRangeHigh) const

int	etaToElement (float feta, int layer) const

int	non_linear_lut (int lutin, unsigned short offset, unsigned short slope, unsigned short noiseCut, unsigned short scale, short par1, short par2, short par3, short par4)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_digiEngine

int	m_cellType

double	m_adcVar

double	m_adcStep

double	m_gainCorr

bool	m_decorateFIR

bool	m_ZeroSuppress

bool	m_requireAllCalos

SG::ReadCondHandleKey< L1CaloPprChanCalibContainer >	m_chanCalibKey {this,"ChanCalibFolderKey","/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib","PprChanCalib key"}

SG::ReadCondHandleKey< L1CaloPprChanDefaultsContainer >	m_chanDefaultsKey {this,"ChanDefaultsFolderKey","/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults","PprChanDefaults key"}

SG::ReadCondHandleKey< L1CaloDisabledTowersContainer >	m_disabledTowersKey {this,"DisabledTowersFolderKey","/TRIGGER/L1Calo/V2/Conditions/DisabledTowers","DisabledTowers key"}

SG::ReadCondHandleKey< L1CaloPpmDeadChannelsContainer >	m_deadChannelsKey {this,"DeadChannelsFolderKey","/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels","PpmDeadChannels key"}

std::string	m_chanCalibKeyoverlay

std::string	m_chanDefaultsKeyoverlay

std::string	m_disabledTowersKeyoverlay

std::string	m_deadChannelsKeyoverlay

ServiceHandle< IAthRNGSvc >	m_rngSvc

ATHRNG::RNGWrapper *	m_rndmADCs

ToolHandle< IL1TriggerTowerTool >	m_TTtool {this,"TTTool","LVL1::L1TriggerTowerTool/L1TriggerTowerTool", "The trigger tower tool"}

ToolHandle< IL1CaloMappingTool >	m_mappingTool

ToolHandle< LVL1BS::ITrigT1CaloDataAccessV2 >	m_bstowertool

const CaloLVL1_ID *	m_caloId

double	m_cpLutScale

double	m_jepLutScale

double	m_TileToMeV

double	m_TileTTL1Ped

bool	m_isDataReprocessing

bool	m_doOverlay

bool	m_isReco

const L1CaloPprChanCalibContainer *	m_chanCalibContainer = nullptr

const L1CaloDisabledTowersContainer *	m_disabledTowersContainer = nullptr

const L1CaloPpmDeadChannelsContainer *	m_deadChannelsContainer = nullptr

L1CaloPprChanDefaults	m_chanDefaults

L1CaloPprChanCalibContainer *	m_chanCalibContaineroverlay = nullptr

L1CaloDisabledTowersContainer *	m_disabledTowersContaineroverlay = nullptr

L1CaloPpmDeadChannelsContainer *	m_deadChannelsContaineroverlay = nullptr

L1CaloPprChanDefaults	m_chanDefaultsoverlay

std::unique_ptr< xAOD::TriggerTowerContainer >	m_xaodTowers

std::unique_ptr< xAOD::TriggerTowerAuxContainer >	m_xaodTowersAux

std::vector< std::vector< double > >	m_xaodTowersAmps

std::size_t	m_curIndex = 0u

std::array< double, m_maxIetaBins >	m_sinThetaHash
	instead of calculating the expression: double theta =2. More...

SG::ReadHandleKey< xAOD::EventInfo >	m_xaodevtKey

SG::ReadDecorHandleKey< xAOD::EventInfo >	m_actMuKey { this, "actualInteractionsPerCrossingKey", "EventInfo.actualInteractionsPerCrossing", "Decoration for actual interactions per crossing" }

SG::ReadHandleKey< xAOD::TriggerTowerContainer >	m_inputTTLocation

SG::WriteHandleKey< xAOD::TriggerTowerContainer >	m_outputLocation

SG::WriteHandleKey< xAOD::TriggerTowerContainer >	m_outputLocationRerun

SG::ReadHandleKey< LArTTL1Container >	m_EmTTL1ContainerName

SG::ReadHandleKey< LArTTL1Container >	m_HadTTL1ContainerName

SG::ReadHandleKey< TileTTL1Container >	m_TileTTL1ContainerName

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

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Static Private Attributes
constexpr static int	s_FIRLENGTH = 5

constexpr static int	s_MEV = 1000

constexpr static unsigned int	m_maxIetaBins = 51

Detailed Description

Definition at line 89 of file Run2TriggerTowerMaker.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ CellTypes

enum LVL1::Run2TriggerTowerMaker::CellTypes

private

Enumerator
CELL
TRIGGERTOWERS
TTL1
SIZE

Definition at line 118 of file Run2TriggerTowerMaker.h.

118 {CELL=1, TRIGGERTOWERS=2, TTL1=3, SIZE=4};

Constructor & Destructor Documentation

◆ Run2TriggerTowerMaker() [1/2]

LVL1::Run2TriggerTowerMaker::Run2TriggerTowerMaker	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 81 of file Run2TriggerTowerMaker.cxx.

     : AthAlgorithm(name, pSvcLocator),
       m_rngSvc("AthRNGSvc", name),
       m_rndmADCs(0),
       m_mappingTool("LVL1::PpmMappingTool/PpmMappingTool", this),
       m_bstowertool("LVL1BS__TrigT1CaloDataAccessV2/TrigT1CaloDataAccessV2", this),
       m_caloId(0),
       m_cpLutScale(1.),
       m_jepLutScale(1.),
       m_TileToMeV(s_MEV/4.1), // Scale for converting ET -> counts
       m_TileTTL1Ped(0.), // TileTTL1 pedestal value - need to subtract if set non-zero
       m_isDataReprocessing(false),
       m_doOverlay(false), m_isReco(false)
   {
     declareProperty("xAODEventInfoKey", m_xaodevtKey=std::string{"EventInfo"});
     declareProperty("RngSvc", m_rngSvc, "Random number service");
     declareProperty("DigiEngine", m_digiEngine = "TrigT1CaloSim_Digitization");
  
     declareProperty("L1TriggerTowerTool", m_TTtool);
     declareProperty("PpmMappingTool", m_mappingTool);
  
     declareProperty("inputTTLocation", m_inputTTLocation=TrigT1CaloDefs::xAODTriggerTowerLocation);
     declareProperty("EmTTL1ContainerName",m_EmTTL1ContainerName= "LArTTL1EM");
     declareProperty("HadTTL1ContainerName",m_HadTTL1ContainerName= "LArTTL1HAD");
     declareProperty("TileTTL1ContainerName",m_TileTTL1ContainerName= "TileTTL1Cnt");
     declareProperty("RequireAllCalos",m_requireAllCalos=true,"Should EM,Had and Tile all be available?");
  
     declareProperty("TriggerTowerLocation", m_outputLocation= TrigT1CaloDefs::xAODTriggerTowerLocation);
     declareProperty("TriggerTowerLocationRerun", m_outputLocationRerun = TrigT1CaloDefs::xAODTriggerTowerRerunLocation);
     declareProperty("CellType", m_cellType = TTL1);
  
     // ADC simulation
     declareProperty("ADCStep", m_adcStep=250.);
     declareProperty("ADCNoise", m_adcVar=0.65);
     declareProperty("CalibrationUncertainty", m_gainCorr=0.);
     
     declareProperty("DoOverlay",m_doOverlay = false);
     declareProperty("IsReco",m_isReco = false);
  
     declareProperty("DecorateFIR", m_decorateFIR = false, "Add FIR values to the xAOD::TriggerTowers");
  
     declareProperty("ZeroSuppress", m_ZeroSuppress = true, "Do not save towers with 0 energy");
  
     declareProperty("ChanCalibFolderKeyoverlay",m_chanCalibKeyoverlay = "/TRIGGER/L1Calo/V2overlay/Calibration/Physics/PprChanCalib","PprChanCalib key for overlay");
     declareProperty("ChanDefaultsFolderKeyoverlay",m_chanDefaultsKeyoverlay = "/TRIGGER/L1Calo/V2overlay/Configuration/PprChanDefaults","PprChanDefaults key for overlay");
     declareProperty("DisabledTowersFolderKeyoverlay",m_disabledTowersKeyoverlay = "/TRIGGER/L1Calo/V2overlay/Conditions/DisabledTowers","DisabledTowers key for overlay");
     declareProperty("DeadChannelsFolderKeyoverlay",m_deadChannelsKeyoverlay = "/TRIGGER/L1Calo/V2overlay/Calibration/PpmDeadChannels","PpmDeadChannels key for overlay");   
  
     // Create hash table for E->ET conversions
     /* Fill table with dummy values */
     m_sinThetaHash.fill(-1.);
  
     /* set values for barrel region with granularity of 0.1*/
     for(unsigned int i = 0; i < 25; i++) {
       m_sinThetaHash[i] = 1.0/cosh((i+0.5)* 0.1);
     }
  
     /* set values for EndCap with granularity of 0.2 except tt by |3.2|
       eta values are are: 2.6, 2.8, 3.0, 3.15 */
     m_sinThetaHash[26] = 1.0/cosh(2.6);
     m_sinThetaHash[28] = 1.0/cosh(2.8);
     m_sinThetaHash[30] = 1.0/cosh(3.0);
     m_sinThetaHash[31] = 1.0/cosh(3.15);
  
     /* fcal granularity is 0.425 */
     m_sinThetaHash[ (unsigned int)(32 + (0.5*0.425)*10.) ] = 1.0/cosh(3.2 + 0.5*0.425);
     m_sinThetaHash[ (unsigned int)(32 + (1.5*0.425)*10.) ] = 1.0/cosh(3.2 + 1.5*0.425);
     m_sinThetaHash[ (unsigned int)(32 + (2.5*0.425)*10.) ] = 1.0/cosh(3.2 + 2.5*0.425);
     m_sinThetaHash[ (unsigned int)(32 + (3.5*0.425)*10.) ] = 1.0/cosh(3.2 + 3.5*0.425);
   }

◆ ~Run2TriggerTowerMaker()

LVL1::Run2TriggerTowerMaker::~Run2TriggerTowerMaker ( )

virtual

Definition at line 152 of file Run2TriggerTowerMaker.cxx.

152 {}

◆ Run2TriggerTowerMaker() [2/2]

LVL1::Run2TriggerTowerMaker::Run2TriggerTowerMaker ( const Run2TriggerTowerMaker & )

delete

Member Function Documentation

◆ ADC()

std::vector< int > LVL1::Run2TriggerTowerMaker::ADC	(	CLHEP::HepRandomEngine *	rndmADCs,
		L1CaloCoolChannelId	channel,
		const std::vector< double > &	amps
	)		const

private

Functions to simulate processing of tower signals.

Definition at line 1144 of file Run2TriggerTowerMaker.cxx.

   {
     auto* chanCalib = m_chanCalibContainer->pprChanCalib(channel);
     if(!chanCalib) { ATH_MSG_WARNING("No database entry for tower " << channel.id()); return {}; }
     double ped = chanCalib->pedMean();
  
     // dice the calibration uncertainty if requested
     double adcCal = (m_gainCorr > 0.) ? CLHEP::RandGaussZiggurat::shoot(rndmADCs, 1., m_gainCorr) : 1.;  
  
     std::vector<int> digits;
     const int nSamples = amps.size();
     digits.reserve(nSamples);
     for(int i = 0; i < nSamples; ++i) {
       // dice the adc noise if requested
       double adcNoise = (m_adcVar > 0.) ? CLHEP::RandGaussZiggurat::shoot(rndmADCs,0.,m_adcVar) : 0.;
  
       int digit = int((amps[i]*adcCal/m_adcStep) + ped + adcNoise);
       if(digit > ADCMAX) digit = ADCMAX;
       if(digit < 0) digit = 0;
       digits.push_back(digit);
     }
     return digits;
   }

◆ addOverlay() [1/2]

StatusCode LVL1::Run2TriggerTowerMaker::addOverlay	(	int	bcid,
		float	mu
	)

privatevirtual

Add overlay data.

Definition at line 392 of file Run2TriggerTowerMaker.cxx.

   {
     // Get the overlay data TTs from Bytestream
     xAOD::TriggerTowerContainer* overlayDataTTs = new xAOD::TriggerTowerContainer();
     xAOD::TriggerTowerAuxContainer overlayDataTTsAux;
     overlayDataTTs->setStore( &overlayDataTTsAux );
     ATH_CHECK( m_bstowertool->loadTriggerTowers(*overlayDataTTs) ); // use L1Calo tool to fill xAOD::TriggerTowerContainer from BS
  
     // put the overlay data TTs into a map 
     std::unordered_map<uint32_t,xAOD::TriggerTower*> overlayMap;
     typedef std::unordered_map<uint32_t,xAOD::TriggerTower*>::iterator Itr;
     
     // decorate the overlay TTs to indicate if they have been used or not 
     char decor_ttNotUsedInOverlay = 0;
     char decor_ttUsedInOverlay = 1;
     static const SG::Decorator<char> decor ("addedToSignal");
     for (auto tt:*overlayDataTTs) {
       // Let's exclude all dead and disabled towers
       if (IsGoodTower(tt,m_deadChannelsContaineroverlay,m_disabledTowersContaineroverlay)) {
         decor(*tt) = decor_ttNotUsedInOverlay;
         overlayMap.insert( std::make_pair( tt->coolId() , tt ) );
       }
     }
     
     // What is the size of the primary LUT readout?
     bool findSizeOfPrimaryLUT(true);
     unsigned int sizeOfPrimaryLUT(0);
     uint8_t peakOfPrimary(0);
       
     // Loop over primary TTs, match overlay TTs, and add LUT values
     for (auto tt:*m_xaodTowers) {
       
       // find size of primary LUT readout for first TT
       if (findSizeOfPrimaryLUT) {
         findSizeOfPrimaryLUT = false;
         sizeOfPrimaryLUT = tt->lut_cp().size();
         peakOfPrimary = tt->peak();
       }
           
       // Do we have a matching overlay tower?
       Itr match = overlayMap.find( tt->coolId() );
       if (match != overlayMap.end()) {
         
         ATH_CHECK( addOverlay(bcid,mu,tt,(*match).second) );
         
         // Let the overlay TT know that it has been used
         decor(*match->second) = decor_ttUsedInOverlay;
         
       } // end of match
     } // end of loop over primary TTs 
     
     // Now we need to add all overlay TTs that have not been used so far
     for (Itr i=overlayMap.begin();i!=overlayMap.end();++i) {
       xAOD::TriggerTower* tt = (*i).second;
       if (decor(*tt) == decor_ttNotUsedInOverlay) {
         // Ensure that LUT vectors are the same size as the primary TTs 
         std::vector<uint8_t> overlay_lut_cp(sizeOfPrimaryLUT,0.);
         std::vector<uint8_t> overlay_lut_jep(sizeOfPrimaryLUT,0.);
         
         // Fill the LUT vectors
         overlay_lut_cp.at(peakOfPrimary) = tt->cpET();
         overlay_lut_jep.at(peakOfPrimary) = tt->jepET();
         
         // Set the LUT vectors and peak 
         tt->setPeak( peakOfPrimary );
         tt->setLut_cp( overlay_lut_cp );
         tt->setLut_jep( overlay_lut_jep );
         
         // add the overlay TT to the primary TT 
         m_xaodTowers->push_back( tt );
       }
     }
     
     // Should be done!!!   
     return StatusCode::SUCCESS;  
   }

◆ addOverlay() [2/2]

StatusCode LVL1::Run2TriggerTowerMaker::addOverlay	(	int	bcid,
		float	mu,
		xAOD::TriggerTower *	sigTT,
		xAOD::TriggerTower *	ovTT
	)

privatevirtual

Add the overlay TriggerTower to the signal TriggerTower.

Definition at line 470 of file Run2TriggerTowerMaker.cxx.

   {
     // Get the relevant databases 
     const L1CaloPprChanCalib* sigDB = m_chanCalibContainer->pprChanCalib(sigTT->coolId());
     const L1CaloPprChanCalib* ovDB  = m_chanCalibContaineroverlay->pprChanCalib(ovTT->coolId());
     
     if (!sigDB) {
       ATH_MSG_ERROR("Cannot find signal DB for tower 0x"<<std::hex<<sigTT->coolId()<<std::dec<<"  Aborting...");
       return StatusCode::FAILURE;
     }
     
     if (!ovDB) {
       ATH_MSG_ERROR("Cannot find overlay DB for tower 0x"<<std::hex<<ovTT->coolId()<<std::dec<<"  Aborting...");
       return StatusCode::FAILURE;
     }  
        
     // Let's begin with the same number of ADC samples
     // retrieve signal and overlay digits
     std::vector<int> sigDigits( std::begin(sigTT->adc()) , std::end(sigTT->adc()) );
     std::vector<int> ovDigits( std::begin(ovTT->adc()) , std::end(ovTT->adc()) );
     std::vector<int> normOverlayDigits; 
     normaliseDigits(sigDigits,ovDigits,normOverlayDigits);
     
     // Get LUT input
     std::vector<int> sigLutIn,ovLutIn;
     ATH_CHECK( preProcessTower_getLutIn(bcid,mu,sigTT,sigDB,sigDigits,sigLutIn) );
     ATH_CHECK( preProcessTower_getLutIn(bcid,mu,ovTT,ovDB,normOverlayDigits,ovLutIn) );
        
     // LUT ouput
     std::vector<int> lutOut_cp,lutOut_jep;
     ATH_CHECK( calcLutOutCP(sigLutIn,sigDB,ovLutIn,ovDB,lutOut_cp) );
     ATH_CHECK( calcLutOutJEP(sigLutIn,sigDB,ovLutIn,ovDB,lutOut_jep) );
     
     // Not doing BCID yet.. can be added at a later date
     
     std::size_t peak = lutOut_jep.size()/2; // both cp & jep have the same length
     std::vector<uint_least8_t> etResultVectorCp { uint8_t(lutOut_cp[peak]) };
     std::vector<uint_least8_t> etResultVectorJep { uint8_t(lutOut_jep[peak]) }; 
     
     sigTT->setLut_cp(std::move(etResultVectorCp));
     sigTT->setLut_jep(std::move(etResultVectorJep));    
     
     return StatusCode::SUCCESS;
   }

◆ calcCombinedLUT()

void LVL1::Run2TriggerTowerMaker::calcCombinedLUT	(	const std::vector< int > &	sigIN,
		const int	sigSlope,
		const int	sigOffset,
		const std::vector< int > &	ovIN,
		const int	ovSlope,
		const int	ovOffset,
		const int	ovNoiseCut,
		std::vector< int > &	output
	)

private

Definition at line 557 of file Run2TriggerTowerMaker.cxx.

   {
     // Modified version of TrigT1CaloTools/src/L1TriggerTowerTool
     
     // (1) Calculate the Et conversion for the signal and the overlay
     // (2) Combine the Et's 
     // (3) apply noise cut on combined Et sum 
     // (4) apply bitshift
     
     output.clear();
     output.reserve(sigIN.size()); // avoid frequent reallocations
  
     for (unsigned int i=0;i<sigIN.size();++i) {
       int out(0);
       int signal = sigIN[i];
       int overlay = ovIN[i];
       
       int outSig = signal*sigSlope - sigOffset; // Et conversion for signal
       int outOv  = overlay*ovSlope - ovOffset;  // Et conversion for overlay
       int outTmp = outSig + outOv;  // Combined Et
       
       // Noise cut from overlay
       if (outTmp >= ovNoiseCut) {
         out = (outSig + outOv + 2048)>>12; // pedestal and bitshift
       }
  
       // keep things in range
       if (out < 0) out = 0;
       if (out > 255) out = 255;
       
       output.push_back( out );
     }     
   }

◆ calcLutOutCP()

StatusCode LVL1::Run2TriggerTowerMaker::calcLutOutCP	(	const std::vector< int > &	sigLutIn,
		const L1CaloPprChanCalib *	sigDB,
		const std::vector< int > &	ovLutIn,
		const L1CaloPprChanCalib *	ovDB,
		std::vector< int > &	output
	)

private

calculate LUT out

Definition at line 515 of file Run2TriggerTowerMaker.cxx.

   {
     if (sigDB->lutCpStrategy() > 2 || ovDB->lutCpStrategy() > 2) {
       ATH_MSG_ERROR("Cannot process calcLutOutCP as lutCpStrategy > 2");
       return StatusCode::FAILURE;
     }
     
     double sigScale = (sigDB->lutCpStrategy() == 0) ? 1. : m_cpLutScale;    
     double sigSlope = sigScale * sigDB->lutCpSlope();
     double sigOffset = sigScale * sigDB->lutCpOffset();
     
     double ovScale  = (ovDB->lutCpStrategy() == 0)  ? 1. : m_cpLutScale;
     double ovSlope = ovScale * ovDB->lutCpSlope();
     double ovOffset = ovScale * ovDB->lutCpOffset();
     double ovNoiseCut = ovScale * ovDB->lutCpNoiseCut();
     
     calcCombinedLUT(sigLutIn,sigSlope,sigOffset,ovLutIn,ovSlope,ovOffset,ovNoiseCut,output);
     
     return StatusCode::SUCCESS;
   }

◆ calcLutOutJEP()

StatusCode LVL1::Run2TriggerTowerMaker::calcLutOutJEP	(	const std::vector< int > &	sigLutIn,
		const L1CaloPprChanCalib *	sigDB,
		const std::vector< int > &	ovLutIn,
		const L1CaloPprChanCalib *	ovDB,
		std::vector< int > &	output
	)

private

Definition at line 536 of file Run2TriggerTowerMaker.cxx.

   {
     if (sigDB->lutJepStrategy() > 2 || ovDB->lutJepStrategy() > 2) {
       ATH_MSG_ERROR("Cannot process calcLutOutJEP as lutJepStrategy > 2");
       return StatusCode::FAILURE;
     }
     
     double sigScale = (sigDB->lutJepStrategy() == 0) ? 1. : m_jepLutScale;    
     double sigSlope = sigScale * sigDB->lutJepSlope();
     double sigOffset = sigScale * sigDB->lutJepOffset();
     
     double ovScale  = (ovDB->lutCpStrategy() == 0)  ? 1. : m_jepLutScale;
     double ovSlope = ovScale * ovDB->lutJepSlope();
     double ovOffset = ovScale * ovDB->lutJepOffset();
     double ovNoiseCut = ovScale * ovDB->lutJepNoiseCut();
     
     calcCombinedLUT(sigLutIn,sigSlope,sigOffset,ovLutIn,ovSlope,ovOffset,ovNoiseCut,output);
     
     return StatusCode::SUCCESS;
   }  

◆ channelId()

L1CaloCoolChannelId LVL1::Run2TriggerTowerMaker::channelId	(	double	eta,
		double	phi,
		int	layer
	)

private

Compute L1CaloCoolChannelId (including support for old geometries)

Function to compute L1CaloCoolChannelId from eta/phi/layer.

Unlike L1TriggerTowerTool::channelID this function can cope with old geometries (hence the hard-coded numbers). So don't remove this until all ATLAS-CSC datasets are irrevokably deprecated

Definition at line 1212 of file Run2TriggerTowerMaker.cxx.

   {
     int crate, module, channel;
     m_mappingTool->mapping(eta, phi, layer, crate, module, channel);
     int slot = module + 5;
     int pin = channel % 16;
     int asic = channel / 16;
     return L1CaloCoolChannelId(crate, L1CaloModuleType::Ppm, slot, pin, asic, false);
   }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & 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< Algorithm > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ digitize()

void LVL1::Run2TriggerTowerMaker::digitize ( const EventContext & ctx )

private

Convert analogue pulses to digits.

Digitize pulses and store results back in xAOD::TriggerTowers.

Definition at line 1130 of file Run2TriggerTowerMaker.cxx.

   {
     CLHEP::HepRandomEngine* rndmADCs = m_rndmADCs->getEngine (ctx);
  
     // Loop over all existing towers and digitize pulses
     for(auto tower : *m_xaodTowers) {
       // First process EM layer
       L1CaloCoolChannelId id(tower->coolId());
       std::vector<int> digits = ADC(rndmADCs, id, m_xaodTowersAmps[tower->index()]); // ADC simulation
       tower->setAdc(std::vector<uint16_t>(std::begin(digits), std::end(digits)));
       tower->setAdcPeak(digits.size()/2);
     }
   }

◆ etaToElement()

int LVL1::Run2TriggerTowerMaker::etaToElement	(	float	feta,
		int	layer
	)		const

private

Get integer eta bin

Definition at line 1222 of file Run2TriggerTowerMaker.cxx.

   {
     constexpr static int NELEMENTS = 33;
     float shiftedEta = feta + 4.9;
     uint eta = (uint)floor(shiftedEta*10.0);
     if(fabs(shiftedEta*10.0 - (uint)(eta+1)) < 0.01) eta++;
     if(fabs(shiftedEta) < 0.01) eta = 0;
  
     constexpr int nBins = 16;
     constexpr uint map[nBins] = {2,6,10,14,17,19,21,23,75,77,79,80,83,87,91,95};
     int element = -1;
     if(eta > 23 && eta < 74) {
       element = eta - 16;
     } else {
       for(int i = 0; i < nBins; i++) {
         if(eta == map[i]) {
           if(i < 8) element = i;
           else element = i + 50;
           break;
         }
       }
     }
     if      (layer == 1 && (element == 0 || element == 64)) element = 1; // FCal2-2
     else if (layer == 1 && (element == 1 || element == 65)) element = 0; // FCal3-2
     else if (layer == 1 && (element == 2 || element == 62)) element = 3; // FCal2-1
     else if (layer == 1 && (element == 3 || element == 63)) element = 2; // FCal3-1
     else if (element > 32) element = 65-element;
  
     // element 29 = FCal2-1, element 30 = FCal3-1, element 31 = FCal2-2, element 32 = FCal3-2
     element = NELEMENTS-element-1;
  
     return element;
   }

◆ EtRange()

int LVL1::Run2TriggerTowerMaker::EtRange	(	int	et,
		unsigned short	bcidEnergyRangeLow,
		unsigned short	bcidEnergyRangeHigh
	)		const

private

Definition at line 1169 of file Run2TriggerTowerMaker.cxx.

   {
     if(et < bcidEnergyRangeLow)  return 0;
     if(et < bcidEnergyRangeHigh) return 1;
     return 2;
   }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LVL1::Run2TriggerTowerMaker::execute ( )

Checks that the Cell Type is supported (terminates with errors if not) and calls relevant routine to look for the cells.

Definition at line 303 of file Run2TriggerTowerMaker.cxx.

                                             {
     ATH_MSG_VERBOSE("Executing");
  
     if (m_isReco && m_doOverlay) return StatusCode::SUCCESS; // nothing to to, since we did overlay and made towers during digi
  
  
     // retrieve conditions
     SG::ReadCondHandle<L1CaloPprChanCalibContainer> pprCalibCont(m_chanCalibKey);
     CHECK(pprCalibCont.isValid());
     m_chanCalibContainer = (*pprCalibCont);
     SG::ReadCondHandle<L1CaloDisabledTowersContainer> pprDisabledTowers(m_disabledTowersKey);
     CHECK(pprDisabledTowers.isValid());
     m_disabledTowersContainer = (*pprDisabledTowers);
     SG::ReadCondHandle<L1CaloPpmDeadChannelsContainer> pprDeadTowers(m_deadChannelsKey);
     CHECK(pprDeadTowers.isValid());
     m_deadChannelsContainer = (*pprDeadTowers);
     SG::ReadCondHandle<L1CaloPprChanDefaultsContainer> pprChanDefaults(m_chanDefaultsKey);
     CHECK(pprChanDefaults.isValid());
     auto* defaults = pprChanDefaults->pprChanDefaults(0); // non-owning ptr
     if(!defaults) {
         ATH_MSG_ERROR("Could not retrieve channel 0 PprChanDefaults folder. Aborting ...");
         throw std::runtime_error("Run2TriggerTowerMaker: channel 0 of PprChanDefaults not accesible");
     }
     m_chanDefaults = *defaults;
  
     const EventContext& ctx = Gaudi::Hive::currentContext();
     m_rndmADCs->setSeed (m_digiEngine, ctx);
  
     m_xaodTowers.reset(new xAOD::TriggerTowerContainer);
     m_xaodTowersAux.reset(new xAOD::TriggerTowerAuxContainer);
     m_xaodTowers->setStore(m_xaodTowersAux.get());
     m_xaodTowers->resize(7168); // avoid frequent reallocations
     m_curIndex = 0u;
  
     switch(m_cellType) {
     case TRIGGERTOWERS:
       ATH_MSG_VERBOSE("Looking for TriggerTower input");
       ATH_CHECK(getTriggerTowers());
       break;
     case TTL1:
       ATH_MSG_VERBOSE("Looking for calo towers");
       ATH_CHECK(getCaloTowers());
       digitize(ctx); // digitisation
       break;
     default:
       ATH_MSG_ERROR("Unsupported Cell Type!!!!!!"); return StatusCode::FAILURE;
     }
     
     SG::ReadHandle<xAOD::EventInfo> evt(m_xaodevtKey, ctx);
     SG::ReadDecorHandle<xAOD::EventInfo,float> muDecor(m_actMuKey, ctx);
     ATH_CHECK(evt.isValid());
     ATH_CHECK(muDecor.isPresent());
     const float mu = muDecor(0);
  
     ATH_CHECK(preProcess(evt->bcid(), mu)); // FIR, BCID etc
  
     if (m_doOverlay) {         
       ATH_CHECK( addOverlay(evt->bcid(), mu) );
     }
  
     // store them thar trigger towers
     ATH_CHECK(store());
  
     return StatusCode::SUCCESS;
   }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

 {
   // If we didn't find any symlinks to add, just return the collection
   // from the base class.  Otherwise, return the extended collection.
   if (!m_extendedExtraObjects.empty()) {
     return m_extendedExtraObjects;
   }
   return Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode LVL1::Run2TriggerTowerMaker::finalize ( )

Definition at line 295 of file Run2TriggerTowerMaker.cxx.

                                              {
     ATH_MSG_DEBUG("Finalizing");
     return StatusCode::SUCCESS;
   }

◆ getCaloTowers()

StatusCode LVL1::Run2TriggerTowerMaker::getCaloTowers ( )

private

fetch Calorimeter Towers

fetches LAr & Tile calorimeter towers

If < 7168 towers in input data will be unallocated pointers in vector.

Definition at line 961 of file Run2TriggerTowerMaker.cxx.

   {
     // Find LAr towers in TES
     StatusCode sc1 = StatusCode::SUCCESS;
     SG::ReadHandle<LArTTL1Container> EMTowers(m_EmTTL1ContainerName);
     if(!EMTowers.isValid()){
       ATH_MSG_WARNING("EM LArTTL1Container not found");
       sc1 = StatusCode::FAILURE;
     }
  
     StatusCode sc2 = StatusCode::SUCCESS;
     SG::ReadHandle<LArTTL1Container> HECTowers(m_HadTTL1ContainerName);
     if(!HECTowers.isValid()){
       ATH_MSG_WARNING("Had LArTTL1Container not found");
       sc2 = StatusCode::FAILURE;
     }
  
     // Find Tile towers in TES
     StatusCode sc3 = StatusCode::SUCCESS;
     SG::ReadHandle<TileTTL1Container> TileTowers(m_TileTTL1ContainerName);
     if(!TileTowers.isValid()){
       ATH_MSG_WARNING("Tile LArTTL1Container not found");
       sc3 = StatusCode::FAILURE;
     }
  
     if(m_requireAllCalos && ((sc1==StatusCode::FAILURE) ||
                             (sc2==StatusCode::FAILURE) ||
                             (sc3==StatusCode::FAILURE))) {
       ATH_MSG_ERROR("Can't find calo towers - stopping processing" << endmsg
                     << "Found Em  LArTTL1 : "<<sc1 << endmsg
                     << "Found Had LArTTL1 : "<<sc2 << endmsg
                     << "Found TileTTL1    : "<<sc3<< endmsg
                     );
       return StatusCode::FAILURE;
     }
  
     // lets now try to create some trigger towers
     if(sc1 == StatusCode::SUCCESS) {
       processLArTowers(EMTowers.cptr());
     }
     if(sc2 == StatusCode::SUCCESS) {
       processLArTowers(HECTowers.cptr());
     }
     if(sc3 == StatusCode::SUCCESS) {
       processTileTowers(TileTowers.cptr());
     }
  
     //  /// So clean-up m_xaodTowers before these cause problems later.
     m_xaodTowers->erase(std::remove_if(m_xaodTowers->begin(), m_xaodTowers->end(),
                         [](const xAOD::TriggerTower* tt){return (tt == 0);}),
                         m_xaodTowers->end());
     
     // Remove dead and disabled towers
     m_xaodTowers->erase(std::remove_if(m_xaodTowers->begin(), m_xaodTowers->end(),
                                        [this](const xAOD::TriggerTower* tt){return !IsGoodTower(tt,m_deadChannelsContainer,m_disabledTowersContainer);}),
                                        m_xaodTowers->end()); 
  
     return StatusCode::SUCCESS;
   }

◆ getTriggerTowers()

StatusCode LVL1::Run2TriggerTowerMaker::getTriggerTowers ( )

private

gets collection of input TriggerTowers for reprocessing

gets TriggerTowers from input collection and copies ADC digits into xAOD::TriggerTowers for reprocessing

If < 7168 towers in input data will be unallocated pointers in vector.

Definition at line 934 of file Run2TriggerTowerMaker.cxx.

   {
     ATH_MSG_INFO("Retrieve input TriggerTowers " << m_inputTTLocation.key());
     SG::ReadHandle<xAOD::TriggerTowerContainer> inputTTs(m_inputTTLocation);
     ATH_CHECK(inputTTs.isValid());
     ATH_MSG_INFO("Found " << inputTTs->size() << " input TriggerTowers");
  
     for(const xAOD::TriggerTower* tower : *inputTTs) {
       xAOD::TriggerTower* t = (*m_xaodTowers)[m_curIndex++] = new xAOD::TriggerTower;
       *t = *tower;
     }
  
     //  /// So clean-up m_xaodTowers before these cause problems later.
     m_xaodTowers->erase(std::remove_if(m_xaodTowers->begin(), m_xaodTowers->end(),
                         [](const xAOD::TriggerTower* tt){return (tt == 0);}),
                         m_xaodTowers->end());
     
     // Remove dead and disabled towers
     m_xaodTowers->erase(std::remove_if(m_xaodTowers->begin(), m_xaodTowers->end(),
                                        [this](const xAOD::TriggerTower* tt){return !IsGoodTower(tt,m_deadChannelsContainer,m_disabledTowersContainer);}),
                                        m_xaodTowers->end());     
  
     return StatusCode::SUCCESS;
   } // end of getTriggerTowers()

◆ handle()

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

Best if initialisation which uses COOL-derived values is done here rather than in initialize()

Get global scales from configSvc

globalScale is number of GeV/count. As code is already written to use MeV/count, safest thing here is to convert:

Definition at line 214 of file Run2TriggerTowerMaker.cxx.

   {
     if(inc.type() != "BeginRun") return;
  
     auto l1Menu = SG::makeHandle( m_L1MenuKey );
     m_cpLutScale = l1Menu->thrExtraInfo().EM().emScale();
     m_jepLutScale = l1Menu->thrExtraInfo().JET().jetScale();
  
     ATH_MSG_INFO("REGTEST CP scale = " << m_cpLutScale << " count/GeV");
     ATH_MSG_INFO("REGTEST JEP scale = " << m_jepLutScale << " count/GeV");
  
  
  
     
     
     if (m_doOverlay) {
  
         throw std::runtime_error("Overlay no longer supported in Run2TriggerTowerMaker");
  
         // Leaving this code commented here as a reminder of what functionality might need to be added to L1CaloCondAlg
         // if we want to restart supporting overlay
  
 //      if (! m_condSvc->retrieve(m_chanCalibContaineroverlay, m_chanCalibKeyoverlay).isSuccess()){ATH_MSG_ERROR("failed!");}
 //      ATH_MSG_INFO("Loading "<<m_chanCalibKeyoverlay<<" into m_chanCalibContaineroverlay");
 //      if (! m_condSvc->retrieve(m_disabledTowersContaineroverlay, m_disabledTowersKeyoverlay).isSuccess()){ATH_MSG_ERROR("failed!");}
 //      if (! m_condSvc->retrieve(m_deadChannelsContaineroverlay, m_deadChannelsKeyoverlay).isSuccess()){ATH_MSG_ERROR("failed!");}
 //      L1CaloPprChanDefaultsContainer *cDCoverlay = nullptr;
 //      if (! m_condSvc->retrieve(cDCoverlay, m_chanDefaultsKeyoverlay).isSuccess()){ATH_MSG_ERROR("failed!");}
 //      if(!m_chanCalibContaineroverlay || !cDCoverlay ||
 //        !m_disabledTowersContaineroverlay || !m_deadChannelsContaineroverlay) {
 //        ATH_MSG_ERROR("Could not retrieve database containers for overlay. Aborting ...");
 //        throw std::runtime_error("Run2TriggerTowerMaker: database container for overlay not accesible");
 //      }
 //
 //      auto* defaultsoverlay = cDCoverlay->pprChanDefaults(0); // non-owning ptr
 //      if(!defaultsoverlay) {
 //        ATH_MSG_ERROR("Could not retrieve channel 0 PprChanDefaults folder for overlay. Aborting ...");
 //        throw std::runtime_error("Run2TriggerTowerMaker: channel 0 of PprChanDefaults for overlay not accesible");
 //      }
 //      m_chanDefaultsoverlay = *defaultsoverlay;
     
     }
  
     const TileInfo* tileInfo = nullptr;
     if(detStore()->retrieve(tileInfo, "TileInfo").isFailure()) {
       ATH_MSG_ERROR("Failed to find TileInfo");
       m_TileToMeV = s_MEV/4.1;
     }
  
     m_TileToMeV = s_MEV/tileInfo->TTL1Calib({});
     ATH_MSG_DEBUG("Tile TTL1 calibration scale = " << tileInfo->TTL1Calib({}));
     m_TileTTL1Ped = tileInfo->TTL1Ped({});
     ATH_MSG_DEBUG("Tile TTL1 pedestal value = " << m_TileTTL1Ped);
  
     // try to determine wheter we run on data or on simulation
     const xAOD::EventInfo* evtinfo{nullptr};
     if(evtStore()->retrieve(evtinfo)!=StatusCode::SUCCESS) {
       ATH_MSG_WARNING("Could not determine if input file is data or simulation. Will assume simulation.");
     }
     else {
       bool isData = !(evtinfo->eventTypeBitmask()&xAOD::EventInfo::IS_SIMULATION);
       m_isDataReprocessing = isData;
       if(m_isDataReprocessing) {
     ATH_MSG_INFO("Detected data reprocessing. Will take pedestal correction values from input trigger towers.");
       } else {
     ATH_MSG_VERBOSE("No data reprocessing - running normal simulation.");
       }
     }
     
     // If this is an overlay job, we will handle this in a different way
     if (m_doOverlay) {
       m_isDataReprocessing = false;
       ATH_MSG_INFO("L1Calo overlay job - setting m_isDataReprocessing to false");
     }
     
     
   }

◆ IDeta()

double LVL1::Run2TriggerTowerMaker::IDeta	(	const Identifier &	id,
		const CaloLVL1_ID *	caloId
	)

private

functions to extract eta, phi coordinates from calo tower identifiers

Definition at line 1176 of file Run2TriggerTowerMaker.cxx.

   {
     int region = l1id->region(id);
     int ieta = l1id->eta(id);
     int sign = l1id->pos_neg_z(id);
  
     double gran[4] = {0.1, 0.2, 0.1, 0.425};
     double offset[4] = {0., 2.5, 3.1, 3.2};
     double eta;
  
     if(region>=0 && region<=3) {
       eta = sign* (((ieta+0.5) * gran[region]) + offset[region]);
     }
     else {
       eta = 0.;
     }
  
     return eta;
   }

◆ IDphi()

double LVL1::Run2TriggerTowerMaker::IDphi	(	const Identifier &	id,
		const CaloLVL1_ID *	caloId
	)

private

Definition at line 1197 of file Run2TriggerTowerMaker.cxx.

   {
     Identifier regId = l1id->region_id(id);
  
     double phiMax = l1id->phi_max(regId);
     int iphi = l1id->phi(id);
     double phi = (iphi+0.5)*2*M_PI/(phiMax+1);
  
     return phi;
   }

◆ initialize()

StatusCode LVL1::Run2TriggerTowerMaker::initialize ( )

Definition at line 154 of file Run2TriggerTowerMaker.cxx.

   {
     ATH_MSG_DEBUG("Initialising");
  
     ATH_CHECK(detStore()->retrieve(m_caloId));
     ATH_CHECK(m_mappingTool.retrieve());
     ATH_CHECK(m_TTtool.retrieve());
     ATH_CHECK(m_rngSvc.retrieve());
     ATH_CHECK(m_bstowertool.retrieve());
  
     m_rndmADCs = m_rngSvc->getEngine(this, m_digiEngine);
     if(!m_rndmADCs) {
       ATH_MSG_ERROR("Failed to retrieve random engine");
       return StatusCode::FAILURE;
     }
  
     // Listen for BeginRun
     ServiceHandle<IIncidentSvc> incSvc("IncidentSvc",name());
     ATH_CHECK(incSvc.retrieve());
     incSvc->addListener(this, "BeginRun");
  
     // reserve enough storage for the amps
     m_xaodTowersAmps.assign(7168, std::vector<double>());
  
     ATH_CHECK(m_xaodevtKey.initialize());
     ATH_CHECK(m_actMuKey.initialize());
  
     ATH_CHECK(m_inputTTLocation.initialize());
  
     ATH_CHECK(m_EmTTL1ContainerName.initialize());
     ATH_CHECK(m_HadTTL1ContainerName.initialize());
     ATH_CHECK(m_TileTTL1ContainerName.initialize());
     ATH_CHECK(m_outputLocation.initialize());
  
     ATH_CHECK(m_outputLocationRerun.initialize());
     
     //Rerun on trigger towers
     if (m_cellType == TRIGGERTOWERS) {
       renounce(m_EmTTL1ContainerName);
       renounce(m_HadTTL1ContainerName);
       renounce(m_TileTTL1ContainerName);
       renounce(m_outputLocation);
     }
     //Start from RDO inputs
     else if (m_cellType == TTL1) {
       renounce(m_inputTTLocation);
       renounce(m_outputLocationRerun);
     }
  
     ATH_CHECK( m_L1MenuKey.initialize() );
     ATH_CHECK( m_chanCalibKey.initialize() );
     ATH_CHECK( m_chanDefaultsKey.initialize() );
     ATH_CHECK( m_disabledTowersKey.initialize() );
     ATH_CHECK( m_deadChannelsKey.initialize() );
  
     return StatusCode::SUCCESS;
   }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

◆ IsDeadChannel()

bool LVL1::Run2TriggerTowerMaker::IsDeadChannel ( const L1CaloPpmDeadChannels * db ) const

private

Database helper functions for dead and disabled towers.

Definition at line 370 of file Run2TriggerTowerMaker.cxx.

   {
     if (!db) return false; // No DB entry - assume that this is not a dead channel
     if (db->errorCode() > 0 || db->noiseCut() > 0) return true; // We do not want these 
     return false;
   }

◆ IsDisabledChannel()

bool LVL1::Run2TriggerTowerMaker::IsDisabledChannel ( const L1CaloDisabledTowers * db ) const

private

Definition at line 377 of file Run2TriggerTowerMaker.cxx.

   {
     if (!db) return false; // No DB entry - assume that this is not a disabled channel
     if (db->disabledBits() > 0) return true; // We do not want these
     return false;
   }

◆ IsGoodTower()

bool LVL1::Run2TriggerTowerMaker::IsGoodTower	(	const xAOD::TriggerTower *	tt,
		const L1CaloPpmDeadChannelsContainer *	dead,
		const L1CaloDisabledTowersContainer *	disabled
	)		const

private

Definition at line 384 of file Run2TriggerTowerMaker.cxx.

   {
     bool isDead = IsDeadChannel(dead->ppmDeadChannels(tt->coolId()));
     bool isDisabled = IsDisabledChannel(disabled->disabledTowers(tt->coolId()));
     if (!isDead && !isDisabled) return true;
     return false;
   }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ non_linear_lut()

int LVL1::Run2TriggerTowerMaker::non_linear_lut	(	int	lutin,
		unsigned short	offset,
		unsigned short	slope,
		unsigned short	noiseCut,
		unsigned short	scale,
		short	par1,
		short	par2,
		short	par3,
		short	par4
	)

private

Definition at line 1261 of file Run2TriggerTowerMaker.cxx.

                                                                                                                                                                                                  {
     // turn shorts into double (database fields are shorts ... )
  
     // 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 (lutin * slope < offset + nll_noise * noiseCut) {
       return 0;
     }
  
     // actual calculation
     int output = int((((int)(2048 + nll_slope * (lutin * slope - offset)))>>12) + nll_offset + nll_ampl * std::exp(nll_expo * (lutin * slope - offset)));
     if(output >= 255) return 255;
     if(output < 0) return 0;
     return output;
   }

◆ normaliseDigits()

void LVL1::Run2TriggerTowerMaker::normaliseDigits	(	const std::vector< int > &	sigDigits,
		const std::vector< int > &	ovDigits,
		std::vector< int > &	normDigits
	)

private

normalise the number of ADC digits for overlay

Definition at line 642 of file Run2TriggerTowerMaker.cxx.

   {
  
     // 3 possible cases:
     // Case 1.) Signal MC and overlay data have same number of digits - easy peasy lemon squeezy
     // Case 2.) Signal MC is larger - pad the overlay digits
     // Case 3.) Signal MC is smaller - crop the overlay digits
     
     // Case 1.)
     if (sigDigits.size() == ovDigits.size()) {
       for (auto x:ovDigits) normDigits.push_back( x );
     }
     
     // Case 2.)
     if (sigDigits.size() > ovDigits.size()) {
       unsigned int pad = (sigDigits.size() - ovDigits.size()) / 2;
       for (unsigned int x=0;x<pad;++x) normDigits.push_back( 32 );
       for (auto x:ovDigits) normDigits.push_back( x );
       for (unsigned int x=0;x<pad;++x) normDigits.push_back( 32 );
     }
     
     
     // Case 3.)
     if (sigDigits.size() < ovDigits.size()) {
       unsigned int offset = (ovDigits.size() - sigDigits.size()) / 2;
       for (unsigned int x=0;x<sigDigits.size();++x) {
         unsigned int pos = x + offset;
         normDigits.push_back( ovDigits[pos] );
       }    
     }
    
   }  

◆ operator=()

Run2TriggerTowerMaker& LVL1::Run2TriggerTowerMaker::operator= ( const Run2TriggerTowerMaker & )

delete

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

◆ preProcess()

StatusCode LVL1::Run2TriggerTowerMaker::preProcess	(	int	bcid,
		float	mu
	)

private

Simulate PreProcessing on analogue amplitudes.

Emulate FIR filter, bunch-crossing identification & LUT, and create & fill TriggerTowers.

Definition at line 678 of file Run2TriggerTowerMaker.cxx.

   {
     // Loop over all existing towers and simulate preprocessor functions
     for(auto tower : *m_xaodTowers) {
       ATH_CHECK(preProcessTower(bcid,mu,tower));
     }
     return StatusCode::SUCCESS;
   }

◆ preProcessTower()

StatusCode LVL1::Run2TriggerTowerMaker::preProcessTower	(	int	bcid,
		float	mu,
		xAOD::TriggerTower *	tower
	)

private

retrieve digits

process tower – digitial filter

dynamic pedestal correction

BCID algorithms (only possible if 7 slices readout)

In simulation external BCID is always zero, but for consistency with data we need to add it to the TriggerTower objects

Definition at line 687 of file Run2TriggerTowerMaker.cxx.

   {
     
     const L1CaloPprChanCalib* chanCalib =  m_chanCalibContainer->pprChanCalib(tower->coolId());
  
     if (!chanCalib) {
       ATH_MSG_ERROR("Tower with coolId 0x"<<std::hex<<tower->coolId()<<std::dec<<" Not in database! Aborting ...");
       return StatusCode::FAILURE;
     }
     
     // pedestal correction
     int pedCorrectionStrategy(0);
     // Regular job - no overlay
     if (!m_doOverlay) {
       if (chanCalib->pedFirSum() && !m_isDataReprocessing) pedCorrectionStrategy = 1; // simulation
       if (chanCalib->pedFirSum() && m_isDataReprocessing) pedCorrectionStrategy = 2; // data reprocessing
     }
     if (m_doOverlay) {
       pedCorrectionStrategy = chanCalib->lutCpStrategy();
     }
  
     std::vector<int> digits(std::begin(tower->adc()), std::end(tower->adc()));
  
     std::vector<int> fir;
     m_TTtool->fir(digits,
                   { chanCalib->firCoeff5(), chanCalib->firCoeff4(), chanCalib->firCoeff3(),
                       chanCalib->firCoeff2(), chanCalib->firCoeff1() }, // reverse order in database
                   fir);
  
     std::vector<int16_t> correction;
     // a few cases follow
     // 1.) simulation and pedestal correction enabled
     // 2.) data reprocessing and pedestal correction enabled
     // 3.) pedestal correction disabled
     
     // old method - now deprecated
 //     if(chanCalib->pedFirSum() && !m_isDataReprocessing) {
     
     // new method
     if (pedCorrectionStrategy == 1) {
       // case 1.) (database "abuses" pedFirSum to steer pedestal correction)
       // apply the parameterized pedestal correction
       int firPed = (chanCalib->firCoeff5() + chanCalib->firCoeff4() + chanCalib->firCoeff3() +
                     chanCalib->firCoeff2() + chanCalib->firCoeff1()) * int(chanCalib->pedMean() + 0.5);
       m_TTtool->pedestalCorrection(fir,
                                   firPed,
                                   etaToElement(tower->eta(), tower->layer()),
                                   tower->layer(),
                                   bcid,
                                   mu,
                                   correction);
     } 
     
     // old method - now deprecated
     //else if(chanCalib->pedFirSum() && m_isDataReprocessing) {
     if (pedCorrectionStrategy == 2) {
     
       // case 2.) (database "abuses" pedFirSum to steer pedestal correction)
       // apply the recorded pedestal correction
       if(!tower->correctionEnabled().empty() && tower->correctionEnabled().front()) {
         std::size_t offset = (fir.size() - tower->correction().size())/2;
  
         for(std::size_t i = offset, e = fir.size() - offset; i != e; ++i) {
           correction.push_back(tower->correction()[i-offset]);
           fir[i] -= tower->correction()[i-offset];
         }
         ATH_MSG_VERBOSE("::correction: (from data");
         printVec(this->msg(MSG::VERBOSE), correction);
       } // in case the correction wasn't enabled in the readout nothing has to be done
     } 
     
     // Case 3.) not yet implemented (will it ever be....??)
  
     std::vector<int> lutIn;
     m_TTtool->dropBits(fir, chanCalib->firStartBit(), lutIn);
  
     // linear LUTs - CP
     std::vector<int> lutOut_cp;
     ATH_MSG_VERBOSE("::cp-lut: strategy: " << chanCalib->lutCpStrategy());
     if(chanCalib->lutCpStrategy() < 3) {
       // for new strategy lutSlope, lutOffset and lutNoiseCut are in units of LUTOut
       // and need to be multiplied by the scale factor
       double scale = (chanCalib->lutCpStrategy() == 0) ? 1. : m_cpLutScale;
  
       m_TTtool->lut(lutIn,
                     scale * chanCalib->lutCpSlope(),
                     scale * chanCalib->lutCpOffset(),
                     scale * chanCalib->lutCpNoiseCut(),
                     32 /* unused */,
                     chanCalib->lutCpStrategy() > 0,
                     false, // TODO - disabled?
                     lutOut_cp);
     } else if(chanCalib->lutCpStrategy() == 3) {
       for(auto l : lutIn) lutOut_cp.push_back(non_linear_lut(l, chanCalib->lutCpOffset(), chanCalib->lutCpSlope(), chanCalib->lutCpNoiseCut(), chanCalib->lutCpScale(), chanCalib->lutCpPar1(), chanCalib->lutCpPar2(), chanCalib->lutCpPar3(), chanCalib->lutCpPar4()));
     }
     ATH_MSG_VERBOSE("::cp-lut: lut:");
     printVec(this->msg(MSG::VERBOSE), lutOut_cp);
  
  
     // linear LUTs - JEP
     std::vector<int> lutOut_jep;
     ATH_MSG_VERBOSE("::jep-lut: strategy: " << chanCalib->lutJepStrategy());
     if(chanCalib->lutJepStrategy() < 3) {
       // for new strategy lutSlope, lutOffset and lutNoiseCut are in units of LUTOut
       // and need to be multiplied by the scale factor
       double scale = (chanCalib->lutJepStrategy() == 0) ? 1. : m_jepLutScale;
  
       m_TTtool->lut(lutIn,
                     scale * chanCalib->lutJepSlope(),
                     scale * chanCalib->lutJepOffset(),
                     scale * chanCalib->lutJepNoiseCut(),
                     32 /* unused */,
                     chanCalib->lutJepStrategy() > 0,
                     false, // TODO - disabled?
                     lutOut_jep);
     } else if(chanCalib->lutJepStrategy() == 3) {
       for(auto l : lutIn) lutOut_jep.push_back(non_linear_lut(l, chanCalib->lutJepOffset(), chanCalib->lutJepSlope(), chanCalib->lutJepNoiseCut(), chanCalib->lutJepScale(), chanCalib->lutJepPar1(), chanCalib->lutJepPar2(), chanCalib->lutJepPar3(), chanCalib->lutJepPar4()));
     }
     ATH_MSG_VERBOSE("::jep-lut: lut:");
     printVec(this->msg(MSG::VERBOSE), lutOut_jep);
  
  
     std::vector<int> BCIDOut;
     if(!m_isDataReprocessing || tower->adc().size() >= 7) {
       m_TTtool->bcid(fir, digits,
                     m_chanDefaults.peakFinderCond(),
                     chanCalib->satBcidThreshLow(),
                     chanCalib->satBcidThreshHigh(),
                     chanCalib->satBcidLevel(),
                     BCIDOut);
     } else {
       // in data reprocessing with less than 7 slices take decision from data
       BCIDOut.assign(tower->bcidVec().begin(), tower->bcidVec().end());
       ATH_MSG_VERBOSE("::bcidOut: (from data):");
       printVec(this->msg(MSG::VERBOSE), BCIDOut);
     }
  
     std::size_t peak = lutOut_jep.size()/2; // both cp & jep have the same length
     std::vector<uint_least8_t> etResultVectorCp { uint8_t(lutOut_cp[peak]) };
     ATH_MSG_VERBOSE("::etResultVector: cp:");
     printVec(this->msg(MSG::VERBOSE), etResultVectorCp);
     std::vector<uint_least8_t> etResultVectorJep { uint8_t(lutOut_jep[peak]) };
     ATH_MSG_VERBOSE("::etResultVector: jep:");
     printVec(this->msg(MSG::VERBOSE), etResultVectorJep);
  
     // identify BCID range
     int range;
     if(!(m_chanDefaults.decisionSource() & 0x1)) {
       range = EtRange(digits[digits.size()/2], chanCalib->bcidEnergyRangeLow(), chanCalib->bcidEnergyRangeHigh());
     } else {
       range = EtRange(fir[fir.size()/2], chanCalib->bcidEnergyRangeLow(), chanCalib->bcidEnergyRangeHigh());
     }
     ATH_MSG_VERBOSE("::range: " << range);
  
     // correct BCID for this range?
     std::array<int, 3> bcidDecision {
       {m_chanDefaults.bcidDecision1(), m_chanDefaults.bcidDecision2(), m_chanDefaults.bcidDecision3()}
     };
     ATH_MSG_VERBOSE("::bcidDecision:");
     printVec(this->msg(MSG::VERBOSE), bcidDecision);
  
     std::array<int, 3> satOverride {
       {m_chanDefaults.satOverride1(), m_chanDefaults.satOverride2(), m_chanDefaults.satOverride3()}
     };
     ATH_MSG_VERBOSE("::satOverride:");
     printVec(this->msg(MSG::VERBOSE), satOverride);
  
     if((bcidDecision[range]) & (0x1 << (BCIDOut[BCIDOut.size()/2]))) {
       if((satOverride[range]) & 0x1) {
         // return saturation if set
         etResultVectorCp[0] = SATURATIONVALUE;
         etResultVectorJep[0] = SATURATIONVALUE;
       }
     } else {
       // zero if fail BCID
       etResultVectorCp[0] = 0;
       etResultVectorJep[0] = 0;
     }
  
     // Overlay protection
     if (m_inputTTLocation.key() == "NoneForOverlay") return StatusCode::SUCCESS;
  
     tower->setLut_cp(std::move(etResultVectorCp));
     tower->setLut_jep(std::move(etResultVectorJep));
     tower->setBcidVec({uint8_t(BCIDOut[BCIDOut.size()/2])});
     ATH_MSG_VERBOSE("::set bcidVec:");
     printVec(this->msg(MSG::VERBOSE), tower->bcidVec());
     tower->setPeak(0u); // we only added one item to etResultVector
     if(m_decorateFIR) firDecorator(*tower) = fir[fir.size()/2];
  
     tower->setBcidExt(std::vector<uint8_t>(tower->adc().size(), 0u));
  
     // fill the pedestal correction
     if(chanCalib->pedFirSum()) {
       // online database abuses pedFirSum to steer pedestal correction
       tower->setCorrectionEnabled(std::vector<uint8_t>(tower->lut_cp().size(), 1u));
       tower->setCorrection(std::vector<int16_t>(tower->lut_cp().size(),
                                                 correction[correction.size()/2]));
       ATH_MSG_VERBOSE("::set correction:");
       printVec(this->msg(MSG::VERBOSE), tower->correction());
     } else {
       tower->setCorrectionEnabled(std::vector<uint8_t>(tower->lut_cp().size(), 0u));
       tower->setCorrection(std::vector<int16_t>(tower->lut_cp().size(), 0u));
     }
     return StatusCode::SUCCESS;
   }

◆ preProcessTower_getLutIn()

StatusCode LVL1::Run2TriggerTowerMaker::preProcessTower_getLutIn	(	int	bcid,
		float	mu,
		xAOD::TriggerTower *	tower,
		const L1CaloPprChanCalib *	db,
		const std::vector< int > &	digits,
		std::vector< int > &	output
	)

private

PreProcess up to LUT in.

Definition at line 592 of file Run2TriggerTowerMaker.cxx.

   {
     // factorised version of Run2TriggerTowerMaker::preProcessTower 
     
     // process tower -- digital filter
     std::vector<int> fir;
     m_TTtool->fir(digits,
                   {db->firCoeff5(),db->firCoeff4(),db->firCoeff3(),db->firCoeff2(),db->firCoeff1()}, // reverse order in database
                   fir);
     
      // pedestal correction
     int pedCorrectionStrategy = db->lutCpStrategy();
     std::vector<int16_t> correction;
     
     // 1.) simulation and pedestal correction enabled
     if (pedCorrectionStrategy == 1) {
 //       cout<<"Using Simulation pedCorrectionStrategy"<<endl;
       // case 1.) (database "abuses" pedFirSum to steer pedestal correction)
       // apply the parameterized pedestal correction
       int firPed = (db->firCoeff5() + db->firCoeff4() + db->firCoeff3() +
                     db->firCoeff2() + db->firCoeff1()) * int(db->pedMean() + 0.5);
       m_TTtool->pedestalCorrection(fir,
                                   firPed,
                                   etaToElement(tower->eta(), tower->layer()),
                                   tower->layer(),
                                   bcid,
                                   mu,
                                   correction);
     }
     
     // 2.) data reprocessing and pedestal correction enabled
     if (pedCorrectionStrategy == 2) {
 //       cout<<"Using data pedCorrectionStrategy"<<endl;
       // case 2.) (database "abuses" pedFirSum to steer pedestal correction)
       // apply the recorded pedestal correction
       if(!tower->correctionEnabled().empty() && tower->correctionEnabled().front()) {
         std::size_t offset = (fir.size() - tower->correction().size())/2;
  
         for(std::size_t i = offset, e = fir.size() - offset; i != e; ++i) {
           correction.push_back(tower->correction()[i-offset]);
           fir[i] -= tower->correction()[i-offset];
         }
       } 
     }
     
     m_TTtool->dropBits(fir, db->firStartBit(), output);   
     
     return StatusCode::SUCCESS; 
   }

◆ processLArTowers()

void LVL1::Run2TriggerTowerMaker::processLArTowers ( const LArTTL1Container * towers )

private

extract amplitudes from TTL1

steps over Calo towers and creates/fills trigger towers

Definition at line 1023 of file Run2TriggerTowerMaker.cxx.

   {
     int towerNumber=0;
     for(const LArTTL1* tower : *towers){
       ATH_MSG_VERBOSE("Looking at retrieved tower number "<<towerNumber++<<" ***********");
  
       // Obtain identifier
       Identifier id = tower->ttOfflineID();
       double eta = IDeta(id, m_caloId);
       double phi = IDphi(id, m_caloId);
       int layer = int(m_caloId->sampling(id) != 0);
       L1CaloCoolChannelId coolId = channelId(eta, phi, layer);
  
       // Tower amplitudes and type
       int nsamples = tower->nsamples();
       std::vector<float> tower_amps = tower->samples();
  
       // Now calibrate tower_amps then fill TriggerTower amplitude vector
       // TTL1 should have 7 samples, but this little kludge handles other
       // eventualities, provided peak is in centre of the pulse
       int offset = (nsamples - (s_FIRLENGTH+2))/2;
       std::vector<double> amps(s_FIRLENGTH+2);
  
       ATH_MSG_VERBOSE("nsamples = " << nsamples << " offset = " << offset);
  
       for(int i = 0; i < s_FIRLENGTH+2; i++) {
         int j = i + offset;
         if(j >= 0 && j < nsamples) {
           amps[i] = tower_amps[j];
         }
         else {
           amps[i] = 0.;
         }
         ATH_MSG_VERBOSE("amps[" << i << "] = " << amps[i]);
       }
  
       // Create TriggerTower
       xAOD::TriggerTower* t = (*m_xaodTowers)[m_curIndex++] = new xAOD::TriggerTower;
       t->setCoolId(coolId.id());
       t->setEta(eta);
       t->setPhi(phi);
       m_xaodTowersAmps[t->index()] = std::move(amps);
     } // end for loop
   }

◆ processTileTowers()

void LVL1::Run2TriggerTowerMaker::processTileTowers ( const TileTTL1Container * towers )

private

Definition at line 1068 of file Run2TriggerTowerMaker.cxx.

   {
     // Step over all towers
     int towerNumber=0;
     for(const TileTTL1* tower : *towers) {
       ATH_MSG_VERBOSE("Looking at retrieved tower number "<<towerNumber++<<" ***********");
  
       // Obtain identifier
       Identifier id = tower->TTL1_ID();
       double cal = m_TileToMeV;//calib(id, m_caloId)*m_TileToMeV;
  
       // Check this tower is used by the trigger
       // don't use gap or mbias scinitllators
       if(m_caloId->is_tile(id)) {
         double tower_eta = IDeta(id, m_caloId);
         double tower_phi = IDphi(id, m_caloId);
  
         // need to convert tower energy to E_t later
         unsigned Ieta = unsigned(fabs(tower_eta)*10.0);
         if(Ieta >= m_maxIetaBins){
           ATH_MSG_WARNING("TileTTL1 with invalid index for m_sinThetaHash: Ieta = " << Ieta);
           Ieta = 0u;
         }
  
         /* Extract amplitudes and rescale according to tower eta */
         int nsamples = tower->nsamples();
         std::vector<float> tower_amps = tower->fsamples();
  
         /* Debug message */
         ATH_MSG_VERBOSE(" nsamples = " << nsamples);
  
         // Want 7 samples, but this little kludge allows us to accept other
         // numbers, provided peak is in centre of the pulse
         int offset = (nsamples - (s_FIRLENGTH+2))/2;
         std::vector<double> amps(s_FIRLENGTH+2);
         for(int i = 0; i < 7; i++) {
           int j = i + offset;
           if(j >= 0 && j < nsamples) {
             amps[i] = (tower_amps[j]-m_TileTTL1Ped)*m_sinThetaHash[Ieta]*cal; // rescale to MeV
           }
           else {
             amps[i] = 0.;
           }
           /* Debug message */
           ATH_MSG_VERBOSE("amps[" << i << "] = " << amps[i]);
         }
  
         // Create TriggerTower
         // m_xaodTowers->push_back(new xAOD::TriggerTower);
         // auto t = m_xaodTowers->back();
         xAOD::TriggerTower* t = (*m_xaodTowers)[m_curIndex++] = new xAOD::TriggerTower;
         t->setCoolId(channelId(tower_eta, tower_phi, 1).id());
         t->setEta(tower_eta);
         t->setPhi(tower_phi);
         m_xaodTowersAmps[t->index()] = std::move(amps);
       } // end check on whether tower is used
     } // end for loop
  
     return;
   }

◆ 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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ store()

StatusCode LVL1::Run2TriggerTowerMaker::store ( )

private

Stores Trigger Towers in the TES, at a location defined in m_outputLocation.

Returns FAILURE if the towers could not be saved.

Definition at line 905 of file Run2TriggerTowerMaker.cxx.

   {
     ATH_MSG_DEBUG("Storing TTs in DataVector");
     if(m_ZeroSuppress) {
       // remove trigger towers whose energy is 0
       m_xaodTowers->erase(std::remove_if(m_xaodTowers->begin(), m_xaodTowers->end(),
                                         [](const xAOD::TriggerTower* tt){
                                           return tt->cpET() == 0 && tt->jepET() == 0;
                                         }),
                           m_xaodTowers->end());
     }
  
     
  
     if (m_cellType == TRIGGERTOWERS) {
       SG::WriteHandle<xAOD::TriggerTowerContainer> output(m_outputLocationRerun);
       ATH_CHECK(output.record(std::move(m_xaodTowers), std::move(m_xaodTowersAux)));
     }
     else if (m_cellType == TTL1) {
       SG::WriteHandle<xAOD::TriggerTowerContainer> output(m_outputLocation);
       ATH_CHECK(output.record(std::move(m_xaodTowers), std::move(m_xaodTowersAux)));
     }
  
     return StatusCode::SUCCESS;
   } // end of LVL1::Run2TriggerTowerMaker::store(){

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;
 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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_actMuKey

SG::ReadDecorHandleKey<xAOD::EventInfo> LVL1::Run2TriggerTowerMaker::m_actMuKey { this, "actualInteractionsPerCrossingKey", "EventInfo.actualInteractionsPerCrossing", "Decoration for actual interactions per crossing" }

private

Definition at line 266 of file Run2TriggerTowerMaker.h.

◆ m_adcStep

double LVL1::Run2TriggerTowerMaker::m_adcStep

private

Definition at line 131 of file Run2TriggerTowerMaker.h.

◆ m_adcVar

double LVL1::Run2TriggerTowerMaker::m_adcVar

private

Definition at line 128 of file Run2TriggerTowerMaker.h.

◆ m_bstowertool

ToolHandle<LVL1BS::ITrigT1CaloDataAccessV2> LVL1::Run2TriggerTowerMaker::m_bstowertool

private

Definition at line 157 of file Run2TriggerTowerMaker.h.

◆ m_caloId

const CaloLVL1_ID* LVL1::Run2TriggerTowerMaker::m_caloId

private

Definition at line 159 of file Run2TriggerTowerMaker.h.

◆ m_cellType

int LVL1::Run2TriggerTowerMaker::m_cellType

private

Definition at line 125 of file Run2TriggerTowerMaker.h.

◆ m_chanCalibContainer

const L1CaloPprChanCalibContainer* LVL1::Run2TriggerTowerMaker::m_chanCalibContainer = nullptr

private

Definition at line 177 of file Run2TriggerTowerMaker.h.

◆ m_chanCalibContaineroverlay

L1CaloPprChanCalibContainer* LVL1::Run2TriggerTowerMaker::m_chanCalibContaineroverlay = nullptr

private

Definition at line 181 of file Run2TriggerTowerMaker.h.

◆ m_chanCalibKey

SG::ReadCondHandleKey<L1CaloPprChanCalibContainer> LVL1::Run2TriggerTowerMaker::m_chanCalibKey {this,"ChanCalibFolderKey","/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib","PprChanCalib key"}

private

Definition at line 142 of file Run2TriggerTowerMaker.h.

◆ m_chanCalibKeyoverlay

std::string LVL1::Run2TriggerTowerMaker::m_chanCalibKeyoverlay

private

Definition at line 146 of file Run2TriggerTowerMaker.h.

◆ m_chanDefaults

L1CaloPprChanDefaults LVL1::Run2TriggerTowerMaker::m_chanDefaults

private

Definition at line 180 of file Run2TriggerTowerMaker.h.

◆ m_chanDefaultsKey

SG::ReadCondHandleKey<L1CaloPprChanDefaultsContainer> LVL1::Run2TriggerTowerMaker::m_chanDefaultsKey {this,"ChanDefaultsFolderKey","/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults","PprChanDefaults key"}

private

Definition at line 143 of file Run2TriggerTowerMaker.h.

◆ m_chanDefaultsKeyoverlay

std::string LVL1::Run2TriggerTowerMaker::m_chanDefaultsKeyoverlay

private

Definition at line 147 of file Run2TriggerTowerMaker.h.

◆ m_chanDefaultsoverlay

L1CaloPprChanDefaults LVL1::Run2TriggerTowerMaker::m_chanDefaultsoverlay

private

Definition at line 184 of file Run2TriggerTowerMaker.h.

◆ m_cpLutScale

double LVL1::Run2TriggerTowerMaker::m_cpLutScale

private

Definition at line 162 of file Run2TriggerTowerMaker.h.

◆ m_curIndex

std::size_t LVL1::Run2TriggerTowerMaker::m_curIndex = 0u

private

Definition at line 189 of file Run2TriggerTowerMaker.h.

◆ m_deadChannelsContainer

const L1CaloPpmDeadChannelsContainer* LVL1::Run2TriggerTowerMaker::m_deadChannelsContainer = nullptr

private

Definition at line 179 of file Run2TriggerTowerMaker.h.

◆ m_deadChannelsContaineroverlay

L1CaloPpmDeadChannelsContainer* LVL1::Run2TriggerTowerMaker::m_deadChannelsContaineroverlay = nullptr

private

Definition at line 183 of file Run2TriggerTowerMaker.h.

◆ m_deadChannelsKey

SG::ReadCondHandleKey<L1CaloPpmDeadChannelsContainer> LVL1::Run2TriggerTowerMaker::m_deadChannelsKey {this,"DeadChannelsFolderKey","/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels","PpmDeadChannels key"}

private

Definition at line 145 of file Run2TriggerTowerMaker.h.

◆ m_deadChannelsKeyoverlay

std::string LVL1::Run2TriggerTowerMaker::m_deadChannelsKeyoverlay

private

Definition at line 149 of file Run2TriggerTowerMaker.h.

◆ m_decorateFIR

bool LVL1::Run2TriggerTowerMaker::m_decorateFIR

private

Definition at line 133 of file Run2TriggerTowerMaker.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_digiEngine

std::string LVL1::Run2TriggerTowerMaker::m_digiEngine

private

Definition at line 122 of file Run2TriggerTowerMaker.h.

◆ m_disabledTowersContainer

const L1CaloDisabledTowersContainer* LVL1::Run2TriggerTowerMaker::m_disabledTowersContainer = nullptr

private

Definition at line 178 of file Run2TriggerTowerMaker.h.

◆ m_disabledTowersContaineroverlay

L1CaloDisabledTowersContainer* LVL1::Run2TriggerTowerMaker::m_disabledTowersContaineroverlay = nullptr

private

Definition at line 182 of file Run2TriggerTowerMaker.h.

◆ m_disabledTowersKey

SG::ReadCondHandleKey<L1CaloDisabledTowersContainer> LVL1::Run2TriggerTowerMaker::m_disabledTowersKey {this,"DisabledTowersFolderKey","/TRIGGER/L1Calo/V2/Conditions/DisabledTowers","DisabledTowers key"}

private

Definition at line 144 of file Run2TriggerTowerMaker.h.

◆ m_disabledTowersKeyoverlay

std::string LVL1::Run2TriggerTowerMaker::m_disabledTowersKeyoverlay

private

Definition at line 148 of file Run2TriggerTowerMaker.h.

◆ m_doOverlay

bool LVL1::Run2TriggerTowerMaker::m_doOverlay

private

Definition at line 173 of file Run2TriggerTowerMaker.h.

◆ m_EmTTL1ContainerName

SG::ReadHandleKey<LArTTL1Container> LVL1::Run2TriggerTowerMaker::m_EmTTL1ContainerName

private

Definition at line 276 of file Run2TriggerTowerMaker.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_gainCorr

double LVL1::Run2TriggerTowerMaker::m_gainCorr

private

Definition at line 132 of file Run2TriggerTowerMaker.h.

◆ m_HadTTL1ContainerName

SG::ReadHandleKey<LArTTL1Container> LVL1::Run2TriggerTowerMaker::m_HadTTL1ContainerName

private

Definition at line 277 of file Run2TriggerTowerMaker.h.

◆ m_inputTTLocation

SG::ReadHandleKey<xAOD::TriggerTowerContainer> LVL1::Run2TriggerTowerMaker::m_inputTTLocation

private

Definition at line 269 of file Run2TriggerTowerMaker.h.

◆ m_isDataReprocessing

bool LVL1::Run2TriggerTowerMaker::m_isDataReprocessing

private

Definition at line 171 of file Run2TriggerTowerMaker.h.

◆ m_isReco

bool LVL1::Run2TriggerTowerMaker::m_isReco

private

Definition at line 174 of file Run2TriggerTowerMaker.h.

◆ m_jepLutScale

double LVL1::Run2TriggerTowerMaker::m_jepLutScale

private

Definition at line 163 of file Run2TriggerTowerMaker.h.

◆ m_L1MenuKey

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

private

Definition at line 280 of file Run2TriggerTowerMaker.h.

◆ m_mappingTool

ToolHandle<IL1CaloMappingTool> LVL1::Run2TriggerTowerMaker::m_mappingTool

private

Definition at line 156 of file Run2TriggerTowerMaker.h.

◆ m_maxIetaBins

constexpr static unsigned int LVL1::Run2TriggerTowerMaker::m_maxIetaBins = 51

staticconstexprprivate

Definition at line 115 of file Run2TriggerTowerMaker.h.

◆ m_outputLocation

SG::WriteHandleKey<xAOD::TriggerTowerContainer> LVL1::Run2TriggerTowerMaker::m_outputLocation

private

Definition at line 271 of file Run2TriggerTowerMaker.h.

◆ m_outputLocationRerun

SG::WriteHandleKey<xAOD::TriggerTowerContainer> LVL1::Run2TriggerTowerMaker::m_outputLocationRerun

private

Definition at line 273 of file Run2TriggerTowerMaker.h.

◆ m_requireAllCalos

bool LVL1::Run2TriggerTowerMaker::m_requireAllCalos

private

Definition at line 139 of file Run2TriggerTowerMaker.h.

◆ m_rndmADCs

ATHRNG::RNGWrapper* LVL1::Run2TriggerTowerMaker::m_rndmADCs

private

Definition at line 153 of file Run2TriggerTowerMaker.h.

◆ m_rngSvc

ServiceHandle<IAthRNGSvc> LVL1::Run2TriggerTowerMaker::m_rngSvc

private

Definition at line 152 of file Run2TriggerTowerMaker.h.

◆ m_sinThetaHash

std::array<double, m_maxIetaBins> LVL1::Run2TriggerTowerMaker::m_sinThetaHash

private

instead of calculating the expression: double theta =2.

*atan(exp(-fabs(cell_eta))); cell_energy=sin(theta)*cell_energy; for each em and had TT again, we will use a hash table

Definition at line 197 of file Run2TriggerTowerMaker.h.

◆ m_TileToMeV

double LVL1::Run2TriggerTowerMaker::m_TileToMeV

private

Definition at line 165 of file Run2TriggerTowerMaker.h.

◆ m_TileTTL1ContainerName

SG::ReadHandleKey<TileTTL1Container> LVL1::Run2TriggerTowerMaker::m_TileTTL1ContainerName

private

Definition at line 278 of file Run2TriggerTowerMaker.h.

◆ m_TileTTL1Ped

double LVL1::Run2TriggerTowerMaker::m_TileTTL1Ped

private

Definition at line 167 of file Run2TriggerTowerMaker.h.

◆ m_TTtool

ToolHandle<IL1TriggerTowerTool> LVL1::Run2TriggerTowerMaker::m_TTtool {this,"TTTool","LVL1::L1TriggerTowerTool/L1TriggerTowerTool", "The trigger tower tool"}

private

Definition at line 155 of file Run2TriggerTowerMaker.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xaodevtKey

SG::ReadHandleKey<xAOD::EventInfo> LVL1::Run2TriggerTowerMaker::m_xaodevtKey

private

Definition at line 265 of file Run2TriggerTowerMaker.h.

◆ m_xaodTowers

std::unique_ptr<xAOD::TriggerTowerContainer> LVL1::Run2TriggerTowerMaker::m_xaodTowers

private

Definition at line 186 of file Run2TriggerTowerMaker.h.

◆ m_xaodTowersAmps

std::vector<std::vector<double> > LVL1::Run2TriggerTowerMaker::m_xaodTowersAmps

private

Definition at line 188 of file Run2TriggerTowerMaker.h.

◆ m_xaodTowersAux

std::unique_ptr<xAOD::TriggerTowerAuxContainer> LVL1::Run2TriggerTowerMaker::m_xaodTowersAux

private

Definition at line 187 of file Run2TriggerTowerMaker.h.

◆ m_ZeroSuppress

bool LVL1::Run2TriggerTowerMaker::m_ZeroSuppress

private

Definition at line 136 of file Run2TriggerTowerMaker.h.

◆ s_FIRLENGTH

constexpr static int LVL1::Run2TriggerTowerMaker::s_FIRLENGTH = 5

staticconstexprprivate

Definition at line 113 of file Run2TriggerTowerMaker.h.

◆ s_MEV

constexpr static int LVL1::Run2TriggerTowerMaker::s_MEV = 1000

staticconstexprprivate

Definition at line 114 of file Run2TriggerTowerMaker.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ CellTypes

Constructor & Destructor Documentation

◆ Run2TriggerTowerMaker() [1/2]

◆ ~Run2TriggerTowerMaker()

◆ Run2TriggerTowerMaker() [2/2]

Member Function Documentation

◆ ADC()

◆ addOverlay() [1/2]

◆ addOverlay() [2/2]

◆ calcCombinedLUT()

◆ calcLutOutCP()

◆ calcLutOutJEP()

◆ channelId()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ digitize()

◆ etaToElement()

◆ EtRange()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ getCaloTowers()

◆ getTriggerTowers()

◆ handle()

◆ IDeta()

◆ IDphi()

◆ initialize()

◆ inputHandles()

◆ IsDeadChannel()

◆ IsDisabledChannel()

◆ IsGoodTower()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ non_linear_lut()

◆ normaliseDigits()

◆ operator=()

◆ outputHandles()

◆ preProcess()

◆ preProcessTower()

◆ preProcessTower_getLutIn()

◆ processLArTowers()

◆ processTileTowers()

◆ renounce()

◆ renounceArray()

◆ store()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_actMuKey

◆ m_adcStep

◆ m_adcVar

◆ m_bstowertool

◆ m_caloId

◆ m_cellType

◆ m_chanCalibContainer

◆ m_chanCalibContaineroverlay