CaloSwDeadOTX_back Class Reference

#include <CaloSwDeadOTX_back.h>

Inheritance diagram for CaloSwDeadOTX_back:

Collaboration diagram for CaloSwDeadOTX_back:

Public Types
enum	{   EMB1 = 0, EMB2 = 1, EME1 = 2, EME2 = 3,   COMBINED2 = 4, CLUSTER = 5, NREGIONS = 6 }
	Region codes for m_region below. More...
typedef ToolWithConstants	base_class
	Shorthand for derived classes. More...
using	Context = CaloUtils::ToolConstantsContext
	Convenient alias for the Context type. More...
using	Constant = ToolConstant< T >
	Alias for the Constant type. More...

Public Member Functions
virtual void	makeTheCorrection (const Context &muctx, xAOD::CaloCluster *cluster, const CaloDetDescrElement *elt, float eta, float adj_eta, float phi, float adj_phi, CaloSampling::CaloSample samp) const override
	Virtual function for the correction-specific code. More...
virtual StatusCode	initialize () override
	Initialize method. More...
	CaloClusterCorrectionCommon (const std::string &type, const std::string &name, const IInterface *parent)
	Inherit constructor. More...
virtual void	makeCorrection (const Context &myctx, xAOD::CaloCluster *cluster) const override
	Perform the correction. More...
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::CaloCluster *cluster) const=0
	Execute on a single cluster. More...
virtual StatusCode	execute (xAOD::CaloCluster *cluster) final
	Execute on a single cluster. More...
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const
	Execute on an entire collection of clusters. More...
Context	context (const EventContext &ctx) const
	Create a Context object. More...
virtual void	writeConstants (std::ostream &stream, const std::string &name, const EventContext &ctx) const
	Dump method (for debugging) More...
virtual StatusCode	mergeConstants (CaloRec::ToolConstants &out, const EventContext &ctx) const override
	Merge our constants into out with the proper prefix. More...
virtual int	toolVersion () const
	Return the version number for this tool. More...
virtual const std::string &	toolType () const
	Return the name of the type of this tool. More...

Static Public Member Functions
static float	energy_interpolation (float energy, const TableBuilder &builder, const CaloRec::Array< 1 > &energies, int energy_degree)
	Many of the corrections use the same method for doing the final interpolation in energy. More...

Public Attributes
	cls = CompFactory.CaloSwDeadOTX_back
list	CaloSwDeadOTX_back_versions

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

Private Member Functions
const CaloClusterCorr::DDHelper &	ddhelper (const CaloDetDescrManager *dd_man) const
	Retrieve the detector description helper, creating it if needed. More...

Private Attributes
SG::ReadCondHandleKey< CaloAffectedRegionInfoVec >	m_affKey
ToolHandle< ICaloAffectedTool >	m_affectedTool {this, "AffectedTool", "CaloAffectedTool", "affected tool instance"}
Constant< CxxUtils::Array< 3 > >	m_correction { this, "correction", "" }
Constant< CxxUtils::Array< 2 > >	m_sampling_depth { this, "sampling_depth", ""}
Constant< float >	m_eta_start_crack { this, "eta_start_crack",""}
Constant< float >	m_eta_end_crack { this, "eta_end_crack", "" }
Constant< float >	m_etamax { this, "etamax", "" }
Constant< bool >	m_use_raw_eta { this, "use_raw_eta", "" }
Constant< int >	m_region { this, "region", "Calorimeter region" }
	Calibration constant: The calorimeter region for which this correction is intended. More...
CxxUtils::CachedUniquePtr< const CaloClusterCorr::DDHelper >	m_ddhelper
	Helper for detector description lookup. More...
SG::ReadCondHandleKey< CaloRec::ToolConstants >	m_DBHandle
	Handle to a ToolConstants conditions object. More...
StringProperty	m_prefix
	Prefix for finding our constants within the ToolConstants object. More...
ToolWithConstantsImpl	m_impl
	Internal implementation object. More...
