CaloTopoEMlayers Class Reference

#include <CaloTopoEMlayers.h>

Inheritance diagram for CaloTopoEMlayers:

Collaboration diagram for CaloTopoEMlayers:

Public Types
typedef std::array< std::pair< double, double >, 4 >	WindowArray_t
	Holds the per-layer window sizes.

Public Member Functions
	CaloTopoEMlayers (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
	Standard Gaudi initialize method.
virtual void	get_seed (CaloClusterCorr::SamplingHelper &helper, const xAOD::CaloCluster *cluster, double &eta, double &phi) const override
virtual WindowArray_t	initWindows (const int neta, const int nphi, const double detas2, const double dphis2) const override
	Set up layer-by-layer cluster window sizes.
virtual void	makeCorrection (const Context &myctx, xAOD::CaloCluster *cluster) const override
	CaloClusterCorrection virtual method.
void	makeCorrection (const EventContext &ctx, xAOD::CaloCluster *cluster) const
virtual StatusCode	setCaloCellContainerName (const std::string &name) override
	Change the name of the CaloCellContainer used by this tool.
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.

Public Attributes
	cls = CompFactory.CaloTopoEMlayers
list	CaloTopoEMlayers_versions

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
Gaudi::Property< int >	m_neta {this, "eta_size", 5}
	\(\eta\times\phi\) cluster size. These are properties.
Gaudi::Property< int >	m_nphi {this, "phi_size", 5}
Gaudi::Property< bool >	m_fill_cluster {this, "fill_cluster", true}
	Fill-cluster flag.
Gaudi::Property< bool >	m_setRawState {this, "set_raw_state", true}
	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
	CaloTopoEMlayers ()=delete
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 {this, "cells_name", "AllCalo"}
	The StoreGate key for the container of our input cells.

Detailed Description

Definition at line 39 of file CaloTopoEMlayers.h.

Member Typedef Documentation

WindowArray_t

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

inherited

Holds the per-layer window sizes.

Definition at line 120 of file CaloFillRectangularCluster.h.

Constructor & Destructor Documentation

CaloTopoEMlayers() [1/2]

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

Definition at line 46 of file CaloTopoEMlayers.cxx.

  : CaloFillRectangularCluster(type, name, parent)
{ 
  m_fill_cluster = false;
}

CaloTopoEMlayers() [2/2]

CaloTopoEMlayers::CaloTopoEMlayers ( )

privatedelete

Member Function Documentation

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

get_seed()

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

overridevirtual

Reimplemented from CaloFillRectangularCluster.

Definition at line 64 of file CaloTopoEMlayers.cxx.

{
  eta = cluster->eta();
  phi = cluster->phi();
}

initialize()

StatusCode CaloTopoEMlayers::initialize ( )

overridevirtual

Standard Gaudi initialize method.

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

Reimplemented from CaloFillRectangularCluster.

Definition at line 56 of file CaloTopoEMlayers.cxx.

{
  CHECK(CaloFillRectangularCluster::initialize() );
 
  return StatusCode::SUCCESS;
}

initWindows()

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

overridevirtual

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 from CaloFillRectangularCluster.

Definition at line 84 of file CaloTopoEMlayers.cxx.

{
  CaloFillRectangularCluster::WindowArray_t w;
 
  float f_neta = (float)neta;
  float f_nphi = (float)nphi;
 
  w[0].first  = detas2*f_neta;
  w[1].first  = w[0].first;
  w[2].first  = w[0].first;
  w[3].first  = w[0].first;
 
  w[0].second = dphis2*f_nphi;
  w[1].second = w[0].second;
  w[2].second = w[0].second;
  w[3].second = w[0].second;
 
  return w;
}

makeCorrection() [1/2]

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

overridevirtualinherited

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

inlineinherited

Definition at line 90 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

privateinherited

Definition at line 817 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

privateinherited

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

setCaloCellContainerName()

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

overridevirtualinherited

Change the name of the CaloCellContainer used by this tool.

Parameters

name	The new container name.

Implements ISetCaloCellContainerName.

Definition at line 1212 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 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

CaloTopoEMlayers_versions

list CaloTopoEMlayers.CaloTopoEMlayers_versions

Initial value:

=  [
    ['',   cls, ['CaloTopoEMlayers.CaloTopoEMlayers_parms',  CALOCORR_NOPOOL]],
    ]

Definition at line 24 of file CaloTopoEMlayers.py.

cls

CaloTopoEMlayers.cls = CompFactory.CaloTopoEMlayers

Definition at line 23 of file CaloTopoEMlayers.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_cellsName

SG::ReadHandleKey<CaloCellContainer> CaloFillRectangularCluster::m_cellsName {this, "cells_name", "AllCalo"}

privateinherited

The StoreGate key for the container of our input cells.

This is a property.

Definition at line 194 of file CaloFillRectangularCluster.h.

{this, "cells_name", "AllCalo"};

m_deta0

double CaloFillRectangularCluster::m_deta0 = 0.0

protectedinherited

Cell window sizes in each sampling.

Definition at line 174 of file CaloFillRectangularCluster.h.

m_deta1

double CaloFillRectangularCluster::m_deta1 = 0.0

protectedinherited

Definition at line 174 of file CaloFillRectangularCluster.h.

m_deta2

double CaloFillRectangularCluster::m_deta2 = 0.0

protectedinherited

Definition at line 174 of file CaloFillRectangularCluster.h.

m_deta3

double CaloFillRectangularCluster::m_deta3 = 0.0

protectedinherited

Definition at line 174 of file CaloFillRectangularCluster.h.

m_dphi0

double CaloFillRectangularCluster::m_dphi0 = 0.0

protectedinherited

Definition at line 175 of file CaloFillRectangularCluster.h.

m_dphi1

double CaloFillRectangularCluster::m_dphi1 = 0.0

protectedinherited

Definition at line 175 of file CaloFillRectangularCluster.h.

m_dphi2

double CaloFillRectangularCluster::m_dphi2 = 0.0

protectedinherited

Definition at line 175 of file CaloFillRectangularCluster.h.

m_dphi3

double CaloFillRectangularCluster::m_dphi3 = 0.0

protectedinherited

Definition at line 175 of file CaloFillRectangularCluster.h.

m_fill_cluster

Gaudi::Property<bool> CaloFillRectangularCluster::m_fill_cluster {this, "fill_cluster", true}

protectedinherited

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 184 of file CaloFillRectangularCluster.h.

{this, "fill_cluster", true};

m_neta

Gaudi::Property<int> CaloFillRectangularCluster::m_neta {this, "eta_size", 5}

protectedinherited

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

Definition at line 178 of file CaloFillRectangularCluster.h.

{this, "eta_size", 5};

m_nphi

Gaudi::Property<int> CaloFillRectangularCluster::m_nphi {this, "phi_size", 5}

protectedinherited

Definition at line 179 of file CaloFillRectangularCluster.h.

{this, "phi_size", 5};

m_setRawState

Gaudi::Property<bool> CaloFillRectangularCluster::m_setRawState {this, "set_raw_state", true}

protectedinherited

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

Definition at line 189 of file CaloFillRectangularCluster.h.

{this, "set_raw_state", true};

---

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

• CaloTopoEMlayers.h
• CaloTopoEMlayers.py
• CaloTopoEMlayers.cxx