CaloSwCalibHitsCalibration Class Reference

#include <CaloSwCalibHitsCalibration.h>

Inheritance diagram for CaloSwCalibHitsCalibration:

Collaboration diagram for CaloSwCalibHitsCalibration:

Public Types
enum	{   EMB1 = 0 , EMB2 = 1 , EME1 = 2 , EME2 = 3 ,   COMBINED2 = 4 , CLUSTER = 5 , NREGIONS = 6 }
	Region codes for m_region below. More...

Public Member Functions
virtual void	makeTheCorrection (const Context &myctx, 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.
	CaloClusterCorrectionCommon (const std::string &type, const std::string &name, const IInterface *parent)
	Inherit constructor.
virtual void	makeCorrection (const Context &myctx, xAOD::CaloCluster *cluster) const override
	Perform the correction.
virtual StatusCode	initialize () override
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.

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.

Public Attributes
	cls = CompFactory.CaloSwCalibHitsCalibration
list	CaloSwCalibHitsCalibration_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.

Private Attributes
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< bool >	m_fix_v6_pathologies { this, "fix_v6_pathologies", "" }
Constant< bool >	m_updateSamplingEnergies { this, "update_sampling_energies", true, "" }
Constant< int >	m_region { this, "region", "Calorimeter region" }
	Calibration constant: The calorimeter region for which this correction is intended.
CxxUtils::CachedUniquePtr< const CaloClusterCorr::DDHelper >	m_ddhelper
	Helper for detector description lookup.

Detailed Description

Definition at line 24 of file CaloSwCalibHitsCalibration.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	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Inherit constructor.

Definition at line 46 of file CaloClusterCorrectionCommon.cxx.

  : CaloClusterCorrection (type, name, parent)
{
}

ddhelper()

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

privateinherited

Retrieve the detector description helper, creating it if needed.

Definition at line 639 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 574 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/2]

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

overrideinherited

Definition at line 52 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;
}

initialize()

StatusCode CaloClusterCorrection::initialize ( )

overridevirtualinherited

Reimplemented in CaloClusterBadChannelList, CaloDummyCorrection, CaloFillRectangularCluster, CaloSwDeadOTX_back, CaloSwDeadOTX_ps, CaloSwGap_g3, CaloSwGap_v2, CaloSwGap_v3, CaloTopoEMGap, and CaloTopoEMlayers.