Constant< int >	m_order
	Used to fix the ordering of tools when we're initializing from COOL based on a hierarchical tag. More...
Constant< bool >	m_isdummy
	If true, then this is a dummy tool that should not be executed. More...

Detailed Description

Definition at line 20 of file CaloSwDeadOTX_back.h.

Member Typedef Documentation

base_class

typedef ToolWithConstants CaloUtils::ToolWithConstants< CaloClusterProcessor >::base_class

inherited

Shorthand for derived classes.

Definition at line 443 of file ToolWithConstants.h.

Constant

using CaloUtils::ToolWithConstants< CaloClusterProcessor >::Constant = ToolConstant<T>

inherited

Alias for the Constant type.

Definition at line 456 of file ToolWithConstants.h.

Context

using CaloUtils::ToolWithConstants< CaloClusterProcessor >::Context = CaloUtils::ToolConstantsContext

inherited

Convenient alias for the Context type.

Definition at line 451 of file ToolWithConstants.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

Region codes for m_region below.

This is used to decide how to report the position of the cluster. Note: This numbering is also used in the job options files.

Enumerator
EMB1
EMB2
EME1
EME2
COMBINED2
CLUSTER
NREGIONS

Definition at line 100 of file CaloClusterCorrectionCommon.h.

       {
    // Barrel, sampling 1.
    EMB1 = 0,
 
    // Barrel, sampling 2.
    EMB2 = 1,
 
    // Endcap, sampling 1.
    EME1 = 2,
 
    // Endcap, sampling 2.
    EME2 = 3,
 
    // Average of barrel and endcap in sampling 2.
    COMBINED2 = 4,
 
    // Overall cluster position.
    CLUSTER = 5,
 
    // Number of different region codes.
    NREGIONS = 6
  };

Member Function Documentation

CaloClusterCorrectionCommon()

CaloClusterCorrectionCommon::CaloClusterCorrectionCommon

Inherit constructor.

Definition at line 46 of file CaloClusterCorrectionCommon.cxx.

  : CaloClusterCorrection (type, name, parent)
{
}

context()

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

inherited

Create a Context object.

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

ddhelper()

const CaloClusterCorr::DDHelper & CaloClusterCorrectionCommon::ddhelper ( const CaloDetDescrManager *  dd_man ) const

privateinherited

Retrieve the detector description helper, creating it if needed.

Definition at line 640 of file CaloClusterCorrectionCommon.cxx.

{
  const CaloClusterCorr::DDHelper* ddhelper = m_ddhelper.get();
  if (!ddhelper) {
    auto newhelper = std::make_unique<const CaloClusterCorr::DDHelper> (dd_man);
    ddhelper = m_ddhelper.set (std::move (newhelper));
  }
  return *ddhelper;
}

energy_interpolation()

float CaloClusterCorrectionCommon::energy_interpolation ( float  energy, const TableBuilder &  builder, const CaloRec::Array< 1 > &  energies, int  energy_degree  )

staticinherited

Many of the corrections use the same method for doing the final interpolation in energy.

Perform energy interpolation.

We factor out this common code here. builder is used to construct the interpolation table; energy is the energy value for the interpolation. energies is the list of energies at which we have tabulated values, and energy_degree is the degree of the polynomial interpolation in energy.

Parameters

energy	The energy value for the interpolation.
builder	Helper to construct the interpolation table.
energies	The energy interpolation table.
energy_degree	The polynomial interpolation degree for the energy interpolation.

Many of the corrections use the same method for doing the final interpolation in energy. We factor out this common code here.

Definition at line 575 of file CaloClusterCorrectionCommon.cxx.

