EgammaReSamp1Fex Class Reference

Feature extraction Tool for LVL2 Calo. More...

#include <EgammaReSamp1Fex.h>

Inheritance diagram for EgammaReSamp1Fex:

Collaboration diagram for EgammaReSamp1Fex:

Public Member Functions
	EgammaReSamp1Fex (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	execute (xAOD::TrigEMCluster &rtrigEmCluster, const IRoiDescriptor &roi, const CaloDetDescrElement *&caloDDE, const EventContext &context) const override
	execute feature extraction for the EM Calorimeter second layer
virtual StatusCode	initialize () override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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
const CaloIdManager *	m_larMgr = nullptr
	Calorimeter Id Manager for calorimeter part determination (Barrel versus EndCap)
Gaudi::Property< bool >	m_saveCells
Gaudi::Property< float >	m_cellkeepthr
ToolHandle< IT2GeometryTool >	m_geometryTool
ServiceHandle< ITrigCaloDataAccessSvc >	m_dataSvc

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

Feature extraction Tool for LVL2 Calo.

First EM Calorimeter sample.

Definition at line 28 of file EgammaReSamp1Fex.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

EgammaReSamp1Fex()

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

Definition at line 30 of file EgammaReSamp1Fex.cxx.

                                                             :
    IReAlgToolCalo(type, name, parent)
{}

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.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode EgammaReSamp1Fex::execute ( xAOD::TrigEMCluster & rtrigEmCluster, const IRoiDescriptor & roi, const CaloDetDescrElement *& caloDDE, const EventContext & context ) const

overridevirtual

execute feature extraction for the EM Calorimeter second layer

Parameters

[out]	rtrigEmCluster	is the output cluster.
[in]	eta/phi-min/max	= RoI definition.

Implements IReAlgToolCalo.

Definition at line 35 of file EgammaReSamp1Fex.cxx.

{
  bool cluster_in_barrel = true;
  if (caloDDE) cluster_in_barrel = caloDDE->is_lar_em_barrel();
 
  ATH_MSG_DEBUG("in execute(TrigEMCluster &)");
 
  // Region Selector, sampling 1
  int sampling = 1;
 
  LArTT_Selector<LArCellCont> sel;
  ATH_CHECK( m_dataSvc->loadCollections(context, roi, TTEM, sampling, sel) );
 
  double totalEnergy = 0;
  double etaEnergyS1 = 0;
  CaloSampling::CaloSample samp;
 
  double energyEta = rtrigEmCluster.eta();
  double energyPhi = rtrigEmCluster.phi();
  if (caloDDE) {
    energyEta = caloDDE->eta();
    energyPhi = caloDDE->phi();
  }
 
  // begin SRA mod: set regions via LAr way
 
  // Fix for 3x7 cluster size
  double z_etamin = energyEta - (0.075 / 2.); // 3 middle layer cells (cell size 0.025) half distance (hence /2)
  double z_etamax = energyEta + (0.075 / 2.); // 
  // in phi, the cluster size uses 7 cells of size {2*pi/64=(0.09817477)}/4 (middle layer cell size)
  double z_phimin = energyPhi - (7.0 * 0.09817477 / 4.0) / 2.0; 
  double z_phimax = energyPhi + (7.0 * 0.09817477 / 4.0) / 2.0;
  // Fix for 5x5 clusters
  if (!cluster_in_barrel) {
    z_etamin = energyEta - (0.125 / 2.); // see comments above, endcap cluster is 5x5
    z_etamax = energyEta + (0.125 / 2.);
    z_phimin = energyPhi - (5.0 * 0.09817477 / 4.0) / 2.0;
    z_phimax = energyPhi + (5.0 * 0.09817477 / 4.0) / 2.0;
  }
 
  double z_eta = z_etamin + (z_etamax - z_etamin) * 0.5;
  double z_phi = z_phimin + (z_phimax - z_phimin) * 0.5;
 
  // Make sure these boundaries are valid
 
  if (z_etamin < -2.4) z_etamin = -2.4;
  if (z_etamin < -1.4 && z_etamin > -1.5) z_etamin = -1.4;
  if (z_etamin > 1.4 && z_etamin < 1.5) z_etamin = 1.5;
 
  if (z_etamax > 2.4) z_etamax = 2.4;
  if (z_etamax < -1.4 && z_etamax > -1.5) z_etamax = -1.5;
  if (z_etamax > 1.4 && z_etamax < 1.5) z_etamax = 1.4;
 
  bool signals = false;
  if ((z_etamin < 0) && (z_etamax > 0)) signals = true;
 
  // identify region in which the detector change granularity for this layer
  // and we have to compensate. This is documented in LAr TDR
  double etareg[6] = {-2.4, -2.0, -1.8, 1.8, 2.0, 2.4};
  double etagra[5] = {0.025 / 4, 0.025 / 6, 0.025 / 8, 0.025 / 6, 0.025 / 4};
  int imax = -9;
  int icrk = 1;
  double dgra = 0.;
  // find the region, and check if the eta range cross region.
  for (int ir = 0; ir < 5; ir++) {
    // make sure you're not outside acceptance of 2.4
    if (std::abs(z_eta) < 2.4 && z_eta >= etareg[ir] && z_eta <= etareg[ir + 1]) {
      dgra = etagra[ir];
      imax = ir;
      if (z_etamin >= etareg[ir] && z_etamax <= etareg[ir + 1]) icrk = 0;
    }
  }
  const double inv_dgra = dgra != 0 ? 1. / dgra : 1;
 
  // begin SRA mod: pick the eta around which to scan
  int strip_border;
  double etanew;
  double aeta = std::abs(z_eta);
  if (aeta <= 1.4) {
    strip_border = (int)rint(aeta * inv_dgra);
    // this is -0.5 in atrecon: qgcshap.F ..   Makes more sense to be +0.5
    etanew = ((double)strip_border - 0.5) * dgra;
  }
  if (aeta <= 1.5) {
    etanew = -99.;
  }
  if (aeta <= 1.8) {
    strip_border = (int)rint(aeta * inv_dgra);
    // this is -0.5 in atrecon: qgcshap.F ..   Makes more sense to be +0.5
    etanew = ((double)strip_border - 0.5) * dgra;
  }
  else if (aeta <= 2.0) {
    strip_border = (int)rint((aeta - 1.8) * inv_dgra);
    etanew = 1.8 + ((double)strip_border - 0.5) * dgra;
  }
  else if (aeta <= 2.4) {
    strip_border = (int)rint((aeta - 2.0) * inv_dgra);
    etanew = 2.0 + ((double)strip_border - 0.5) * dgra;
  }
  else {
    etanew = -99.;
  }
 
  etanew = (z_eta < 0.) ? -etanew : etanew;
 
  // check border crossing.
  int ibin = 0;
  double dgra1 = 0.;
  int iadd = 0;
  if ((icrk == 1) && (imax != -9)) {
    if (imax > 0 && z_etamin > etareg[imax - 1] && z_etamin <= etareg[imax]) {
      dgra1 = etagra[imax - 1];
      ibin = (int)rint((etareg[imax] + 0.5 * dgra - etanew) * inv_dgra) + 20;
      iadd = 0;
    }
    else {
      if (imax < 4 && z_etamax > etareg[imax + 1] && z_etamax <= etareg[imax + 2]) {
        dgra1 = etagra[imax + 1];
        ibin = (int)rint((etareg[imax + 1] - 0.5 * dgra - etanew) * inv_dgra) + 20;
        iadd = 1;
      }
    }
    if (imax == 0) {
      dgra1 = etagra[0];
      ibin = (int)rint((etareg[0] + 0.5 * dgra - etanew) * inv_dgra) + 20;
      iadd = 1;
    }
    if (imax == 4) {
      dgra1 = etagra[4];
      ibin = (int)rint((etareg[5] - 0.5 * dgra - etanew) * inv_dgra) + 20;
      iadd = 0;
    }
  }
  const double inv_dgra1 = dgra1 != 0 ? 1. / dgra1 : 1;
 
  // end SRA mod
 
  double z_enecell[40]; // SRA
  double z_etacell[40]; // SRA
 
  for (int iii = 0; iii < 40; iii++) {
    z_enecell[iii] = 0.;
    z_etacell[iii] = 0.;
  }
 
  int ncells = 0;
 
  for (const LArCell* larcell : sel) { // Should be revised for London scheme
    ncells++;
    double etaCell = larcell->caloDDE()->eta_raw();
    double phiCell = larcell->phi();
    double energyCell = larcell->energy();
 
    if (std::abs(etanew) != 99.) {
 
      double eta_cell = etaCell; // SRA
      // double eta_cell = larcell->eta(); //SRA
 
      // begin SRA mod
      if (eta_cell >= z_etamin && eta_cell <= z_etamax) {
        // adjust for possible 2*pi offset.
        double phi_cell0 = larcell->phi();
        double phi_cell = proxim(phi_cell0, z_phi);
        if (phi_cell >= z_phimin && phi_cell <= z_phimax) {
          int ieta; // SRA
          if (icrk == 0) {
            // single region
            ieta = (int)rint((eta_cell - etanew) * inv_dgra) + 20;
            // correction for eta=0 spacing
            if (signals && eta_cell < 0)
              ieta = (int)rint((eta_cell - etanew + 0.007) * inv_dgra) + 20;
          }
          else {
            if (eta_cell > etareg[imax] && eta_cell < etareg[imax + 1]) {
              // same region
              ieta = (int)rint((eta_cell - etanew) * inv_dgra) + 20;
            }
            else {
              // different region
              ieta = (int)rint((eta_cell - etareg[imax + iadd] - (0.5 - iadd) * dgra1) *
                               inv_dgra1) +
                     ibin;
            }
          } //  icrk==0
 
          double z_e = energyCell;
 
          if (ieta >= 1 && ieta <= 40) {
            z_enecell[ieta - 1] += z_e;
            z_etacell[ieta - 1] = eta_cell;
          }
        } // phi range
      }   // eta range
          // end SRA mod
    }     // endif for veto of clusters in crack outside acceptance
 
    // Find the standard em cluster energy (3*7 cell, now sampling 1)
    double deta = std::abs(etaCell - energyEta);
    double dphi = std::abs(phiCell - energyPhi);
    if (dphi > M_PI) dphi = 2. * M_PI - dphi; // wrap (pi - 2pi)->(-pi - 0)
 
    bool condition37 = cluster_in_barrel && (deta <= 0.0375 && dphi <= 0.0875);
    bool condition55 = (!cluster_in_barrel) && (deta <= 0.0625 && dphi <= 0.0625);
 
    if (condition37 || condition55) {
      totalEnergy += energyCell;
      etaEnergyS1 += energyCell * etaCell;
      // samp = CaloSampling::getSampling(*larcell);
      samp = larcell->caloDDE()->getSampling();
      rtrigEmCluster.setEnergy(samp, rtrigEmCluster.energy(samp) + energyCell);
      rtrigEmCluster.setRawEnergy(samp, rtrigEmCluster.rawEnergy(samp) + energyCell);
    }
 
  } // end of loop over sampling 1
 
  // SRA mod: Emax!
  double z_emax = -999.0;
  int z_ncmax = -999;
  for (int ic = 0; ic < 40; ic++) {
    if (z_enecell[ic] > z_emax) {
      z_emax = z_enecell[ic];
      z_ncmax = ic;
    }
  }
 
  // Include now setWstot
  double wtot = 0.;
  double etot = 0.;
  double wstot = -9999.;
  double wstot_deta = (z_etamax - z_etamin) * 0.5;
  // cppcheck-suppress negativeIndex
  double eta_center = z_etacell[z_ncmax];
  if (caloDDE != 0) {
    eta_center = caloDDE->eta();
    wstot_deta = caloDDE->deta() * 2.5;
  }
 
  for (int ic = 0; ic < 40; ic++) {
    if ((z_etacell[ic] >= (eta_center - wstot_deta)) &&
        (z_etacell[ic] <= (eta_center + wstot_deta))) {
      wtot += z_enecell[ic] * (ic - z_ncmax) * (ic - z_ncmax);
      etot += z_enecell[ic];
    }
  }
  if (etot > 0) {
    wtot = wtot / etot;
    wstot = wtot > 0 ? sqrt(wtot) : -9999.;
  }
 
  // SRA mod: Emax2!
  // int z_ncsec1=0;
  double z_esec1 = -999.0; // energy of strip with second max 2
 
  double ecand1;
 
  for (int iic = 1; iic < 39; iic++) {
    if ((z_enecell[iic] > z_enecell[iic - 1]) && (z_enecell[iic] > z_enecell[iic + 1])) {
      if (iic != z_ncmax) {
        ecand1 = z_enecell[iic];
        if (ecand1 > z_esec1) {
          z_esec1 = ecand1;
          // z_ncsec1=iic;
        }
      }
    }
  }
 
  if ((z_emax + z_esec1) < 0.) z_emax = -(100. / 98.) * z_esec1;
 
  // do frac73 calculation: sum energies +-3 strips
  // and +-1 strip around highest energy strip
  double strip7 = 0.; // temporary variables to sum energy
  double strip3 = 0.;
  double frac73 = 0.; // (E7-E3)/E3 in layer 1
 
  // use Steve's array to calculate frac73    MW
  //
  int smax = z_ncmax;
  if (z_ncmax > 2 && z_ncmax < 37) {
    strip7 = z_enecell[smax - 3] + z_enecell[smax - 2] + z_enecell[smax - 1] + z_enecell[smax + 1] +
             z_enecell[smax + 2] + z_enecell[smax + 3] + z_enecell[smax];
    strip3 = z_enecell[smax - 1] + z_enecell[smax] + z_enecell[smax + 1];
  }
  else if (z_ncmax == 2) {
    strip7 = z_enecell[smax - 2] + z_enecell[smax - 1] + z_enecell[smax + 1] + z_enecell[smax + 2] +
             z_enecell[smax + 3] + z_enecell[smax];
    strip3 = z_enecell[smax - 1] + z_enecell[smax] + z_enecell[smax + 1];
  }
  else if (z_ncmax == 37) {
    strip7 = z_enecell[smax - 3] + z_enecell[smax - 2] + z_enecell[smax - 1] + z_enecell[smax + 1] +
             z_enecell[smax + 2] + z_enecell[smax];
    strip3 = z_enecell[smax - 1] + z_enecell[smax] + z_enecell[smax + 1];
  }
  else if (z_ncmax == 1) {
    strip7 = z_enecell[smax - 1] + z_enecell[smax + 1] + z_enecell[smax + 2] + z_enecell[smax + 3] +
             z_enecell[smax];
    strip3 = z_enecell[smax - 1] + z_enecell[smax] + z_enecell[smax + 1];
  }
  else if (z_ncmax == 38) {
    strip7 = z_enecell[smax - 3] + z_enecell[smax - 2] + z_enecell[smax - 1] + z_enecell[smax + 1] +
             z_enecell[smax];
    strip3 = z_enecell[smax - 1] + z_enecell[smax] + z_enecell[smax + 1];
  }
  strip3 > 1.e-6 ? // protect against small values of strip3
      frac73 = (strip7 - strip3) / strip3
                 : frac73 = 99.;
 
  // Update Cluster Variables
 
  rtrigEmCluster.setNCells(ncells + rtrigEmCluster.nCells());
  rtrigEmCluster.setEmaxs1(z_emax);
  rtrigEmCluster.setWstot(wstot);
  rtrigEmCluster.setE2tsts1(z_esec1);
  rtrigEmCluster.setFracs1(frac73);
  if (totalEnergy != 0.0)
    rtrigEmCluster.setEta1(etaEnergyS1 / totalEnergy);
  else
    rtrigEmCluster.setEta1(99.0);
  rtrigEmCluster.setRawEnergy(rtrigEmCluster.rawEnergy() + totalEnergy);
 
 
  return StatusCode::SUCCESS;
}

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

initialize()

StatusCode IReAlgToolCalo::initialize ( )

overridevirtualinherited

Reimplemented in RingerReFex.

Definition at line 25 of file IReAlgToolCalo.cxx.

{
  ATH_CHECK(detStore()->retrieve(m_larMgr));
  if (!m_dataSvc.empty()) ATH_CHECK(m_dataSvc.retrieve());
  ATH_CHECK(m_geometryTool.retrieve());
 
  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.

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);
  }

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.

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();
  }

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_cellkeepthr

