CaloFillRectangularCluster Class Reference

#include <CaloFillRectangularCluster.h>

Inheritance diagram for CaloFillRectangularCluster:

Collaboration diagram for CaloFillRectangularCluster:

Public Types
typedef std::array< std::pair< double, double >, 4 >	WindowArray_t
	Holds the per-layer window sizes.
typedef ToolWithConstants	base_class
	Shorthand for derived classes.
using	Context
	Convenient alias for the Context type.
using	Constant
	Alias for the Constant type.

Public Member Functions
	CaloFillRectangularCluster (const std::string &type, const std::string &name, const IInterface *parent)
	Standard Gaudi constructor.
virtual StatusCode	initialize () override
	Standard Gaudi initialize method.
virtual void	makeCorrection (const Context &myctx, xAOD::CaloCluster *cluster) const override
	CaloClusterCorrection virtual method.
void	makeCorrection (const EventContext &ctx, xAOD::CaloCluster *cluster) const
virtual void	get_seed (CaloClusterCorr::SamplingHelper &helper, const xAOD::CaloCluster *cluster, double &eta, double &phi) const
virtual StatusCode	setCaloCellContainerName (const std::string &name) override
	Change the name of the CaloCellContainer used by this tool.
virtual WindowArray_t	initWindows (const int neta, const int nphi, const double detas2, const double dphis2) const
	Set up layer-by-layer cluster window sizes.
virtual void	setsample (xAOD::CaloCluster *cluster, CaloSampling::CaloSample sampling, float em, float etam, float phim, float emax, float etamax, float phimax, float etas, float phis) const
virtual void	setenergy (xAOD::CaloCluster *cluster, float energy) const
StatusCode	execute (const EventContext &ctx, xAOD::CaloCluster *cluster) const override
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const
	Execute on an entire collection of clusters.
Context	context (const EventContext &ctx) const
	Create a Context object.
virtual void	writeConstants (std::ostream &stream, const std::string &name, const EventContext &ctx) const
	Dump method (for debugging)
virtual StatusCode	mergeConstants (CaloRec::ToolConstants &out, const EventContext &ctx) const override
	Merge our constants into out with the proper prefix.
virtual int	toolVersion () const
	Return the version number for this tool.
virtual const std::string &	toolType () const
	Return the name of the type of this tool.

Protected Attributes
double	m_deta0 = 0.0
	Cell window sizes in each sampling.
double	m_deta1 = 0.0
double	m_deta2 = 0.0
double	m_deta3 = 0.0
double	m_dphi0 = 0.0
double	m_dphi1 = 0.0
double	m_dphi2 = 0.0
double	m_dphi3 = 0.0
int	m_neta
	\(\eta\times\phi\) cluster size. These are properties.
int	m_nphi
bool	m_fill_cluster
	Fill-cluster flag.
bool	m_setRawState
	Property to tell if the raw energy, eta0 and phi0 should be saved as uncalibrated signal state.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

Private Member Functions
	CaloFillRectangularCluster ()=delete
	This isn't allowed.
void	makeCorrection1 (const EventContext &ctx, const CaloDetDescrManager &dd_man, CaloClusterCorr::SamplingHelper &helper, double eta, double phi, const CaloSampling::CaloSample samplings[4]) const
void	makeCorrection2 (const EventContext &ctx, const CaloDetDescrManager &dd_man, CaloClusterCorr::SamplingHelper &helper) const

Private Attributes
SG::ReadHandleKey< CaloCellContainer >	m_cellsName
	The StoreGate key for the container of our input cells.
SG::ReadCondHandleKey< CaloRec::ToolConstants >	m_DBHandle
	Handle to a ToolConstants conditions object.
StringProperty	m_prefix
	Prefix for finding our constants within the ToolConstants object.
ToolWithConstantsImpl	m_impl
	Internal implementation object.
Constant< int >	m_order
	Used to fix the ordering of tools when we're initializing from COOL based on a hierarchical tag.