{
  // Calculate the correction for each energy.
  unsigned int n_energies = energies.size();
  unsigned int shape[] = {n_energies, 2};
  CaloRec::WritableArrayData<2> corrtab (shape);
 
  // If we're outside the range of the table, we'll just be using the
  // value at the end (no extrapolation).  We only need to calculate
  // that one point in that case.
  unsigned int beg = 0;
  unsigned int end = n_energies;
  if (energy <= energies[0])
    end = 1;
  else if (energy >= energies[n_energies-1])
    beg = n_energies-1;
 
  // Build the table.
  int n_good = 0;
  for (unsigned int i=beg; i<end; i++)
    docalc (i, builder, energies, corrtab, n_good);
 
  // If we only evaluated one point, but it wasn't good, keep
  // searching until we find a good one.
  while (n_good == 0 && beg > 0) {
    --beg;
    docalc (beg, builder, energies, corrtab, n_good);
  }
  while (n_good == 0 && end < n_energies) {
    docalc (end, builder, energies, corrtab, n_good);
    ++end;
  }
 
  // Now interpolate in energy.
  // But if we're outside of the range of the table, just use the value
  // at the end (don't extrapolate).
  if (n_good == 0) {
    // No good energies --- return a null correction.
    return 0;
  }
  else if (n_good == 1) {
    // Only one good energy --- nothing to do but to use it.
    return corrtab[0][1];
  }
  else if (energy <= corrtab[0][0]) {
    // Off the low end of the table --- return the first value.
    return corrtab[0][1];
  }
  else if (energy >= corrtab[n_good-1][0]) {
    // Off the high end of the table --- return the last value.
    return corrtab[n_good-1][1];
  }
 
  // Do the interpolation.
  return interpolate (corrtab, energy, energy_degree,
                      1, CaloRec::Array<1>(), n_good);
}

execute() [1/4]

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/4]

virtual StatusCode CaloClusterProcessor::execute

inherited

Execute on a single cluster.

Parameters

cluster	The cluster to process.
ctx	The event context.

execute() [3/4]

StatusCode CaloClusterProcessor::execute

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 73 of file CaloClusterProcessor.cxx.

{
  xAOD::CaloClusterContainer::iterator beg = collection->begin();
  xAOD::CaloClusterContainer::iterator end = collection->end();
  for (; beg != end; ++beg) {
    CHECK( execute (ctx, *beg) );
  }
  return StatusCode::SUCCESS;
}

execute() [4/4]

StatusCode CaloClusterProcessor::execute

finalinherited

Execute on a single cluster.

Parameters

cluster

The cluster to process. (deprecated)

Definition at line 63 of file CaloClusterProcessor.cxx.

{
  return execute (Gaudi::Hive::currentContext(), cluster);
}

initialize()

StatusCode CaloSwDeadOTX_back::initialize ( )

overridevirtual

Initialize method.

Derived classes must call this.

Reimplemented from CaloClusterCorrection.

Definition at line 29 of file CaloSwDeadOTX_back.cxx.

{
  CHECK( CaloClusterCorrectionCommon::initialize() );
 
  // Need the explicit std::string here to avoid matching
  // the template in AlgTool.
  //  CHECK( setProperty ("isDummy", std::string("1")) );
 
  ATH_CHECK(m_affKey.initialize());
 
  ATH_MSG_DEBUG( " --------------->>>>> CaloSwDeadOTX_back :: retrieving affectedTool" << endmsg);
 
  if (m_affectedTool.retrieve().isFailure()){
      ATH_MSG_DEBUG( " --------------->>>>> CaloSwDeadOTX_back :: failure retrieving affectedTool !! " << endmsg);
      return StatusCode::FAILURE;
  } 
 
  ATH_MSG_DEBUG( " --------------->>>>> CaloSwDeadOTX_back :: affectedTool successfully retrieved" << endmsg);
 
  return StatusCode::SUCCESS;
}

makeCorrection()

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

overridevirtualinherited

Perform the correction.

Called by the tool

Parameters

myctx	ToolWithConstants context.
cluster	The cluster to correct. It is updated in place.

Called by the tool.

Parameters

myctx	ToolWithConstants context.
cluster	The cluster to correct. It is updated in place.

Does the following:

