#include <TileL2Builder.h>

Inheritance diagram for TileL2Builder:

Collaboration diagram for TileL2Builder:

Public Member Functions
	TileL2Builder (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TileL2Builder () override
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	process (int fragmin, int fragmax, TileL2Container *l2Container) const
virtual StatusCode	process (int fragmin, int fragmax, TileL2Container *l2Container, const EventContext &ctx) const
int	indexToId (int i) const
	Return collection ID for a given index.
int	idToIndex (int id) const
void	MaskBad (int partition, float E, int gain, bool *bad) const
	function which does bad channel masking: if one channel of a cell is bad, energy from second channel is taken if both channels are bad, zero energy is assigned to both channels
void	MTagLB (int partition, int drawer, float *EMeV, std::vector< float > &EtaMuons, std::vector< float > &EMuons0, std::vector< float > &EMuons1, std::vector< float > &EMuons2, std::vector< unsigned int > &qf, std::vector< unsigned int > &extraWord) const
	Muon tagging function for LB superdrawers as processed at the ROD DSPs.
void	MTagLB (int partition, int drawer, float EMeV, int gain, bool *bad, std::vector< float > &EtaMuons, std::vector< float > &EMuons0, std::vector< float > &EMuons1, std::vector< float > &EMuons2, std::vector< unsigned int > &qf, std::vector< unsigned int > &extraWord) const
void	MTagEB (int partition, int drawer, float *EMeV, std::vector< float > &EtaMuons, std::vector< float > &EMuons0, std::vector< float > &EMuons1, std::vector< float > &EMuons2, std::vector< unsigned int > &qf, std::vector< unsigned int > &extraWord) const
	Muon tagging function for EB superdrawers as processed at the ROD DSPs.
void	MTagEB (int partition, int drawer, float EMeV, int gain, bool *bad, std::vector< float > &EtaMuons, std::vector< float > &EMuons0, std::vector< float > &EMuons1, std::vector< float > &EMuons2, std::vector< unsigned int > &qf, std::vector< unsigned int > &extraWord) const
void	SumE (int partition, int drawer, float *E, std::vector< float > &sumE) const
	SumE function for one superdrawer as processed at the ROD DSPs.
void	SumE (int partition, int drawer, int unit, float E, int gain, std::vector< float > &sumE) const
void	SumE (int partition, int drawer, int unit, float E, int gain, bool *bad, std::vector< float > &sumE) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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

Protected Attributes
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
	TileRawChannelContainer in event store.
float	m_noiseThreshold
int	m_noiseType
const TileHWID *	m_tileHWID
	Pointer to TileHWID.
SG::ReadCondHandleKey< TileEMScale >	m_emScaleKey
	Name of TileEMScale in condition store.
SG::ReadCondHandleKey< TileBadChannels >	m_badChannelsKey
	Name of TileBadChannels in condition store.
TileFragHash	m_hashFunc
float	m_sinTh [4][48] {}
float	m_sinThRound [4][48] {}
float	m_cosTh [4][48] {}
float	m_cosThRound [4][48] {}
bool	m_connected [4][48] {}
int	m_channelPairs [4][48] {}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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

Detailed Description

Definition at line 44 of file TileL2Builder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileL2Builder()

TileL2Builder::TileL2Builder	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 52 of file TileL2Builder.cxx.

    : AthAlgTool(type, name, parent)
  , m_noiseThreshold(100.0) // 100 MeV universal cut for now
  , m_noiseType(9999)       // this huge value means that noise cut is taken from JO
  , m_tileHWID(nullptr)
{
 
  declareInterface<TileL2Builder>(this);
 
  declareProperty("NoiseThreshold", m_noiseThreshold);       // use channels only above noise cut
  declareProperty("Noise", m_noiseType);            // choose between electronic or total noise
}

◆ ~TileL2Builder()

TileL2Builder::~TileL2Builder ( )

overridevirtual

Definition at line 66 of file TileL2Builder.cxx.

66 {

67}

Member Function Documentation

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ finalize()

StatusCode TileL2Builder::finalize ( )

overridevirtual

Definition at line 284 of file TileL2Builder.cxx.

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

◆ idToIndex()

int TileL2Builder::idToIndex ( int id ) const

inline

Definition at line 66 of file TileL2Builder.h.

                                       {
      return m_hashFunc(id);
    }

◆ indexToId()

int TileL2Builder::indexToId ( int i ) const

inline

Return collection ID for a given index.

Definition at line 62 of file TileL2Builder.h.

                                      {
      return m_hashFunc.identifier(i);
    }

◆ initialize()

StatusCode TileL2Builder::initialize ( )

overridevirtual

Definition at line 69 of file TileL2Builder.cxx.

                                     {
 
  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
 
  ATH_CHECK( m_emScaleKey.initialize() );
  ATH_CHECK( m_badChannelsKey.initialize() );
 
  // Initialize
  this->m_hashFunc.initialize(m_tileHWID);
 
  const TileID* tileID = nullptr;
  ATH_CHECK( detStore()->retrieve(tileID) );
 
  const TileTBID* tileTBID = nullptr;
  ATH_CHECK( detStore()->retrieve(tileTBID) );
 
  // retrieve Tile detector manager and TileID helper from det store
  const TileDetDescrManager* tileMgr = nullptr;
  ATH_CHECK( detStore()->retrieve(tileMgr) );
 
  ServiceHandle<TileCablingSvc> cablingSvc("TileCablingSvc", name());
  ATH_CHECK( cablingSvc.retrieve());
 
  const TileCablingService* cabling = cablingSvc->cablingService();
  if (!cabling) {
    ATH_MSG_ERROR( "Unable to retrieve TileCablingService" );
    return StatusCode::FAILURE;
  }
 
  for (int ros = 0; ros < 4; ++ros) {
    for (int ch = 0; ch < 48; ++ch) {
      m_channelPairs[ros][ch] = ch;
      m_connected[ros][ch] = true;
    }
  }
 
  int drawer = 0;
  for (int ros = 1; ros < 5; ++ros) {
    int ros1 = ros - 1;
    for (int ch = 0; ch < 48; ++ch) {
      HWIdentifier ch_id = m_tileHWID->channel_id(ros, drawer, ch);
      Identifier cell_id = cabling->h2s_cell_id(ch_id);
 
      if (cell_id.is_valid()
          && !tileTBID->is_tiletb(cell_id)
          && tileID->sample(cell_id) != TileID::SAMP_E) {
 
        m_sinTh[ros1][ch] = tileMgr->get_cell_element(cell_id)->sinTh();
        m_sinThRound[ros1][ch] = round(m_sinTh[ros1][ch] * 32768) / 32768.; // set 15 bit presision a-la DSP
        m_cosTh[ros1][ch] = fabs(tileMgr->get_cell_element(cell_id)->cosTh()); // Always positive !!!
        m_cosThRound[ros1][ch] = round(m_cosTh[ros1][ch] * 32768) / 32768.; // set 15 bit presision a-la DSP
 
        Identifier pmt1_id = tileID->pmt_id(cell_id, 0);
        Identifier pmt2_id = tileID->pmt_id(cell_id, 1);
        HWIdentifier ch1_id = cabling->s2h_channel_id(pmt1_id);
        HWIdentifier ch2_id = cabling->s2h_channel_id(pmt2_id);
        int ch1 = m_tileHWID->channel(ch1_id);
        int ch2 = m_tileHWID->channel(ch2_id);
        if (ch1 != ch && ch2 != ch) {
          ATH_MSG_ERROR( "wrong cabling! ch=" << ch
                        << " ch1=" << ch1
                        << " ch2=" << ch2 );
 
        } else {
          m_channelPairs[ros1][ch1] = ch2;
          m_channelPairs[ros1][ch2] = ch1;
        }
 
        ATH_MSG_VERBOSE( "ros=" << ros
                        << " ch=" << ch
                        << " tower=" << tileID->tower(cell_id)
                        << " sample=" << tileID->sample(cell_id)
                        << " sinTh=" << m_sinThRound[ros1][ch]
                        << " cosTh=" << m_cosThRound[ros1][ch]
                        << " channels in a cell: " << ch1 << " " << ch2 );
 
      } else {
        m_sinTh[ros1][ch] = 0.0;
        m_sinThRound[ros1][ch] = 0;
        m_cosTh[ros1][ch] = 0.0;
        m_cosThRound[ros1][ch] = 0;
        m_connected[ros1][ch] = false;
        ATH_MSG_VERBOSE( "ros=" << ros
                        << " ch=" << ch
                        << " sinTh=" << m_sinThRound[ros1][ch]
                        << " cosTh=" << m_cosThRound[ros1][ch] );
      }
    }
  }
 
  ATH_CHECK( m_rawChannelContainerKey.initialize() );
 
  ATH_MSG_INFO( "TileL2Builder initialization completed" );
 
  return StatusCode::SUCCESS;
}

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ interfaceID()

const InterfaceID & TileL2Builder::interfaceID ( )

static

Definition at line 48 of file TileL2Builder.cxx.

                                              {
  return IID_ITileL2Builder;
}

◆ MaskBad()

void TileL2Builder::MaskBad	(	int	partition,
		float *	E,
		int *	gain,
		bool *	bad ) const

function which does bad channel masking: if one channel of a cell is bad, energy from second channel is taken if both channels are bad, zero energy is assigned to both channels

Parameters

partition	partition (1=LBA, 2=LBC, 3=EBA, 4=EBC)
E	energy for all channels - on return it will contain corrected values
gain	gain for all channels - on return it will contain corrected values
bad	bad flag for all channels

Definition at line 754 of file TileL2Builder.cxx.

                                                                          {
  for (int i = 0; i < 48; ++i) {
    if (bad[i]) {
      int j = m_channelPairs[ros - 1][i];
      if (bad[j]) { // both bad or i=j (i.e. single channel)
        E[i] = E[j] = 0.0;
        gain[i] = gain[j] = -1;
      } else {
        E[i] = E[j]; // copy from second channel
        gain[i] = gain[j];
      }
    }
  }
  return;
}

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ MTagEB() [1/2]

void TileL2Builder::MTagEB	(	int	partition,
		int	drawer,
		float *	EMeV,
		int *	gain,
		bool *	bad,
		std::vector< float > &	EtaMuons,
		std::vector< float > &	EMuons0,
		std::vector< float > &	EMuons1,
		std::vector< float > &	EMuons2,
		std::vector< unsigned int > &	qf,
		std::vector< unsigned int > &	extraWord ) const

inline

Definition at line 139 of file TileL2Builder.h.

                                                                  {
      MaskBad(partition, EMeV, gain, bad);
      MTagEB(partition, drawer, EMeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
    }

◆ MTagEB() [2/2]

void TileL2Builder::MTagEB	(	int	partition,
		int	drawer,
		float *	EMeV,
		std::vector< float > &	EtaMuons,
		std::vector< float > &	EMuons0,
		std::vector< float > &	EMuons1,
		std::vector< float > &	EMuons2,
		std::vector< unsigned int > &	qf,
		std::vector< unsigned int > &	extraWord ) const

Muon tagging function for EB superdrawers as processed at the ROD DSPs.

Parameters

EMeV	Calibrated energy (in MeV) for all channels
EtaMuons	Muons eta coordinate
EMuons0	Energy (in MeV) deposited by the muons in A cells
EMuons1	Energy (in MeV) deposited by the muons in B cells
EMuons2	Energy (in MeV) deposited by the muons in D cells
qf	Quality factor
extraWord	Encoded 32-bit words with muon info

Definition at line 475 of file TileL2Builder.cxx.

                                                                      {
 
  // Maximum number of muons tagged per superdrawer
  int cut = 4;
 
  // Energy thresholds (MeV)
  int Eth_low = 150;
  int Eth_EB_A[4] = { 810, 1140, 1230, 1380 };
  int Eth_EB_BC[5] = { 1050, 1380, 1440, 1500, 1680 };
  int Eth_EB_D[2] = { 2100, 2370 };
 
  // Eta cells
  float eta_EB_A[4] = { 1.15, 1.25, 1.35, 1.45 };  // A12, A13, A14, A15
  float eta_EB_BC[5] = { 1.05, 1.15, 1.25, 1.35, 1.45 };  // B11, B12, B13, B14, B15
  float eta_EB_D[2] = { 1.00, 1.20 };  // D5, D6
 
  // D cells to B cells in EB
  int cell32[2 * 6] = {
      3, 0, 1, 2, 0, 0,  // D5 -> B11, B12, B13
      5, 0, 1, 2, 3, 4   // D6 -> B11, B12, B13, B14, B15
  };
 
  // B cells to A cells in EB
  int cell21[5 * 4] = {
      1, 0, 0, 0,  // B11 -> A12
      2, 0, 1, 0,  // B12 -> A12, A13
      3, 0, 1, 2,  // B13 -> A12, A13, A14
      3, 1, 2, 3,  // B14 -> A13, A14, A15
      2, 2, 3, 0   // B15 -> A14, A15
  };
 
  drawer = drawer % 2;
 
  int NMuons = 0;
  int quality;
  int pattern = 0;
 
  int k2, ks, ksto2, k1, ksto1;
  int cand = 0;
 
  unsigned int cquality[4] = { 0 };
  unsigned int flquality[4] = { 0 };
  unsigned int aquality[4] = { 0 };
 
  int eta[4] = { 0 };
  int splited[4] = { 0 };
  int found[4] = { 0 };
 
  float E_A[4];
  float E_BC[5];
  float E_D[2];
 
  /* A cells */
 
  E_A[0] = E[6] + E[7];   // A12
  E_A[1] = E[10] + E[11];  // A13
  E_A[2] = E[20] + E[21];  // A14
  E_A[3] = E[31] + E[32];  // A15
 
  /* B cells */
 
  E_BC[0] = E[8] + E[9];   // B11
  E_BC[1] = E[14] + E[15];  // B12
  E_BC[2] = E[22] + E[23];  // B13
  E_BC[3] = E[30] + E[35];  // B14
  E_BC[4] = E[36] + E[39];  // B15
 
  /* D cells */
 
  E_D[0] = E[16] + E[17];  // D5
  E_D[1] = E[37] + E[38];  // D6
 
  /* Define candidates */
 
  for (int i = 0; i < 2; i++) {  // loop over D cells
    if (E_D[i] >= Eth_low) {
      eta[cand] = i;
      splited[cand] = -1;
      cquality[cand] = E_D[i] < Eth_EB_D[i] ? 0 : 1;
      cand++;
    }
  }
 
  /* Repair for muons splitted */
 
  if (cand > 4) std::abort();
  for (int i = 0; i < cand; i++) {
    for (int j = 0; j < i; j++) {
      if ((cquality[i] + cquality[j]) == 0) {
        if (abs(eta[i] - eta[j]) <= 1
            && (E_D[eta[i]] + E_D[eta[j]])
                < (Eth_EB_D[eta[i]] > Eth_EB_D[eta[j]] ? Eth_EB_D[eta[i]] : Eth_EB_D[eta[j]])) {
 
          splited[i] = j;
        }
      } else if ((cquality[i] + cquality[j]) == 1) {
        if (abs(eta[i] - eta[j]) <= 1) {
          splited[i] = j;
        }
      }
    }
  }
 
  /* Loop on the candidates */
 
  for (int i = 0;
      (i < cand && splited[i] < 0) || ((i < cand && splited[i] >= 0) && found[splited[i]] == 0);
      i++) {
 
    found[i] = 0;
 
    ksto2 = cell32[6 * eta[i]];
 
    for (ks = 1; ks <= ksto2 && found[i] != 1; ks++) {
 
      // eta position BC cell with a muon candidate 
      k2 = cell32[6 * eta[i] + ks];
 
      // Lower threshold BC cells
      if (E_BC[k2] > Eth_low) {
 
        flquality[i] = (E_BC[k2] < Eth_EB_BC[k2] ? 0 : 1);
        ksto1 = cell21[4 * k2 + 0];
 
        for (int kp = 1; kp <= ksto1 && found[i] != 1; kp++) {
          k1 = cell21[4 * k2 + kp];
          if (E_A[k1] > Eth_low) {
            aquality[i] = (E_A[k1] < Eth_EB_A[k1] ? 0 : 1);
            quality = cquality[i] + flquality[i] + aquality[i];
            if (quality <= 1) {
              found[i] = 1;
 
              // energy deposited by the muon (A cell)
              EMuons0.push_back(E_A[k1]);
 
              // energy deposited by the muon (B cell)
              EMuons1.push_back(E_BC[k2]);
 
              // energy deposited by the muon (D cell)
              EMuons2.push_back(E_D[eta[i]]);
 
              // quality factor
              qf.push_back(cquality[i] + flquality[i] + aquality[i]);
 
              // EBC partition
              if (partition == 3)
                EtaMuons.push_back((eta_EB_D[eta[i]] + eta_EB_BC[k2] + eta_EB_A[k1]) * (1. / 3));
 
              // EBA partition
              if (partition == 4)
                EtaMuons.push_back(-(eta_EB_D[eta[i]] + eta_EB_BC[k2] + eta_EB_A[k1]) * (1. / 3));
 
              if (eta[i] == 0 && k2 == 0 && k1 == 0) pattern = 0;   // D5, B11, A12
              if (eta[i] == 0 && k2 == 1 && k1 == 0) pattern = 1;   // D5, B12, A12
              if (eta[i] == 0 && k2 == 1 && k1 == 1) pattern = 2;   // D5, B12, A13
              if (eta[i] == 0 && k2 == 2 && k1 == 0) pattern = 3;   // D5, B13, A12
              if (eta[i] == 0 && k2 == 2 && k1 == 1) pattern = 4;   // D5, B13, A13
              if (eta[i] == 0 && k2 == 2 && k1 == 2) pattern = 5;   // D5, B13, A14
              if (eta[i] == 1 && k2 == 0 && k1 == 0) pattern = 6;   // D6, B11, A12
              if (eta[i] == 1 && k2 == 1 && k1 == 0) pattern = 7;   // D6, B12; A12
              if (eta[i] == 1 && k2 == 1 && k1 == 1) pattern = 8;   // D6, B12; A13
              if (eta[i] == 1 && k2 == 2 && k1 == 0) pattern = 9;   // D6, B13, A12
              if (eta[i] == 1 && k2 == 2 && k1 == 1) pattern = 10;  // D6, B13, A13
              if (eta[i] == 1 && k2 == 2 && k1 == 2) pattern = 11;  // D6, B13, A14
              if (eta[i] == 1 && k2 == 3 && k1 == 1) pattern = 12;  // D6, B14, A13
              if (eta[i] == 1 && k2 == 3 && k1 == 2) pattern = 13;  // D6, B14, A14
              if (eta[i] == 1 && k2 == 3 && k1 == 3) pattern = 14;  // D6, B14, A15
              if (eta[i] == 1 && k2 == 4 && k1 == 2) pattern = 15;  // D6, B15, A14
              if (eta[i] == 1 && k2 == 4 && k1 == 3) pattern = 16;  // D6, B15, A15
 
              // Words with encoded muon information for one superdrawer
              unsigned int uquality = quality;
              extraWord.push_back( (uquality << 31)
                                   | (drawer << 30)
                                   | (pattern << 25)
                                   | ((int) (2 * E_D[eta[i]])));
 
              extraWord.push_back((((int) (2 * E_BC[k2])) << 16) | ((int) (2 * E_A[k1])));
 
              NMuons++;
 
            }
          }
        }
      }
    }
    if (NMuons >= cut) break;
  }
}

◆ MTagLB() [1/2]

void TileL2Builder::MTagLB	(	int	partition,
		int	drawer,
		float *	EMeV,
		int *	gain,
		bool *	bad,
		std::vector< float > &	EtaMuons,
		std::vector< float > &	EMuons0,
		std::vector< float > &	EMuons1,
		std::vector< float > &	EMuons2,
		std::vector< unsigned int > &	qf,
		std::vector< unsigned int > &	extraWord ) const

inline

Definition at line 104 of file TileL2Builder.h.

                                                                  {
      MaskBad(partition, EMeV, gain, bad);
      MTagLB(partition, drawer, EMeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
    }

◆ MTagLB() [2/2]

void TileL2Builder::MTagLB	(	int	partition,
		int	drawer,
		float *	EMeV,
		std::vector< float > &	EtaMuons,
		std::vector< float > &	EMuons0,
		std::vector< float > &	EMuons1,
		std::vector< float > &	EMuons2,
		std::vector< unsigned int > &	qf,
		std::vector< unsigned int > &	extraWord ) const

Muon tagging function for LB superdrawers as processed at the ROD DSPs.

Parameters

EMeV	Calibrated energy (in MeV) for all channels
EtaMuons	Muons eta coordinate
EMuons0	Energy (in MeV) deposited by the muons in A cells
EMuons1	Energy (in MeV) deposited by the muons in BC cells
EMuons2	Energy (in MeV) deposited by the muons in D cells
qf	Quality factor
extraWord	Encoded 32-bit words with muon info

Definition at line 291 of file TileL2Builder.cxx.

                                                                      {
 
  // Maximum number of muons tagged per superdrawer
  int cut = 4;
 
  // Energy thresholds (MeV)
  int Eth_low = 150;
  int Eth_LB_A[8] = { 1350, 960, 870, 750, 840, 840, 930, 840 };
  int Eth_LB_BC[8] = { 2550, 1980, 1770, 1890, 1860, 1800, 1890, 1860 };
  int Eth_LB_D[4] = { 1590, 1110, 1050, 1050 };
 
  // Eta cells
  float eta_LB_A[8] = { 0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75 }; // A1, A2, A3, A4, A5, A6, A7, A8
  float eta_LB_BC[8] = { 0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75 }; // BC1, BC2, BC3, BC4, BC5, BC6, BC7, BC8
  float eta_LB_D[4] = { 0.00, 0.20, 0.40, 0.60 };  // D0, D1, D2, D3
 
  // D cells to BC cells in LB
  int cell32[4 * 4] = {
      1, 0, 0, 0,  // D0 -> BC1
      2, 1, 2, 0,  // D1 -> BC2, BC3
      3, 3, 4, 5,  // D2 -> BC4, BC5, BC6
      3, 5, 6, 7   // D3 -> BC6, BC7, BC8
  };
 
  drawer = drawer % 2;
 
  int NMuons = 0;
  int quality;
  int pattern = 0;
 
  int k2, ks, ksto2;
  int cand = 0;
 
  unsigned int cquality[4] = { 0 };
  unsigned int flquality[4] = { 0 };
  unsigned int aquality[4] = { 0 };
 
  int eta[4] = { 0 };
  int splited[4] = { 0 };
  int found[4] = { 0 };
 
  float E_A[8];
  float E_BC[8];
  float E_D[4];
 
  /* A cells */
 
  E_A[0] = E[1] + E[4];   // A1
  E_A[1] = E[5] + E[8];   // A2
  E_A[2] = E[9] + E[10];  // A3
  E_A[3] = E[15] + E[18];  // A4
  E_A[4] = E[19] + E[20];  // A5
  E_A[5] = E[23] + E[26];  // A6
  E_A[6] = E[29] + E[32];  // A7
  E_A[7] = E[35] + E[38];  // A8
 
  /* BC cells */
 
  E_BC[0] = E[2] + E[3];   // BC1
  E_BC[1] = E[6] + E[7];   // BC2
  E_BC[2] = E[11] + E[12];  // BC3
  E_BC[3] = E[16] + E[17];  // BC4
  E_BC[4] = E[21] + E[22];  // BC5
  E_BC[5] = E[28] + E[27];  // BC6
  E_BC[6] = E[34] + E[33];  // BC7
  E_BC[7] = E[40] + E[39];  // BC8
 
  /* D cells */
 
  E_D[0] = E[0] * 2;         // D0
  E_D[1] = E[13] + E[14];  // D1
  E_D[2] = E[24] + E[25];  // D2
  E_D[3] = E[41] + E[44];  // D3
 
  /* Define candidates */
 
  for (int i = 0; i < 4; i++) {  // loop over D cells
    if (E_D[i] >= Eth_low) {
      eta[cand] = i;
      splited[cand] = -1;
      cquality[cand] = E_D[i] < Eth_LB_D[i] ? 0 : 1;
      cand++;
    }
  }
 
  /* Repair for muons splitted */
 
  if (cand > 4) std::abort();
  for (int i = 0; i < cand; i++) {
    for (int j = 0; j < i; j++) {
      if ((cquality[i] + cquality[j]) == 0) {
        if (abs(eta[i] - eta[j]) <= 1
            && (E_D[eta[i]] + E_D[eta[j]])
                < (Eth_LB_D[eta[i]] > Eth_LB_D[eta[j]] ? Eth_LB_D[eta[i]] : Eth_LB_D[eta[j]])) {
 
          splited[i] = j;
 
        }
      } else if ((cquality[i] + cquality[j]) == 1) {
 
        if (abs(eta[i] - eta[j]) <= 1) {
 
          splited[i] = j;
 
        }
      }
    }
  }
 
  /* Loop on the candidates */
 
  for (int i = 0;
      (i < cand && splited[i] < 0) || ((i < cand && splited[i] >= 0) && found[splited[i]] == 0);
      i++) {
 
    found[i] = 0;
    ksto2 = cell32[4 * eta[i]];
 
    for (ks = 1; ks <= ksto2 && found[i] != 1; ks++) {
 
      // eta position BC cell with a muon candidate 
      k2 = cell32[4 * eta[i] + ks];
 
      // Lower threshold BC cells
      if (E_BC[k2] > Eth_low) {
        flquality[i] = (E_BC[k2] < Eth_LB_BC[k2] ? 0 : 1);
        if (found[i] != 1 && E_A[k2] > Eth_low) {
          aquality[i] = (E_A[k2] < Eth_LB_A[k2] ? 0 : 1);
          quality = cquality[i] + flquality[i] + aquality[i];
          if (quality <= 1) {
            found[i] = 1;
 
            // energy deposited by the muon (A cell)
            EMuons0.push_back(E_A[k2]);
 
            // energy deposited by the muon (BC cell)
            EMuons1.push_back(E_BC[k2]);
 
            // energy deposited by the muon (D cell)
            EMuons2.push_back(E_D[eta[i]]);
 
            // quality factor
            qf.push_back(cquality[i] + flquality[i] + aquality[i]);
 
            // LBC partition
            if (partition == 1)
              EtaMuons.push_back((eta_LB_D[eta[i]] + eta_LB_BC[k2] + eta_LB_A[k2]) * (1. / 3));
 
            // LBA partition
            if (partition == 2)
              EtaMuons.push_back(-(eta_LB_D[eta[i]] + eta_LB_BC[k2] + eta_LB_A[k2]) * (1. / 3));
 
            if (eta[i] == 0 && k2 == 0) pattern = 0;  // D0, BC1, A1
            if (eta[i] == 1 && k2 == 1) pattern = 1;  // D1, BC2, A2
            if (eta[i] == 1 && k2 == 2) pattern = 2;  // D1, BC3, A3
            if (eta[i] == 2 && k2 == 3) pattern = 3;  // D2, BC4, A4
            if (eta[i] == 2 && k2 == 4) pattern = 4;  // D2, BC5, A5
            if (eta[i] == 2 && k2 == 5) pattern = 5;  // D2, BC6, A6
            if (eta[i] == 3 && k2 == 5) pattern = 6;  // D3, BC6, A6
            if (eta[i] == 3 && k2 == 6) pattern = 7;  // D3, BC7, A7
            if (eta[i] == 3 && k2 == 7) pattern = 8;  // D3, BC8, A8
 
            // Words with encoded muon information for one superdrawer
            unsigned int uquality = quality;
            extraWord.push_back( (uquality << 31) | (drawer << 30) | (pattern << 25) | ((int) (2 * E_D[eta[i]])));
            extraWord.push_back((((int) (2 * E_BC[k2])) << 16) | ((int) (2 * E_A[k2])));
 
            NMuons++;
          }
        }
      }
    }
    if (NMuons >= cut) break;
  }
}

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

◆ process() [1/2]

StatusCode TileL2Builder::process	(	int	fragmin,
		int	fragmax,
		TileL2Container *	l2Container ) const

virtual

Definition at line 166 of file TileL2Builder.cxx.

                                                                                              {
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  return process(fragmin, fragmax, l2Container, ctx);
};

◆ process() [2/2]

StatusCode TileL2Builder::process	(	int	fragmin,
		int	fragmax,
		TileL2Container *	l2Container,
		const EventContext &	ctx ) const

virtual

Definition at line 171 of file TileL2Builder.cxx.

                                                                                                                       {
 
  SG::ReadCondHandle<TileEMScale> emScale(m_emScaleKey, ctx);
  ATH_CHECK( emScale.isValid() );
 
  SG::ReadCondHandle<TileBadChannels> badChannels(m_badChannelsKey, ctx);
  ATH_CHECK( badChannels.isValid() );
 
  // Get TileRawChannels
  SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(m_rawChannelContainerKey, ctx);
  ATH_CHECK( rawChannelContainer.isValid() );
 
  std::vector<unsigned int> extraWord;
  std::vector<float> EtaMuons;
  std::vector<float> EMuons0;
  std::vector<float> EMuons1;
  std::vector<float> EMuons2;
  std::vector<unsigned int> qf;
 
  float E_MeV[48];
  bool bad[48];
  int gain[48];
 
  TileRawChannelUnit::UNIT rChUnit = rawChannelContainer->get_unit();
  bool dspCont = (rChUnit >= TileRawChannelUnit::OnlineOffset);
  bool recalibrate = (rChUnit != TileRawChannelUnit::MegaElectronVolts
                      && rChUnit != TileRawChannelUnit::OnlineMegaElectronVolts);
 
  // iterate over all collections in a container
  for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
 
    HWIdentifier drawer_id = m_tileHWID->drawer_id(rawChannelCollection->identify());
    int ros = m_tileHWID->ros(drawer_id);
    int drawer = m_tileHWID->drawer(drawer_id);
    int fragId = m_tileHWID->frag(ros, drawer);
    int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
    if ((fragId >= fragmin) && (fragId <= fragmax)) {
 
      ATH_MSG_VERBOSE( "Unpacking frag 0x" << MSG::hex << fragId << MSG::dec );
 
      memset(E_MeV, 0, sizeof(E_MeV));
      memset(bad, 0, sizeof(bad));
      memset(gain, -1, sizeof(gain));
 
      // iterate over all raw channels in a collection
      for (const TileRawChannel* rawChannel : *rawChannelCollection) {
        HWIdentifier adc_id = rawChannel->adc_HWID();
        int channel = m_tileHWID->channel(adc_id);
        int adc = m_tileHWID->adc(adc_id);
        float ampl = rawChannel->amplitude();
        if (recalibrate) {
          E_MeV[channel] = emScale->calibrateChannel(drawerIdx, channel, adc, ampl, rChUnit
                                                     , TileRawChannelUnit::MegaElectronVolts);
        } else {
          E_MeV[channel] = ampl; // no conversion since energy is in MeV already
        }
        if (dspCont) {
          bad[channel] = rawChannel->quality() > 15.99;
        } else {
          bad[channel] = badChannels->getAdcStatus(adc_id).isBad();
        }
        gain[channel] = adc;
      }
 
      // bad channel masking
      MaskBad(ros, E_MeV, gain, bad);
 
      // MET
      std::vector<float> sumE(3);
      SumE(ros, drawer, TileRawChannelUnit::MegaElectronVolts, E_MeV, gain, sumE);
      (*l2Container)[m_hashFunc(fragId)]->setEt(std::move(sumE));
 
      // MTag
 
      EtaMuons.clear();
      EMuons0.clear();
      EMuons1.clear();
      EMuons2.clear();
      qf.clear();
      extraWord.clear();
 
      switch (ros) {
        case TileHWID::BARREL_POS:
          MTagLB(ros, drawer, E_MeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
          break;
        case TileHWID::BARREL_NEG:
          MTagLB(ros, drawer, E_MeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
          break;
        case TileHWID::EXTBAR_POS:
          MTagEB(ros, drawer, E_MeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
          break;
        case TileHWID::EXTBAR_NEG:
          MTagEB(ros, drawer, E_MeV, EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
          break;
        default:
          ATH_MSG_ERROR( "incorrect ros value " << ros );
          break;
      }
 
      if (EtaMuons.size())
        (*l2Container)[m_hashFunc(fragId)]->setMu(EtaMuons, EMuons0, EMuons1, EMuons2, qf, extraWord);
 
    } // end loop over collections
 
  }
 
  // Execution completed
  ATH_MSG_DEBUG( "TileL2Builder execution completed" );
 
  return StatusCode::SUCCESS;
}

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ SumE() [1/3]

void TileL2Builder::SumE	(	int	partition,
		int	drawer,
		float *	E,
		std::vector< float > &	sumE ) const

SumE function for one superdrawer as processed at the ROD DSPs.

Parameters

partition	partition (1=LBA, 2=LBC, 3=EBA, 4=EBC)
drawer	drawer number (0-63)
unit	energy units (0=ADC counts, 3=MeV) for proper rounding a-la DSP
E	energy for all channels in some units
gain	gain for all channels
bad	bad flag for all channels
sumE	sumEt, sumEz and sumE for the drawer in one vector

Definition at line 721 of file TileL2Builder.cxx.

                                                                               {
  if (ros < 1 || ros > 4) {
    sumE[0] = sumE[1] = sumE[2] = 0.0;
    return;
  }
 
  int ros1 = ros - 1;
  const float* wt = m_sinTh[ros1];
  const float* wz = m_cosTh[ros1];
  const bool* connected = m_connected[ros1];
  float Et = 0.0;
  float Ez = 0.0;
  float Es = 0.0;
 
  for (int i = 0; i < 48; ++i) {
    if (*connected++) {
      float e = (*E); // assuming that E is in MeV
      if (e > m_noiseThreshold) { // for the moment only fixed noise cut implemented
        Et += e * (*wt);
        Ez += e * (*wz);
        Es += e;
      }
    }
    ++E;
    ++wt;
    ++wz;
  }
 
  sumE[0] = Et;
  sumE[1] = Ez;
  sumE[2] = Es;
}

◆ SumE() [2/3]

void TileL2Builder::SumE	(	int	partition,
		int	drawer,
		int	unit,
		float *	E,
		int *	gain,
		bool *	bad,
		std::vector< float > &	sumE ) const

inline

Definition at line 166 of file TileL2Builder.h.

                                                    {
      MaskBad(partition, E, gain, bad);
      SumE(partition, drawer, unit, E, gain, sumE);
    }

◆ SumE() [3/3]

void TileL2Builder::SumE	(	int	partition,
		int	drawer,
		int	unit,
		float *	E,
		int *	gain,
		std::vector< float > &	sumE ) const

Definition at line 673 of file TileL2Builder.cxx.

                                  {
  // precision in DSP - 1/16 ADC counts or 1/2048 pC and CspC  or 1/2 MeV
  static const float AMPLITUDE_FACTOR_HG[4] = { 16.0, 32.0 * 64, 32.0 * 64., 2.0 };
  static const float AMPLITUDE_FACTOR_LG[4] = { 16.0, 32.0, 32.0, 2.0 / 64.0 };
 
  if (ros < 1 || ros > 4) {
    sumE[0] = sumE[1] = sumE[2] = 0.0;
    return;
  }
 
  unit &= 3; // keep last 2 bits, remove online offset
  const float scaleHG = AMPLITUDE_FACTOR_HG[unit];
  const float scaleLG = AMPLITUDE_FACTOR_LG[unit];
  int ros1 = ros - 1;
  const float* wt = m_sinThRound[ros1];
  const float* wz = m_cosThRound[ros1];
  const bool* connected = m_connected[ros1];
 
  float Et = 0.0;
  float Ez = 0.0;
  float Es = 0.0;
 
  // for the moment only fixed noise cut implemented
  // and it works correctly only if energy is in MeV
  float cut = m_noiseThreshold * scaleHG;
 
  for (int i = 0; i < 48; ++i) {
    if (*connected++) {
      float e = (*gain) ? round((*E) * scaleHG) : round((*E) * scaleLG) * 64.;
      if (e > cut) {
        Et += round((*wt) * e);
        Ez += round((*wz) * e);
        Es += round(e);
      }
    }
    ++E;
    ++gain;
    ++wt;
    ++wz;
  }
 
  const float inv_scaleHG = 1. / scaleHG;
  sumE[0] = Et * inv_scaleHG;
  sumE[1] = Ez * inv_scaleHG;
  sumE[2] = Es * inv_scaleHG;
}

◆ sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_badChannelsKey

SG::ReadCondHandleKey<TileBadChannels> TileL2Builder::m_badChannelsKey

protected

Initial value:

{this,

"TileBadChannels", "TileBadChannels", "Input Tile bad channel status"}

Name of TileBadChannels in condition store.

Definition at line 201 of file TileL2Builder.h.

201 {this,

202 "TileBadChannels", "TileBadChannels", "Input Tile bad channel status"};

◆ m_channelPairs

int TileL2Builder::m_channelPairs[4][48] {}

protected

Definition at line 212 of file TileL2Builder.h.

212{};

◆ m_connected

bool TileL2Builder::m_connected[4][48] {}

protected

Definition at line 211 of file TileL2Builder.h.

211{};

◆ m_cosTh

float TileL2Builder::m_cosTh[4][48] {}

protected

Definition at line 209 of file TileL2Builder.h.

209{};

◆ m_cosThRound

float TileL2Builder::m_cosThRound[4][48] {}

protected

Definition at line 210 of file TileL2Builder.h.

210{};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_emScaleKey

SG::ReadCondHandleKey<TileEMScale> TileL2Builder::m_emScaleKey

protected

Initial value:

{this,

"TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"}

Name of TileEMScale in condition store.

Definition at line 195 of file TileL2Builder.h.

195 {this,

196 "TileEMScale", "TileEMScale", "Input Tile EMS calibration constants"};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_hashFunc

TileFragHash TileL2Builder::m_hashFunc

protected

Definition at line 205 of file TileL2Builder.h.

◆ m_noiseThreshold

float TileL2Builder::m_noiseThreshold

protected

Definition at line 186 of file TileL2Builder.h.

◆ m_noiseType

int TileL2Builder::m_noiseType

protected

Definition at line 187 of file TileL2Builder.h.

◆ m_rawChannelContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileL2Builder::m_rawChannelContainerKey

protected

Initial value:

{this,"TileRawChannelContainer",
                                                                        "TileRawChannelCnt",
                                                                        "Input Tile raw channel container key"}

TileRawChannelContainer in event store.

Definition at line 181 of file TileL2Builder.h.

                                                                     {this,"TileRawChannelContainer",
                                                                        "TileRawChannelCnt",
                                                                        "Input Tile raw channel container key"};

◆ m_sinTh

float TileL2Builder::m_sinTh[4][48] {}

protected

Definition at line 207 of file TileL2Builder.h.

207{};

◆ m_sinThRound

float TileL2Builder::m_sinThRound[4][48] {}

protected

Definition at line 208 of file TileL2Builder.h.

208{};

◆ m_tileHWID

const TileHWID* TileL2Builder::m_tileHWID

protected

Pointer to TileHWID.

Definition at line 190 of file TileL2Builder.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TileL2Builder()

◆ ~TileL2Builder()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ idToIndex()

◆ indexToId()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ MaskBad()

◆ msg()

◆ msgLvl()

◆ MTagEB() [1/2]

◆ MTagEB() [2/2]

◆ MTagLB() [1/2]

◆ MTagLB() [2/2]

◆ outputHandles()

◆ process() [1/2]

◆ process() [2/2]

◆ renounce()

◆ renounceArray()

◆ SumE() [1/3]

◆ SumE() [2/3]

◆ SumE() [3/3]

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_badChannelsKey

◆ m_channelPairs

◆ m_connected

◆ m_cosTh

◆ m_cosThRound

◆ m_detStore

◆ m_emScaleKey

◆ m_evtStore

◆ m_hashFunc

◆ m_noiseThreshold

◆ m_noiseType

◆ m_rawChannelContainerKey

◆ m_sinTh

◆ m_sinThRound

◆ m_tileHWID

◆ m_varHandleArraysDeclared

◆ m_vhka