Constant< bool >	m_isdummy
	If true, then this is a dummy tool that should not be executed.

Detailed Description

Definition at line 60 of file CaloFillRectangularCluster.h.

Member Typedef Documentation

base_class

typedef ToolWithConstants CaloUtils::ToolWithConstants< BASE >::base_class

inherited

Shorthand for derived classes.

Definition at line 450 of file ToolWithConstants.h.

Constant

using CaloUtils::ToolWithConstants< BASE >::Constant

inherited

Alias for the Constant type.

Definition at line 463 of file ToolWithConstants.h.

Context

using CaloUtils::ToolWithConstants< BASE >::Context

inherited

Convenient alias for the Context type.

Definition at line 458 of file ToolWithConstants.h.

WindowArray_t

typedef std::array<std::pair<double, double>, 4> CaloFillRectangularCluster::WindowArray_t

Holds the per-layer window sizes.

Definition at line 122 of file CaloFillRectangularCluster.h.

Constructor & Destructor Documentation

CaloFillRectangularCluster() [1/2]

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

Standard Gaudi constructor.

Parameters

type	The type of the tool.
name	The name of the tool.
parent	The parent algorithm of the tool.

Definition at line 781 of file CaloFillRectangularCluster.cxx.

    : CaloClusterCorrection(type, name, parent)
{ 
  // properties 
  declareProperty("eta_size",     m_neta = 5);
  declareProperty("phi_size",     m_nphi = 5);
  declareProperty("fill_cluster", m_fill_cluster = true);
  declareProperty("cells_name",   m_cellsName = "AllCalo");
  declareProperty("set_raw_state",m_setRawState=true);
}

CaloFillRectangularCluster() [2/2]

CaloFillRectangularCluster::CaloFillRectangularCluster ( )

privatedelete

This isn't allowed.

Member Function Documentation

context()

Context CaloUtils::ToolWithConstants< BASE >::context ( const EventContext & ctx ) const

inherited

Create a Context object.

This can then be passed to Constant::operator().

execute() [1/2]

StatusCode CaloClusterCorrection::execute ( const EventContext & ctx, xAOD::CaloCluster * cluster ) const

overrideinherited

Definition at line 53 of file CaloClusterCorrection.cxx.

{
  this->makeCorrection (context(ctx), cluster);
 
#if 0
  ATH_MSG_DEBUG( " ...... e, et " << cluster->e() << " " << cluster->et() << endmsg);
  ATH_MSG_DEBUG( " ...... eta, etaBE, etaSmp " << cluster->eta() << " " << cluster->etaBE(2) 
      << " " << cluster->etaSample(CaloSampling::EMB1) 
      << " " << cluster->etaSample(CaloSampling::EMB2) 
      << " " << cluster->etaSample(CaloSampling::EMB3) << endmsg);
  ATH_MSG_DEBUG( " ...... phi, phiBE, phiSmp " << cluster->phi() << " " << cluster->phiBE(2) 
      << " " << cluster->phiSample(CaloSampling::EMB1) 
      << " " << cluster->phiSample(CaloSampling::EMB2) 
      << " " << cluster->phiSample(CaloSampling::EMB3) << endmsg);
#endif
  
  return StatusCode::SUCCESS;
}

execute() [2/2]

StatusCode CaloClusterProcessor::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * collection ) const

inherited

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters.

This will iterate over all the clusters in collection and call execute on each one individually.

Parameters

collection	The container of clusters.
ctx	The event context.

This will iterate over all the clusters in collection and call execute on each one individually.

Definition at line 65 of file CaloClusterProcessor.cxx.

{
  for (xAOD::CaloCluster* clu : *collection) {
    ATH_CHECK( execute (ctx, clu) );
  }
  return StatusCode::SUCCESS;
}

get_seed()

void CaloFillRectangularCluster::get_seed ( CaloClusterCorr::SamplingHelper & helper, const xAOD::CaloCluster * cluster, double & eta, double & phi ) const