• Checks whether the cluster is present in the given calorimeter and sampling. If not, do nothing.
• Computes quantities to pass to makeTheCorrection.
• Calls makeTheCorrection.

Implements CaloClusterCorrection.

Definition at line 436 of file CaloClusterCorrectionCommon.cxx.

{
  int region = m_region (myctx);
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, myctx.ctx()};
  const CaloDetDescrManager* dd_man = *caloMgrHandle;
 
  // This causes a lot of overhead (mostly from the MsgStream ctor).
  // Comment out when not needed.
  //MsgStream log( msgSvc(), name() );
  //log << MSG::DEBUG << "Entering makeCorrection" << endmsg;
  //log << MSG::DEBUG << "e, eta, phi, etasize, phisize" << " " << cluster->e() << " " << cluster->eta() << " " << cluster->phi() 
  //  << " " <<  cluster->etasize(CaloSampling::EMB2) << " " << cluster->phisize(CaloSampling::EMB2) << endmsg;
  //log << MSG::DEBUG << "B / E  " << cluster->inBarrel() << " " << cluster->inEndcap() << endmsg;
  //log << MSG::DEBUG << "region " << region << endmsg;
 
  float eta;
  float phi;
  CaloSampling::CaloSample samp = CaloSampling::Unknown;
 
  // Find the proper @f$\eta@f$ and @f$\phi@f$ measures of the cluster.
  // Also set up the sampling code @c samp.
  switch (region) {
  case EMB1:
  case EMB2:
  case EME1:
  case EME2:
    // Return immediately if we can tell we're in the wrong region.
    if (barrel_p (region)) {
      if (!cluster->inBarrel()) return;
    }
    else {
      if (!cluster->inEndcap()) return;
    }
 
    switch (region) {
    case EMB1:
      samp = CaloSampling::EMB1;
      break;
    case EMB2:
      samp = CaloSampling::EMB2;
      break;
    case EME1:
      samp = CaloSampling::EME1;
      break;
    case EME2:
      samp = CaloSampling::EME2;
      break;
    }
 
    eta = cluster->etaSample (samp);
    phi = cluster->phiSample (samp);
    break;
 
  case COMBINED2:
    eta = cluster->etaBE (2);
    phi = cluster->phiBE (2);
    break;
 
  case CLUSTER:
    eta = cluster->eta();
    phi = cluster->phi();
    break;
 
  default:
    abort();
  }
 
  // Give up if one of them is an error flag.
  if (std::abs (phi) > 900 || std::abs (eta) > 900)
    return;
 
  // Sometimes unnormalized @f$\phi@f$ values still come through.
  // Make sure this is in the proper range before calling the correction.
  phi = CaloPhiRange::fix (phi);
 
  // Look up the DD element.
  // Give up if we can't find one.
  const CaloDetDescrElement* elt = ddhelper(dd_man).find_dd_elt (dd_man,
                                 region,
                                 cluster,
                                 eta, phi);
  if (!elt)
    return;
 
  // Compute the adjusted eta and phi --- the coordinates shifted
  // from the actual to the nominal coordinate system.
  float adj_eta = eta - elt->eta() + elt->eta_raw();
  float adj_phi = CaloPhiRange::fix (phi - elt->phi() + elt->phi_raw());
 
  // Call the actual correction.
  makeTheCorrection (myctx, cluster, elt, eta, adj_eta, phi, adj_phi, samp);
}

makeTheCorrection()

void CaloSwDeadOTX_back::makeTheCorrection ( const Context &  muctx, xAOD::CaloCluster *  cluster, const CaloDetDescrElement *  elt, float  eta, float  adj_eta, float  phi, float  adj_phi, CaloSampling::CaloSample  samp  ) const

overridevirtual

Virtual function for the correction-specific code.

Parameters