Gaudi::Property<float> IReAlgToolCalo::m_cellkeepthr

protectedinherited

Initial value:

{this, "ThresholdKeepCells", 1e5,
                                       "Threshold to keep cells incontainer"}

Definition at line 63 of file IReAlgToolCalo.h.

                                    {this, "ThresholdKeepCells", 1e5,
                                       "Threshold to keep cells incontainer"};

m_dataSvc

ServiceHandle<ITrigCaloDataAccessSvc> IReAlgToolCalo::m_dataSvc

protectedinherited

Initial value:

{this, "trigDataAccessMT",
                                                  "TrigCaloDataAccessSvc/TrigCaloDataAccessSvc",
                                                  "Data Access for LVL2 Calo Algorithms in MT"}

Definition at line 70 of file IReAlgToolCalo.h.

                                                 {this, "trigDataAccessMT",
                                                  "TrigCaloDataAccessSvc/TrigCaloDataAccessSvc",
                                                  "Data Access for LVL2 Calo Algorithms in MT"};

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_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_geometryTool

ToolHandle<IT2GeometryTool> IReAlgToolCalo::m_geometryTool

protectedinherited

Initial value:

{
      this, "T2GeometryTool", "T2GeometryTool/T2GeometryTool",
      "Tool to check that a cells are contained in a given cluster"}

Definition at line 66 of file IReAlgToolCalo.h.

                                            {
      this, "T2GeometryTool", "T2GeometryTool/T2GeometryTool",
      "Tool to check that a cells are contained in a given cluster"};

m_larMgr

const CaloIdManager* IReAlgToolCalo::m_larMgr = nullptr

protectedinherited

Calorimeter Id Manager for calorimeter part determination (Barrel versus EndCap)

Definition at line 57 of file IReAlgToolCalo.h.

m_saveCells

Gaudi::Property<bool> IReAlgToolCalo::m_saveCells

protectedinherited

Initial value:

{this, "SaveCellsInContainer", false,
                                    "Enables saving of the RoI Calorimeter Cells in StoreGate"}

Definition at line 60 of file IReAlgToolCalo.h.

                                 {this, "SaveCellsInContainer", false,
                                    "Enables saving of the RoI Calorimeter Cells in StoreGate"};

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:

• EgammaReSamp1Fex.h
• EgammaReSamp1Fex.cxx