virtual

!!! NEW way of the endcap-shift treatment (same for barrel and endcap)

Reimplemented in CaloTopoEMlayers.

Definition at line 1153 of file CaloFillRectangularCluster.cxx.

{
  const CaloCell* max_et_cell = helper.max_et_cell();

  // a.b.c 2004 : for barrel, correct for the alignment before 
  //               comparing the Tower direction and the cell's
  // ( for Atlas the difference is null, but it's not true for TB )
  const CaloDetDescrElement* elt = max_et_cell->caloDDE();
  double phi_shift = elt->phi()-elt->phi_raw();
  double eta_shift = elt->eta()-elt->eta_raw();
  eta = cluster->eta0()+eta_shift;
  phi = CaloPhiRange::fix(cluster->phi0()+phi_shift);
 
  // Special case to handle a pathology seen at the edge of the calorimeter
  // with clusters with an eta size of 3.  The cluster size used for the SW
  // clustering is 5x5.  The SW clustering will find the window that contains
  // the maximum amount of energy.  So, suppose that there's a cluster
  // near the edge of the calorimeter such that the most energetic cell
  // is right at the edge of the calorimeter.  In this case, the SW clustering
  // is likely to position the seed cell two cells from the edge
  // (the next-to-next-to-last cell), as in that case, all 5 eta cells
  // are contained within the calorimeter.  But in that case, if we then
  // build a cluster of size 3 around this seed, then we'll be missing
  // the cell with the highest energy!  This will severely bias the
  // energy and eta measurements.
  //
  // So, what I'll do is this.  If the maximum cell is at the outer
  // edge of the (outer) EC and it is not within our eta window, then I'll
  // use the maximum cell position as the seed instead of what
  // the SW clustering gives.  I restrict this to the outer edge
  // of the EC to avoid any chance of changing the clustering results
  // in the bulk of the calorimeter.
  // Also do this if the maximum cell is on the edge of the inner endcap --- 
  // we can get the same effect.
  if ((elt->is_lar_em_endcap_inner() &&
       std::abs(elt->eta_raw()) - elt->deta() <
           elt->descriptor()->calo_eta_min()) ||
      (elt->is_lar_em_endcap_outer() &&
       std::abs(elt->eta_raw()) + elt->deta() >
           elt->descriptor()->calo_eta_max()))
  {
    // Max cell is at the edge.  Is it outside the window?
    if (std::abs (eta - elt->eta()) > helper.deta(2)/2) {
      // Yes --- change the seed.
      eta = elt->eta();
    }
  }
 
  // stay in the calo frame and do not cook for cluster on edge
  // (inputs are now 3x5 so there should not be problems anymore)
  eta = cluster->eta0();
  phi = CaloPhiRange::fix(cluster->phi0());
 
}

initialize()

StatusCode CaloFillRectangularCluster::initialize ( )

overridevirtual

Standard Gaudi initialize method.

Derived classes can extend this to change the sampling window sizes.

Reimplemented from CaloClusterCorrection.

Reimplemented in CaloTopoEMlayers.

Definition at line 801 of file CaloFillRectangularCluster.cxx.

{
  // The method from the base class.
  CHECK( CaloClusterCorrection::initialize() );
  if (!m_cellsName.key().empty()){
    CHECK( m_cellsName.initialize() );
  }
 
  ATH_CHECK(m_caloMgrKey.initialize());
  return StatusCode::SUCCESS;
}

initWindows()

CaloFillRectangularCluster::WindowArray_t CaloFillRectangularCluster::initWindows ( const int neta, const int nphi, const double detas2, const double dphis2 ) const

virtual

Set up layer-by-layer cluster window sizes.

Parameters

neta	Cluster eta size.
nphi	Cluster phi size.
detas2	Middle layer cell eta size.
detas2	Middle layer cell phi size.

Returns per-layer array of deta,dphi pairs.

Reimplemented in CaloTopoEMlayers.

Definition at line 1235 of file CaloFillRectangularCluster.cxx.