myctx	ToolWithConstants context.
cluster	The cluster to correct. It is updated in place.
elt	The detector description element corresponding to the cluster location.
eta	The \(\eta\) coordinate of the cluster, in this sampling.
adj_eta	The \(\eta\) adjusted for any shift between the actual and nominal coordinates. (This is shifted back to the nominal coordinate system.)
phi	The \(\phi\) coordinate of the cluster, in this sampling.
adj_phi	The \(\phi\) adjusted for any shift between the actual and nominal coordinates. (This is shifted back to the nominal coordinate system.)
samp	The calorimeter sampling we're examining. This is a sampling code as defined by CaloSampling::CaloSample; i.e., it has both the calorimeter region and sampling encoded.

Implements CaloClusterCorrectionCommon.

Definition at line 51 of file CaloSwDeadOTX_back.cxx.

{
// ??? In principle, we should use adj_eta for the interpolation
//     and range checks.  However, the v2 corrections were derived
//     using regular eta instead.
//
   //Get affected info for this event
   SG::ReadCondHandle<CaloAffectedRegionInfoVec> affHdl{m_affKey, myctx.ctx()};
   const CaloAffectedRegionInfoVec* affCont=*affHdl;
   if(!affCont) {
     ATH_MSG_WARNING("Do not have affected regions info, is this expected ?");
   }
 
   float the_aeta;
   if (m_use_raw_eta(myctx))
      the_aeta = std::abs (adj_eta);
   else
      the_aeta = std::abs (eta);
    
   const float etamax = m_etamax (myctx);
   if (the_aeta >= etamax) return;
    
   int si;
   if (the_aeta < m_eta_start_crack(myctx))
      si = 0;
   else if (the_aeta > m_eta_end_crack(myctx))
      si = 1;
   else {
   // No corrections are applied for the crack region.
      return;
   } 
 
  const CxxUtils::Array<3> correction = m_correction (myctx);
 
   ATH_MSG_DEBUG(  "************************************************************************************************" << endmsg);
   ATH_MSG_DEBUG(  " USING CALIBHITS CALIBRATION : apply correction for dead OTX in the back" << endmsg);
   ATH_MSG_DEBUG(  " Tool Name   " << name() << endmsg);
   ATH_MSG_DEBUG(  "************************************************************************************************" << endmsg);   
 
// -------------------------------------------------------------
// check if the cluster is in an affected region
// -------------------------------------------------------------
 
   static const CaloSampling::CaloSample samps[2][4] = {
      { CaloSampling::PreSamplerB,
        CaloSampling::EMB1,
        CaloSampling::EMB2,
        CaloSampling::EMB3 },
      { CaloSampling::PreSamplerE,
        CaloSampling::EME1,
        CaloSampling::EME2,
        CaloSampling::EME3 }
   };
 
// Keep memory of the energy stored in the back
 
   float eneBackold =  cluster->eSample (samps[si][3]) ;
 
// Set the safety margin around the dead region     
   float deta = 0.025;
   float dphi = 0.025;     
 
   int layer = si * 4 + 3 ;
   bool check = m_affectedTool->isAffected(cluster, affCont, deta , dphi ,layer,layer,0) ; //  check dead OTX in barrel PS 
 
 
// if a cluster is in an affected region set the back energy to zero else return
 
   if (check) { 
       ATH_MSG_DEBUG(  "The cluster is in an affected region, apply corrections" << endmsg);
       cluster->setEnergy (samps[si][3], 0 );
   } else { 
       ATH_MSG_DEBUG(  "The cluster is NOT in an affected region, skip correction" << endmsg);
       return; 
   }
 
// -------------------------------------------------------------
// If the cluster is in an affected region load the corrections
// -------------------------------------------------------------
 
// Determine the eta bin for the correction
   int ibin = (static_cast<int> (the_aeta / etamax * 100)) ;  
 
// Load the correction coefficients 
   CaloRec::Array<1> lleak    = correction[0][ibin];
 
// -------------------------------------------------------------
// Compute longitudinal barycenter: this is a very old and approximate
// parametrization that needs to be updated.
// -------------------------------------------------------------
 
   double raw_energy =0;
   double shower_lbary_raw =0;
   for (int nl = 0 ; nl< 4 ; nl++){
      raw_energy +=  cluster->eSample (samps[si][nl]);
      shower_lbary_raw += (m_sampling_depth(myctx)[ibin][nl+1] * cluster->eSample (samps[si][nl])) ;
   }
           
   if (raw_energy == 0) return;
   double shower_lbary = shower_lbary_raw / raw_energy;
    
   ATH_MSG_DEBUG( "Shower longitudinal barycenter ---->> " << shower_lbary << endmsg);
   
   double depth_max = 20. + raw_energy*(3./TeV) ;
 
   if ( shower_lbary > depth_max   || shower_lbary < 0.) {
     shower_lbary = 15.;
     ATH_MSG_DEBUG( " replace pathological depth by 15 X0 "
         << endmsg);
   }
 
 
   raw_energy = raw_energy * 1e-3;
 
// -------------------------------------------------------------
// Estimate the energy deposited in the back sampling and the 
// longitudinal leakage based on the longitudinal barycenter   
// -------------------------------------------------------------
   
   double e_acc_reco = 0;
   for (int nl = 1 ; nl< 4 ; nl++){
      e_acc_reco +=  cluster->eSample (samps[si][nl]);
   }
 
   ATH_MSG_DEBUG( "Leakage     :  " << lleak[0] <<"  " << lleak[1]
          << " " << lleak[2] << " "  << lleak[3] << endmsg);
 
   double e_leak_perc = lleak[3] + lleak[1] * shower_lbary + lleak[2] * exp(shower_lbary);
 
   ATH_MSG_DEBUG( "LongLeakage correction --> " << e_leak_perc << endmsg);
    
   if (e_leak_perc < 0 ) e_leak_perc = 0.;
   if (e_leak_perc > 100.) e_leak_perc = 100.;
 
   double e_leak_reco = e_leak_perc * (e_acc_reco)*0.01; 
 
// If something goes wrong keep the old energy
   if (e_leak_reco<0.) e_leak_reco= eneBackold; 
 
// -------------------------------------------------------------
// Now set the energies of the cluster  
// -------------------------------------------------------------
 
// set the energy of the presampler
   cluster->setEnergy (samps[si][3], e_leak_reco );
   
// take the cluster energy, subtract the old PS energy and add the new one
 
   ATH_MSG_DEBUG( "CaloSwDeadOTX_back:: cluster energy before correction --> " <<  cluster->e() << endmsg);
   ATH_MSG_DEBUG( "subtracting back energy -->> " << eneBackold << endmsg);
   ATH_MSG_DEBUG( "adding new back energy  -->> " << e_leak_reco << endmsg);
 
   float e_temp = cluster->e() - eneBackold + e_leak_reco ; 
 
// set the energy of the cluster
   cluster->setE (e_temp); 
 
   ATH_MSG_DEBUG( "CaloSwDeadOTX_back::Energy after  correction --> " <<  cluster->e() << endmsg); 
 
}

