LVL1::Run2TriggerTowerMaker Class Reference

#include <Run2TriggerTowerMaker.h>

Inheritance 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.
StatusCode	finalize ()
void	handle (const Incident &)
	Best if initialisation which uses COOL-derived values is done here rather than in initialize()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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	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

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
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)
StatusCode	getTriggerTowers ()
	gets collection of input TriggerTowers for reprocessing
StatusCode	getCaloTowers ()
	fetch Calorimeter Towers
void	digitize (const EventContext &ctx)
	Convert analogue pulses to digits.
StatusCode	preProcess (int bcid, float mu)
	Simulate PreProcessing on analogue amplitudes.
StatusCode	preProcessTower (int bcid, float mu, xAOD::TriggerTower *tower)
virtual StatusCode	addOverlay (int bcid, float mu)
	Add overlay data.
virtual StatusCode	addOverlay (int bcid, float mu, xAOD::TriggerTower *sigTT, xAOD::TriggerTower *ovTT)
	Add the overlay TriggerTower to the signal TriggerTower.
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.
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
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.
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
StatusCode	store ()
	Stores Trigger Towers in the TES, at a location defined in m_outputLocation.
void	processLArTowers (const LArTTL1Container *)
	extract amplitudes from TTL1
void	processTileTowers (const TileTTL1Container *)
double	IDeta (const Identifier &id, const CaloLVL1_ID *caloId)
	functions to extract eta, phi coordinates from calo tower identifiers
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.
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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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.
SG::ReadHandleKey< xAOD::EventInfo >	m_xaodevtKey {this, "xAODEventInfoKey", "EventInfo"}
SG::ReadDecorHandleKey< xAOD::EventInfo >	m_actMuKey { this, "actualInteractionsPerCrossingKey", m_xaodevtKey, "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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr int	s_FIRLENGTH = 5
static constexpr int	s_MEV = 1000
static constexpr 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.

{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("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 151 of file Run2TriggerTowerMaker.cxx.

{}

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 1149 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 397 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 475 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 562 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 520 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 541 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 1217 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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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; }

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 1135 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 1227 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 1174 of file Run2TriggerTowerMaker.cxx.

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

evtStore()

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.

{ 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 308 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 300 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 966 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 939 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 213 of file Run2TriggerTowerMaker.cxx.

  {
    if(inc.type() != "BeginRun") return;
 
    auto l1Menu = SG::makeHandle( m_L1MenuKey );
    try {
        m_cpLutScale = l1Menu->thrExtraInfo().EM().emScale();
        m_jepLutScale = l1Menu->thrExtraInfo().JET().jetScale();
    } catch(const std::out_of_range&) {
        ATH_MSG_DEBUG("No Legacy triggers in menu, using default scales");
        m_cpLutScale = 2;
        m_jepLutScale = 1;
    }
 
    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 1181 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 1202 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 153 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 375 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 382 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 389 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 1266 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 647 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 683 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 692 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 597 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 1028 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 1073 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.

Returns FAILURE if the towers could not be saved.

Definition at line 910 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, AthHistogramAlgorithm, and PyAthena::Alg.

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", m_xaodevtKey, "actualInteractionsPerCrossing", "Decoration for actual interactions per crossing" }

private

Definition at line 266 of file Run2TriggerTowerMaker.h.

{ this, "actualInteractionsPerCrossingKey", m_xaodevtKey, "actualInteractionsPerCrossing", "Decoration for actual interactions per crossing" };

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.

{this,"ChanCalibFolderKey","/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib","PprChanCalib key"};

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.

{this,"ChanDefaultsFolderKey","/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults","PprChanDefaults key"};

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.

{this,"DeadChannelsFolderKey","/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels","PpmDeadChannels key"};

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.

{this,"DisabledTowersFolderKey","/TRIGGER/L1Calo/V2/Conditions/DisabledTowers","DisabledTowers key"};

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.

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

m_mappingTool

ToolHandle<IL1CaloMappingTool> LVL1::Run2TriggerTowerMaker::m_mappingTool

private

Definition at line 156 of file Run2TriggerTowerMaker.h.

m_maxIetaBins

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.

{this,"TTTool","LVL1::L1TriggerTowerTool/L1TriggerTowerTool", "The trigger tower tool"};

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 {this, "xAODEventInfoKey", "EventInfo"}

private

Definition at line 265 of file Run2TriggerTowerMaker.h.

{this, "xAODEventInfoKey", "EventInfo"};

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

int LVL1::Run2TriggerTowerMaker::s_FIRLENGTH = 5

staticconstexprprivate

Definition at line 113 of file Run2TriggerTowerMaker.h.

s_MEV

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:

• Run2TriggerTowerMaker.h
• Run2TriggerTowerMaker.cxx