{
  CaloFillRectangularCluster::WindowArray_t w;
 
  // set up the sampling windows:
  w[0].first  = detas2*neta;
  w[0].second = dphis2*4;
 
  if (nphi >= 7)
    w[0].second *= 2;
  else
    w[0].second *= 1.5;
 
  w[1].first  = w[0].first;
  w[1].second = w[0].second;
 
  w[2].first  = detas2*neta;
  w[2].second = dphis2*nphi;
 
  w[3].first  = (2*detas2)*(0.5 + (neta/2.));
  w[3].second = w[2].second;
 
  return w;
}

makeCorrection() [1/2]

virtual void CaloFillRectangularCluster::makeCorrection ( const Context & myctx, xAOD::CaloCluster * cluster ) const

overridevirtual

CaloClusterCorrection virtual method.

Parameters

myctx	ToolWithConstants context.
cluster	The cluster on which to operate.

Implements CaloClusterCorrection.

makeCorrection() [2/2]

void CaloFillRectangularCluster::makeCorrection ( const EventContext & ctx, xAOD::CaloCluster * cluster ) const

inline

Definition at line 92 of file CaloFillRectangularCluster.h.

  {
    return makeCorrection (context(ctx), cluster);
  }

makeCorrection1()

void CaloFillRectangularCluster::makeCorrection1 ( const EventContext & ctx, const CaloDetDescrManager & dd_man, CaloClusterCorr::SamplingHelper & helper, double eta, double phi, const CaloSampling::CaloSample samplings[4] ) const

private

Definition at line 823 of file CaloFillRectangularCluster.cxx.