mergeConstants()

virtual StatusCode CaloUtils::ToolWithConstants< CaloClusterProcessor >::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.

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< CaloClusterProcessor >::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.

toolVersion()

virtual int CaloUtils::ToolWithConstants< CaloClusterProcessor >::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< CaloClusterProcessor >::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

CaloSwDeadOTX_back_versions

list CaloSwDeadOTX_back.CaloSwDeadOTX_back_versions

Initial value:

=  [
#
    ['v1', cls, ['CaloSwDeadOTX_back_v1.' +
                   'CaloSwDeadOTX_back_v1_parms',
                 'caloswcorr_pool', CALOCORR_COOL,
                 ], 
                 ['ele55',        'ele35',        'ele37',
                  'gam55_conv',   'gam35_conv',   'gam37_conv',
                  'gam55_unconv', 'gam35_unconv', 'gam37_unconv',
                  'ele33',        'ele57',        'ele77',
                  'gam33_conv',   'gam57_conv',   'gam77_conv',
                  'gam33_unconv', 'gam57_unconv', 'gam77_unconv'] ]
    ]

Definition at line 19 of file CaloSwDeadOTX_back.py.

cls

CaloSwDeadOTX_back.cls = CompFactory.CaloSwDeadOTX_back

Definition at line 18 of file CaloSwDeadOTX_back.py.