Definition at line 46 of file CaloClusterCorrection.cxx.

                                             {
  ATH_CHECK(m_caloMgrKey.initialize());
  ATH_CHECK(base_class::initialize());
  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 435 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 CaloSwCalibHitsCalibration::makeTheCorrection ( const Context & myctx, 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 56 of file CaloSwCalibHitsCalibration.cxx.

{
   // ??? In principle, we should use adj_eta for the interpolation
   //     and range checks.  However, the v2 corrections were derived
   //     using regular eta instead.
   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;
 
   const float eta_start_crack = m_eta_start_crack (myctx);
   const float eta_end_crack = m_eta_end_crack (myctx);
   int si;
   if (the_aeta < eta_start_crack)
     si = 0;
   else if (the_aeta > eta_end_crack)
     si = 1;
   else {
     // No corrections are applied for the crack region.
     return;
   }
 
   const CxxUtils::Array<3> correction = m_correction (myctx);
 
//   the_aeta = std::abs (cluster->eta() );
 
 
   ATH_MSG_DEBUG(  "************************************************************************************************" << endmsg);
   ATH_MSG_DEBUG(  " USING CALIBHITS CALIBRATION " << endmsg);
   ATH_MSG_DEBUG(  " Tool Name   " << name() << endmsg);
   ATH_MSG_DEBUG(  "************************************************************************************************" << endmsg);   
 
   unsigned int shape[] = {2};
   CaloRec::WritableArrayData<1> interp_barriers (shape);
   interp_barriers[0] = eta_start_crack;
   interp_barriers[1] = eta_end_crack;
 
   int ibin = (static_cast<int> (the_aeta / etamax * 100)) ;
 
   int ibin_frontCorr = ibin;
   if (m_fix_v6_pathologies (myctx)) {
     if (the_aeta>2.35) ibin_frontCorr = (static_cast<int> (2.35 / etamax * 100)) ;
   }
 
// -------------------------------------------------------------
// Load calibration coefficients
// -------------------------------------------------------------
 
   CaloRec::Array<1> acc      = correction[0][ibin];
   CaloRec::Array<1> ooc      = correction[1][ibin];
   CaloRec::Array<1> lleak    = correction[2][ibin];
   CaloRec::Array<1> froffset = correction[3][ibin_frontCorr];  
   CaloRec::Array<1> frslope  = correction[4][ibin_frontCorr];
   CaloRec::Array<1> sec      = correction[5][ibin_frontCorr];
 
   ATH_MSG_DEBUG( "Check etas -------------------------------------------------------------------"<< endmsg);
   ATH_MSG_DEBUG( "Eta --> " << the_aeta << "  Bin --> " << ibin <<" Cluster eta = " << cluster->eta() << endmsg);
   ATH_MSG_DEBUG( "ETA = " << std::abs (adj_eta) << "    ADJ_ETA = " << std::abs (eta)<<  endmsg);
 
   ATH_MSG_DEBUG( "Check calibration coefficients -----------------------------------------------"<< endmsg);
   ATH_MSG_DEBUG( "Accordion   :  " << acc[0] <<"  " << acc[1]
          << " "  << acc[2] << " "  << acc[3] << endmsg);
   ATH_MSG_DEBUG( "OutOfCOne   :  " << ooc[0] <<"  " << ooc[1]
          << " "  << ooc[2] << " "  << ooc[3] << endmsg);
   ATH_MSG_DEBUG( "Leakage     :  " << lleak[0] <<"  " << lleak[1]
          << " " << lleak[2] << " "  << lleak[3] << endmsg);
   ATH_MSG_DEBUG( "Front offset:  " << froffset[0] <<"  " 
          <<froffset[1]  << " " << froffset[2] << " "  << froffset[3] <<endmsg);
   ATH_MSG_DEBUG( "Front Slope  :  " << frslope[0] <<"  " << frslope[1]
          << " " << frslope[2] << " "  << frslope[3] <<  endmsg);
   ATH_MSG_DEBUG( "Second order:  " << sec[0] << "  " << sec[1]
          << "  "  << sec[2] << " " << sec[3] << endmsg);
 
   static const CaloSampling::CaloSample samps[2][4] = {
     { CaloSampling::PreSamplerB,
       CaloSampling::EMB1,
       CaloSampling::EMB2,
       CaloSampling::EMB3 },
     { CaloSampling::PreSamplerE,
       CaloSampling::EME1,
       CaloSampling::EME2,
       CaloSampling::EME3 }
   };
 
   // Compute longitudinal barycenter: this is a very old and approximate
   // parametrization that needs to be updated.
   double shower_lbary = CaloClusterCorr::CaloSwCalibHitsShowerDepth::depth (the_aeta,
                                              eta_start_crack,
                                              eta_end_crack,
                                              m_sampling_depth(myctx),
                                              etamax,
                                              cluster, msg() );
   if (shower_lbary == 0) return;
 
   if (shower_lbary < 5. || shower_lbary > 25.) {
    shower_lbary =15.;
    ATH_MSG_DEBUG( " replace pathological depth by 15 X0" << endmsg); 
   }
 
   // Compute total energy in the accordion (eacc_base) and
   // presampler (eps_base)
 
   double eacc_base = 0;
   for (int sampling=1; sampling<4; sampling++) {
       eacc_base += cluster->eSample(samps[si][sampling]);
       ATH_MSG_DEBUG( "Barrel/endcap = " << si << "  Sampling = " <<   sampling << "   Energy -->> " <<  cluster->eSample(samps[si][sampling]) << endmsg);
   }
   double eps_base = cluster->eSample (samps[si][0]);
 
   ATH_MSG_DEBUG( "E accordion base --->>>> "  << eacc_base <<  "  Eps base " << eps_base << endmsg);
 
   // Add a protection against large longitudinal barycenter for clusters from
   // hadrons which may cause over-calibration. A energy dependent upper limit
   // on the long bary is introduced (from 20 at 0 to 23 at 1 TeV)    
 
   double depth_max = 20. + (eacc_base+eps_base)*(3./TeV) ;
   ATH_MSG_DEBUG( "Raw energy ---->> " << (eacc_base+eps_base) << endmsg) ;
   ATH_MSG_DEBUG( "Bary max for this event ---->> " << depth_max
       << endmsg) ;
 
   if ( shower_lbary > depth_max ) {
     shower_lbary = 15.;
     //shower_lbary = depth_max;
     ATH_MSG_DEBUG( " replace pathological depth by 15 X0 " 
         << endmsg); 
   } 
 
 
 
// -------------------------------------------------------------
// Now calibrate the accordion
// -------------------------------------------------------------
 
   double acc_corr    =
     acc[1] + acc[2] * shower_lbary + acc[3] * shower_lbary * shower_lbary ;
 
   double e_out_perc = 0;
   if (the_aeta < eta_start_crack) {
       e_out_perc = ooc[1] + ooc[2] * shower_lbary + ooc[3] * shower_lbary * shower_lbary ;
   }
   else if (the_aeta > eta_end_crack) {
       e_out_perc = ooc[1] + ooc[2] * shower_lbary + ooc[3] / shower_lbary ;
   }   
 
   double e_acc_reco=acc_corr*(eacc_base )*(1+(e_out_perc)*0.01);
 
// -------------------------------------------------------------
// Now estimate the longitudinal leakage
// -------------------------------------------------------------
 
   double e_leak_perc = 0;
/*
   if (the_aeta < eta_start_crack) { 
       e_leak_perc = lleak[1] + lleak[2] * shower_lbary + lleak[3] * exp(shower_lbary);
   } else if (the_aeta > eta_end_crack) {
       e_leak_perc = lleak[1] * shower_lbary + lleak[2] * exp(shower_lbary);
   }
*/
   e_leak_perc = lleak[3] + lleak[1] * shower_lbary + lleak[2] * exp(shower_lbary);
 
   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;
 
// -------------------------------------------------------------
// Now estimate the energy lost in front of the calorimeter
// -------------------------------------------------------------
 
 //  raw_energy = e_acc_reco ;
 
   double raw_energy=e_acc_reco*1e-3;
   double e_front_reco = eps_base;
 
   if (raw_energy <= 1) {
     // Protect against log() going negative in pow();
     // also protect against sqrt() of a negative number and div-by-zero.
   }
   else if (the_aeta < 1.8) {
 
     if (the_aeta < eta_start_crack) {
       double WpsOff      = froffset[1] + froffset[2]     * raw_energy + 
                            froffset[3] * raw_energy * raw_energy;
       double WpsSlo      = frslope[1]  * pow(log(raw_energy),
                                              static_cast<double>(frslope[2])) +
                            frslope[3] *sqrt( raw_energy );
       e_front_reco=WpsOff + WpsSlo*(eps_base );
 
       ATH_MSG_DEBUG( " raw event  " << raw_energy << endmsg);
       ATH_MSG_DEBUG( " froffset coeff " << froffset[1] << " " << froffset[2] << " " << froffset[3]  << endmsg);
       ATH_MSG_DEBUG( " frslope coeff  " << frslope[1] << " " << frslope[2] << " " << frslope[3] << endmsg);
       ATH_MSG_DEBUG( " WpsOff,WpsSlo " << WpsOff << " " << WpsSlo << endmsg);
        ATH_MSG_DEBUG( " eps_base, efront_reco " << eps_base << " " << e_front_reco << endmsg);
     }
     else{
 
       if (raw_energy<20.) raw_energy=20.;
 
       double WpsOff      = froffset[1] + froffset[2]     * raw_energy + 
                            froffset[3] * sqrt(raw_energy);
       double WpsSlo      = frslope[1]  + frslope[2] * log(raw_energy) +
                            frslope[3] * sqrt(raw_energy);
       double WpsSlo2     = sec[1]  + sec[2] * raw_energy -
                            sec[3] / (raw_energy * raw_energy) ;
       e_front_reco=WpsOff + WpsSlo*(eps_base) + WpsSlo2*(eps_base)*(eps_base);
       if (e_front_reco<0.) e_front_reco= eps_base;
          
       ATH_MSG_DEBUG( " raw energy " << raw_energy << endmsg);
       ATH_MSG_DEBUG( "p1 " << froffset[1] << " "
              << froffset[2] << " " << froffset[3] <<  " " << WpsOff << endmsg);
       ATH_MSG_DEBUG( "p2 " << frslope[1] << " "
              << frslope[2] << " " << frslope[3] << " " << WpsSlo << endmsg);
       ATH_MSG_DEBUG( "p3 " << sec[1] << " "
              << sec[2] << " " << sec[3] << " " << WpsSlo2 << endmsg);
       ATH_MSG_DEBUG( " WpsOff, WpsSlo, WpsSlo2 " << WpsOff << " " << WpsSlo << " " << WpsSlo2 << endmsg);
       ATH_MSG_DEBUG( " eps_base, efront_reco " << eps_base << " " <<  e_front_reco << endmsg);
 
     }
 
   }
   else {
 
     double p1 =  froffset[1] + froffset[2]     * raw_energy  +
                  froffset[3]* raw_energy  * raw_energy ;
     double p2 =  frslope[1]  + frslope[2]      * raw_energy  +
                  frslope[3] * raw_energy  * raw_energy ;
     double p3 =  sec[1]      + sec[2]          * raw_energy  +
                  sec[3] * raw_energy  * raw_energy ;
 
     ATH_MSG_DEBUG( "p1 " << froffset[1] << " "
            << froffset[2] << " " << froffset[3] << endmsg);
     ATH_MSG_DEBUG( "p2 " << frslope[1] << " "
            << frslope[2] << " " << frslope[3] << endmsg);
     ATH_MSG_DEBUG( "p3 " << sec[1] << " "
            << sec[2] << " " << sec[3] << endmsg);
 
     e_front_reco= (p1 + p2 * shower_lbary + p3 * shower_lbary * shower_lbary);
     if (e_front_reco<0.) e_front_reco=eps_base;
   }
 
// -------------------------------------------------------------
// Now compute the total energy and finally update the cluster energies
// -------------------------------------------------------------
 
   double e_calo_reco =e_front_reco + e_leak_reco + e_acc_reco;
 
   ATH_MSG_DEBUG( "CaloSwCalibrationHits::Final reco energy ---------------------- " << e_calo_reco << endmsg);
   ATH_MSG_DEBUG( "CaloSwCalibrationHits::Front ---------------------- " <<  e_front_reco << endmsg);
   ATH_MSG_DEBUG( "CaloSwCalibrationHits::Accordion ------------------ " <<  e_acc_reco << endmsg);
   ATH_MSG_DEBUG( "CaloSwCalibrationHits::out of cone ---------------- " <<  acc_corr*(eacc_base )*(e_out_perc)*0.01 << endmsg);      
   ATH_MSG_DEBUG( "CaloSwCalibrationHits::Leakage -------------------- " <<  e_leak_reco << endmsg);
   
   
 
/*
 -------------------------------------------------------------
 Conventions discussed in Dec 2007 larg week to fill energies in the samplings:
 E = total energy including all corrections
 E0 = total energy in front of the accordion :
        presampler energy + energy lost in front + energy lost between PS and strips
 E1 = energy in the strips with no out of cone corrections
 E2 = energy in the middle with no out of cone corrections
 E3 = energy in the back with no out of cone correction + longitudinal leakage 
 
 Please note that E != E0+E1+E2+E3 
  -------------------------------------------------------------
*/
   if (m_updateSamplingEnergies (myctx))
   {
       // presampler
 
       cluster->setEnergy (samps[si][0], e_front_reco );
 
       // strips and middle
 
       for (int sampling=1; sampling<=2; sampling++){
       cluster->setEnergy (samps[si][sampling], cluster->eSample(samps[si][sampling]) * acc_corr );
       }
       
       // back
       
       cluster->setEnergy (samps[si][3], cluster->eSample (samps[si][3]) * acc_corr + e_leak_reco);
   }
// total energy
   
   double e_temp = 0;
   for (int nl = 0 ; nl< 4 ; nl++) e_temp +=  cluster->eSample (samps [si][nl]);
   
   ATH_MSG_DEBUG( "----------  Sum of the sampling energy ---  >> " << e_temp << "  EcaloReco = " << e_calo_reco << endmsg);
 
   cluster->setE (e_calo_reco);
   
   ATH_MSG_DEBUG( "CaloSwCalibHitsCalibration::Energy after  correction --> " <<  cluster->e() << endmsg);
 
}

setenergy()

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

virtualinherited

Definition at line 93 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 73 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);
}