{
  // Do sampling 2.
  helper.calculate_and_set (eta, phi, 2, -1, samplings, true);
  // the etam and phim of the helper are now filled with etamr and phimr from the CaloLayerCalculator
  double eta2 = helper.etam();
  double phi2 = helper.phim();
  // Make sure that we have a seed. Assume the input cluster has a good (eta,phi)
  if (eta2 == -999.) eta2 = eta;
  if (phi2 == -999.) phi2 = phi;
 
  // Now do sampling 1; use the result from sampling 2 as the seed.
  helper.calculate_and_set (eta2, phi2, 1, -1, samplings);
  double eta1 = helper.etam();
  double phi1 = helper.phim();
  bool refine = true;
  if (eta1 == -999. || phi1 == -999.) {
    // Make sure that we have a seed. If eta,phi1 not OK, (e.g. deadOTX), take (eta2,phi2)
    if (eta1 == -999.) eta1 = eta2;
    if (phi1 == -999.) phi1 = phi2;
    refine = false;
  }
 
  // For some silly reason, we have TWO different sampling enums.
  // The clusters use one, the detector description uses the other.
  CaloCell_ID::CaloSample xsample;
  if (samplings[1] == CaloSampling::EMB1)
    xsample = CaloCell_ID::EMB1;
  else
    xsample = CaloCell_ID::EME1;
 
  // Now refine the eta position using +-1 strip around hot cell
  // This only makes sense if the previous step was OK 
  if (refine) {
    double detastr, dphistr;
    CaloClusterCorr::etaphi_range (dd_man,helper.etamax(), helper.phimax(),
                   xsample,
                   detastr, dphistr);
    
    if (detastr > 0 && dphistr > 0) {
      helper.calculate_cluster (helper.etamax(), helper.phimax(),
                detastr, dphistr, samplings[1]);
      
      if (helper.etam()!=-999.) {
        eta1 = helper.etam();
        double eta1r = helper.etareal();
        helper.cluster()->setEta(samplings[1], eta1r);
      }
    }
  }
 
  // Now do sampling 0 using the eta1 point: 
  helper.calculate_and_set (eta1, phi2, 0, 1, samplings);
 
  // Do for sampling 3 (using the sampling 2 seed).
  helper.calculate_and_set (eta2, phi2, 3, -1, samplings);
 
  // Crack;
  // Check if the cluster has TileGap3 sampling and avoid to calculate the TileGap3 energy twice
  if ( helper.cluster()->hasSampling(CaloSampling::TileGap3) && samplings[0]==CaloSampling::PreSamplerE )
  {
    //By default, use the original cell container
    const CaloCellContainer* cc = helper.cluster()->getCellLinks()->getCellContainer();
 
    //Leave the option to use a different cell container
    if (!m_cellsName.key().empty()) {
      SG::ReadHandle<CaloCellContainer> cchand (m_cellsName, ctx);
      if (!cchand.isValid()) {
        REPORT_ERROR(StatusCode::FAILURE)
          << "Can't retrieve cell container " << m_cellsName.key();
        return;
      }
      cc = cchand.cptr();
    }
    
    if(!cc) //cover the case when the cluster does not give a cell container and the name is empty
    {
      REPORT_ERROR(StatusCode::FAILURE)
        << "Can't find cell container; cluster does not give a cell container";
      return;
    }
 
    // Add up the tile scintillator energy in the region around the cluster.
    double eh_scint = 0;
    CaloCellContainer::const_iterator f_cell =
      cc->beginConstCalo(CaloCell_ID::TILE);
    CaloCellContainer::const_iterator l_cell =
      cc->endConstCalo(CaloCell_ID::TILE);
 
    for ( ; f_cell!=l_cell; ++f_cell)
    {
      const CaloCell* cell = (*f_cell) ;
 
      if (CaloCell_ID::TileGap3 == cell->caloDDE()->getSampling()) {
        // consider only E4 cell
        if( fabs(cell->eta()) < 1.4 || fabs(cell->eta()) > 1.6 ) continue;
        double phic = cell->phi();
        double etac = cell->eta();
 
        float diffeta = etac-eta2;
        float diffphi = phic-phi2;
        if (diffphi < -pi) diffphi += twopi;
        if (diffphi > pi)  diffphi -= twopi;
 
        if(fabs(diffeta)<deta && fabs(diffphi)<dphi){
          eh_scint += cell->e();
        }
      }
    }
    //Set the TileGap3 sampling energy to the cluster; Needed for MVA calibration
    helper.cluster()->setEnergy(CaloSampling::TileGap3,eh_scint);
 
    helper.cluster()->setEta(CaloSampling::TileGap3, eta2);
    helper.cluster()->setPhi(CaloSampling::TileGap3, phi2);
  }
}

makeCorrection2()

void CaloFillRectangularCluster::makeCorrection2 ( const EventContext & ctx, const CaloDetDescrManager & dd_man, CaloClusterCorr::SamplingHelper & helper ) const

private

Definition at line 954 of file CaloFillRectangularCluster.cxx.