m_affectedTool

ToolHandle<ICaloAffectedTool> CaloSwDeadOTX_back::m_affectedTool {this, "AffectedTool", "CaloAffectedTool", "affected tool instance"}

private

Definition at line 68 of file CaloSwDeadOTX_back.h.

m_affKey

SG::ReadCondHandleKey<CaloAffectedRegionInfoVec> CaloSwDeadOTX_back::m_affKey

private

Initial value:

{this,
    "LArAffectedRegionKey", "LArAffectedRegionInfo", "SG key for affected regions cond object"}

Definition at line 65 of file CaloSwDeadOTX_back.h.

m_caloMgrKey

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

protectedinherited

Definition at line 119 of file CaloClusterCorrection.h.

m_correction

Constant<CxxUtils::Array<3> > CaloSwDeadOTX_back::m_correction { this, "correction", "" }

private

Definition at line 70 of file CaloSwDeadOTX_back.h.

m_DBHandle

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

privateinherited

Handle to a ToolConstants conditions object.

Definition at line 527 of file ToolWithConstants.h.

m_ddhelper

CxxUtils::CachedUniquePtr<const CaloClusterCorr::DDHelper> CaloClusterCorrectionCommon::m_ddhelper

privateinherited

Helper for detector description lookup.

Definition at line 165 of file CaloClusterCorrectionCommon.h.

m_eta_end_crack

Constant<float> CaloSwDeadOTX_back::m_eta_end_crack { this, "eta_end_crack", "" }

private

Definition at line 73 of file CaloSwDeadOTX_back.h.

m_eta_start_crack

Constant<float> CaloSwDeadOTX_back::m_eta_start_crack { this, "eta_start_crack",""}

private

Definition at line 72 of file CaloSwDeadOTX_back.h.

m_etamax

Constant<float> CaloSwDeadOTX_back::m_etamax { this, "etamax", "" }

private

Definition at line 74 of file CaloSwDeadOTX_back.h.

m_impl

ToolWithConstantsImpl CaloUtils::ToolWithConstants< CaloClusterProcessor >::m_impl

privateinherited

Internal implementation object.

Definition at line 535 of file ToolWithConstants.h.

m_isdummy

Constant<bool> CaloUtils::ToolWithConstants< CaloClusterProcessor >::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 553 of file ToolWithConstants.h.

m_order

Constant<int> CaloUtils::ToolWithConstants< CaloClusterProcessor >::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 540 of file ToolWithConstants.h.

m_prefix

StringProperty CaloUtils::ToolWithConstants< CaloClusterProcessor >::m_prefix

privateinherited

Prefix for finding our constants within the ToolConstants object.

Definition at line 531 of file ToolWithConstants.h.

m_region

Constant<int> CaloClusterCorrectionCommon::m_region { this, "region", "Calorimeter region" }

privateinherited

Calibration constant: The calorimeter region for which this correction is intended.

This should be one of the constants above. This affects the meaning of the eta and phi arguments passed to makeTheCorrection, as well as the samp argument.

Definition at line 161 of file CaloClusterCorrectionCommon.h.

m_sampling_depth

Constant<CxxUtils::Array<2> > CaloSwDeadOTX_back::m_sampling_depth { this, "sampling_depth", ""}

private

Definition at line 71 of file CaloSwDeadOTX_back.h.

m_use_raw_eta

Constant<bool> CaloSwDeadOTX_back::m_use_raw_eta { this, "use_raw_eta", "" }

private

Definition at line 75 of file CaloSwDeadOTX_back.h.

---

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

• CaloSwDeadOTX_back.h
• CaloSwDeadOTX_back.py
• CaloSwDeadOTX_back.cxx