Member Data Documentation

CaloSwCalibHitsCalibration_versions

list CaloSwCalibHitsCalibration.CaloSwCalibHitsCalibration_versions

Definition at line 28 of file CaloSwCalibHitsCalibration.py.

cls

CaloSwCalibHitsCalibration.cls = CompFactory.CaloSwCalibHitsCalibration

Definition at line 27 of file CaloSwCalibHitsCalibration.py.

m_caloMgrKey

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

protectedinherited

Definition at line 83 of file CaloClusterCorrection.h.

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

m_correction

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

private

Definition at line 62 of file CaloSwCalibHitsCalibration.h.

{ this, "correction", "" };

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> CaloSwCalibHitsCalibration::m_eta_end_crack { this, "eta_end_crack", "" }

private

Definition at line 65 of file CaloSwCalibHitsCalibration.h.

{ this, "eta_end_crack",   "" };

m_eta_start_crack

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

private

Definition at line 64 of file CaloSwCalibHitsCalibration.h.

{ this, "eta_start_crack", "" };

m_etamax

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

private

Definition at line 66 of file CaloSwCalibHitsCalibration.h.

{ this, "etamax",          "" };

m_fix_v6_pathologies

Constant<bool> CaloSwCalibHitsCalibration::m_fix_v6_pathologies { this, "fix_v6_pathologies", "" }

private

Definition at line 68 of file CaloSwCalibHitsCalibration.h.

{ this, "fix_v6_pathologies", "" };

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.

{ this, "region", "Calorimeter region" };

m_sampling_depth

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

private

Definition at line 63 of file CaloSwCalibHitsCalibration.h.

{ this, "sampling_depth", "" };

m_updateSamplingEnergies

Constant<bool> CaloSwCalibHitsCalibration::m_updateSamplingEnergies { this, "update_sampling_energies", true, "" }

private

Definition at line 69 of file CaloSwCalibHitsCalibration.h.

{ this, "update_sampling_energies", true, "" };

m_use_raw_eta

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

private

Definition at line 67 of file CaloSwCalibHitsCalibration.h.

{ this, "use_raw_eta",     "" };

---

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

• CaloSwCalibHitsCalibration.h
• CaloSwCalibHitsCalibration.py
• CaloSwCalibHitsCalibration.cxx