{
 
  // Don't do anything if we don't have any cells.
  if (helper.empty())
    return;
 
  // Get the seed position of the cluster.
  CaloCluster* cluster = helper.cluster();
  double eta, phi;
  get_seed (helper, cluster, eta, phi);
  double aeta = fabs(eta);  
 
  // set the appropriate cluster size
  int neta = cluster->getClusterEtaSize();
  int nphi = cluster->getClusterPhiSize();
 
  if (m_neta != neta || m_nphi != nphi) {
     CaloCluster::ClusterSize oldSize = cluster->clusterSize();
     CaloCluster::ClusterSize newSize = oldSize;
     switch(oldSize) {
       case CaloCluster::SW_softe:
          break;
       case CaloCluster::SW_55ele:
       case CaloCluster::SW_35ele:
       case CaloCluster::SW_37ele:
          if (m_neta==5 && m_nphi==5) newSize=CaloCluster::SW_55ele;
          if (m_neta==3 && m_nphi==5) newSize=CaloCluster::SW_35ele;
          if (m_neta==3 && m_nphi==7) newSize=CaloCluster::SW_37ele;
          if (m_neta==7 && m_nphi==11) newSize=CaloCluster::SW_7_11;
          break;
       case CaloCluster::SW_55gam:
       case CaloCluster::SW_35gam:
       case CaloCluster::SW_37gam:
          if (m_neta==5 && m_nphi==5) newSize=CaloCluster::SW_55gam;
          if (m_neta==3 && m_nphi==5) newSize=CaloCluster::SW_35gam;
          if (m_neta==3 && m_nphi==7) newSize=CaloCluster::SW_37gam;
          if (m_neta==7 && m_nphi==11) newSize=CaloCluster::SW_7_11;
          break;
       case CaloCluster::SW_55Econv:
       case CaloCluster::SW_35Econv:
       case CaloCluster::SW_37Econv:
          if (m_neta==5 && m_nphi==5) newSize=CaloCluster::SW_55Econv;
          if (m_neta==3 && m_nphi==5) newSize=CaloCluster::SW_35Econv;
          if (m_neta==3 && m_nphi==7) newSize=CaloCluster::SW_37Econv;
          if (m_neta==7 && m_nphi==11) newSize=CaloCluster::SW_7_11;
          break;
       default:
          if (m_neta==5 && m_nphi==5) newSize=CaloCluster::SW_55ele;
          if (m_neta==3 && m_nphi==5) newSize=CaloCluster::SW_35ele;
          if (m_neta==3 && m_nphi==7) newSize=CaloCluster::SW_37ele;
          if (m_neta==7 && m_nphi==11) newSize=CaloCluster::SW_7_11;
          break;
     }
     cluster->setClusterSize(newSize);
  }
 
  // Lists of samplings in the barrel and endcap.
  static const CaloSampling::CaloSample samplings_b[4] = 
    { CaloSampling::PreSamplerB, CaloSampling::EMB1,
      CaloSampling::EMB2, CaloSampling::EMB3 };
  static const CaloSampling::CaloSample samplings_e[4] = 
    { CaloSampling::PreSamplerE, CaloSampling::EME1,
      CaloSampling::EME2, CaloSampling::EME3 };
 
  // We need to calculate sampling properties for barrel and endcap 
  // separately.
  // FIXME: the overlap with barrel should be checked!!
 
  //Now set the sampling pattern for this cluster
  //Can't set sampling variables w/o setting the sampling pattern before
  uint32_t samplingPattern_b=0xf;  //first four bits: The barrel sampling (PS to Back)
  uint32_t samplingPattern_e=0xf0; //bits 4-7: The EMEC samplings (PS to back)
  uint32_t samplingPattern=0;
 
  if (aeta < 1.6)
    samplingPattern |=samplingPattern_b;
 
  if (aeta > 1.3)
    samplingPattern |=samplingPattern_e;
 
  if (aeta > 1.37 && aeta < 1.63)
    samplingPattern |=(1<<(uint32_t)CaloSampling::TileGap3);
 
  cluster->setSamplingPattern(samplingPattern);
 
  // Barrel
  if (aeta < 1.6) {
    makeCorrection1 (ctx, dd_man,helper, eta, phi, samplings_b);
  }
 
  // Endcap
  if (aeta > 1.3) {
    makeCorrection1 (ctx, dd_man,helper, eta, phi, samplings_e);
  }
 
  // Set the total cluster energy to the sum over all samplings.
  double cl_ene = 0;
  for(int i=0; i<4; i++ ){
    cl_ene += cluster->eSample(samplings_b[i]);
    cl_ene += cluster->eSample(samplings_e[i]);
  }
  cluster->setE(cl_ene);
  
  if (m_setRawState) {
    cluster->setRawE(cl_ene);
    cluster->setRawEta(eta);
    cluster->setRawPhi(phi);
  }
 
}

mergeConstants()

virtual StatusCode CaloUtils::ToolWithConstants< BASE >::mergeConstants ( CaloRec::ToolConstants & out, const EventContext & ctx ) const

overridevirtualinherited

Merge our constants into out with the proper prefix.

Parameters

[out]	out	Object to receive our constants.
	ctx	Event context.

setCaloCellContainerName()

StatusCode CaloFillRectangularCluster::setCaloCellContainerName ( const std::string & name )

overridevirtual

Change the name of the CaloCellContainer used by this tool.

Parameters

name	The new container name.

Implements ISetCaloCellContainerName.

Definition at line 1218 of file CaloFillRectangularCluster.cxx.

{
  return this->setProperty (StringProperty ("cells_name", name));
}

setenergy()

void CaloClusterCorrection::setenergy ( xAOD::CaloCluster * cluster, float energy ) const

virtualinherited

Definition at line 94 of file CaloClusterCorrection.cxx.

{
  if (cluster->e() == 0) {
    if (energy != 0)
      REPORT_MESSAGE (MSG::WARNING)
        << "Attempt to rescale zero-energy cluster to energy " << energy
        << " ignored.";
    return;
  }
 
  float correction = energy/cluster->e();
  cluster->setE(energy);
 
  // also correct individual sampling energies:
 
  for (int iSample=CaloSampling::PreSamplerB; 
        iSample < CaloSampling::Unknown; 
       ++iSample) 
    {
      CaloSampling::CaloSample sampling=static_cast<CaloSampling::CaloSample>(iSample);
      if (cluster->hasSampling (sampling)) {
        double e = cluster->eSample(sampling);
        cluster->setEnergy(sampling,e*correction) ;
      }
  }
}

setsample()

void CaloClusterCorrection::setsample ( xAOD::CaloCluster * cluster, CaloSampling::CaloSample sampling, float em, float etam, float phim, float emax, float etamax, float phimax, float etas, float phis ) const

virtualinherited

Definition at line 74 of file CaloClusterCorrection.cxx.

{
  cluster->setEnergy(sampling, em);
  cluster->setEta(sampling, etam);
  cluster->setPhi(sampling, phim);
 
  cluster->setEmax(sampling,emax);
  cluster->setEtamax(sampling,etamax);
  cluster->setPhimax(sampling,phimax);
 
  cluster->setEtasize(sampling, etas);
  cluster->setPhisize(sampling, phis);
}

toolType()

virtual const std::string & CaloUtils::ToolWithConstants< BASE >::toolType ( ) const

virtualinherited

Return the name of the type of this tool.

A saved set of constants includes both the C++ class name and a version number. Normally, the class name is taken from the Gaudi type() method, but that may be changed by overriding this method. This can be used, for example, when there are tools with distinct C++ classes but which are yet similar enough to combine together.

Reimplemented in CaloSwEta1b_g3, CaloSwEta1e_g3, CaloSwEta2b_g3, and CaloSwEta2e_g3.

toolVersion()

virtual int CaloUtils::ToolWithConstants< BASE >::toolVersion ( ) const

virtualinherited

Return the version number for this tool.

A saved set of constants includes both the C++ class name and a version number. The idea is that the version number can be bumped whenever there's a backwards-incompatible change; this gives some protection against trying to use an old version of a tool with an incompatible newer set of constants.

If you want a tool to have a version number, override this method. Otherwise, it will default to a version number of 0.

writeConstants()

virtual void CaloUtils::ToolWithConstants< BASE >::writeConstants ( std::ostream & stream, const std::string & name, const EventContext & ctx ) const

virtualinherited

Dump method (for debugging)

Parameters

stream	Ostream to which to write.
name	Name to go in output
ctx	Event context.

Member Data Documentation

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloClusterCorrection::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

protectedinherited

Definition at line 83 of file CaloClusterCorrection.h.

{this,"CaloDetDescrManager", "CaloDetDescrManager"};

m_cellsName

SG::ReadHandleKey<CaloCellContainer> CaloFillRectangularCluster::m_cellsName

private

The StoreGate key for the container of our input cells.

This is a property.

Definition at line 195 of file CaloFillRectangularCluster.h.

m_DBHandle

SG::ReadCondHandleKey<CaloRec::ToolConstants> CaloUtils::ToolWithConstants< BASE >::m_DBHandle

privateinherited

Handle to a ToolConstants conditions object.

Definition at line 534 of file ToolWithConstants.h.

{ this, "DBHandleKey", "", "" };

m_deta0

double CaloFillRectangularCluster::m_deta0 = 0.0

protected

Cell window sizes in each sampling.

Definition at line 176 of file CaloFillRectangularCluster.h.

m_deta1

double CaloFillRectangularCluster::m_deta1 = 0.0

protected

Definition at line 176 of file CaloFillRectangularCluster.h.

m_deta2

double CaloFillRectangularCluster::m_deta2 = 0.0

protected

Definition at line 176 of file CaloFillRectangularCluster.h.

m_deta3

double CaloFillRectangularCluster::m_deta3 = 0.0

protected

Definition at line 176 of file CaloFillRectangularCluster.h.

m_dphi0

double CaloFillRectangularCluster::m_dphi0 = 0.0

protected

Definition at line 177 of file CaloFillRectangularCluster.h.

m_dphi1

double CaloFillRectangularCluster::m_dphi1 = 0.0

protected

Definition at line 177 of file CaloFillRectangularCluster.h.

m_dphi2

double CaloFillRectangularCluster::m_dphi2 = 0.0

protected

Definition at line 177 of file CaloFillRectangularCluster.h.

m_dphi3

double CaloFillRectangularCluster::m_dphi3 = 0.0

protected

Definition at line 177 of file CaloFillRectangularCluster.h.

m_fill_cluster

bool CaloFillRectangularCluster::m_fill_cluster

protected

Fill-cluster flag.

This is a property. If true, then we fill the cluster with cells from StoreGate. Otherwise, we use the cells already in the cluster.

Definition at line 185 of file CaloFillRectangularCluster.h.

m_impl

ToolWithConstantsImpl CaloUtils::ToolWithConstants< BASE >::m_impl

privateinherited

Internal implementation object.

Definition at line 542 of file ToolWithConstants.h.

{ this->name(), m_prefix, m_DBHandle };

m_isdummy

Constant<bool> CaloUtils::ToolWithConstants< BASE >::m_isdummy

privateinherited

If true, then this is a dummy tool that should not be executed.

This is used for the case of reading from COOL using hierarchical tags: we need to have such tags associated with some object in each folder, regardless of whether or not the correction from that folder is actually used. [Every folder that IOVDbSvc knows about at configuration time needs to have a valid object for the configured tag, else IOVDbSvc will raise a fatal error. But we don't know at configuration time which folders we're actually going to need, so we gotta configure all of them.]

Definition at line 560 of file ToolWithConstants.h.

{this, "isDummy", false };

m_neta

int CaloFillRectangularCluster::m_neta

protected

\(\eta\times\phi\) cluster size. These are properties.

Definition at line 180 of file CaloFillRectangularCluster.h.

m_nphi

int CaloFillRectangularCluster::m_nphi

protected

Definition at line 180 of file CaloFillRectangularCluster.h.

m_order

Constant<int> CaloUtils::ToolWithConstants< BASE >::m_order

privateinherited

Used to fix the ordering of tools when we're initializing from COOL based on a hierarchical tag.

Tools should be executed in order of increasing m_order.

Definition at line 547 of file ToolWithConstants.h.

{ this, "order", 0 };

m_prefix

StringProperty CaloUtils::ToolWithConstants< BASE >::m_prefix

privateinherited

Prefix for finding our constants within the ToolConstants object.

Definition at line 538 of file ToolWithConstants.h.

{ this, "prefix", "", "" };

m_setRawState

bool CaloFillRectangularCluster::m_setRawState

protected

Property to tell if the raw energy, eta0 and phi0 should be saved as uncalibrated signal state.

Definition at line 190 of file CaloFillRectangularCluster.h.

---

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

• CaloFillRectangularCluster.h
• CaloFillRectangularCluster.cxx