CaloLCDeadMaterialTool Class Reference

dead material correction tool for local hadronic calibration More...

#include <CaloLCDeadMaterialTool.h>

Inheritance diagram for CaloLCDeadMaterialTool:

Collaboration diagram for CaloLCDeadMaterialTool:

Classes
struct	Area
struct	Cell

Public Types
enum	dm_area_keys {   sDM_EMB0_EMB1, sDM_EMB3_TILE0, sDM_SCN, sDM_EME0_EME12,   sDM_EME3_HEC0, sDM_FCAL, sDM_LEAKAGE, sDM_UNCLASS,   sDM }
	Dead Material area number. More...

Public Member Functions
virtual	~CaloLCDeadMaterialTool () override
virtual StatusCode	weight (xAOD::CaloCluster *theCluster, const EventContext &ctx) const override
	method to weight the cells in a cluster More...
virtual StatusCode	initialize () override
	CaloLCDeadMaterialTool (const std::string &type, const std::string &name, const IInterface *parent)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	prepare_for_cluster (const xAOD::CaloCluster *theCluster, std::vector< Area > &areas, std::vector< Cell > &cells, float *smp_energy, float &cls_unweighted_energy, const CaloLocalHadCoeff *data) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadCondHandleKey< CaloLocalHadCoeff >	m_key
	name of the key for DM cell weights More...
int	m_recoStatus
	Required Reco Status for the clusters in order to be calibrated. More...
int	m_weightModeDM
	method of assignment of DM energy to cluster More...
float	m_MinClusterEnergyToDeal
	Minimum energy of clusters to apply correction. More...
int	m_MinLookupBinNentry
	minimum number of events in one lookup bin to use More...
float	m_MinCellEnergyToDeal
	minimum cell energy to deal More...
float	m_MaxChangeInCellWeight
	maximum allowed change in cell weights More...
bool	m_useHadProbability
	calculate DM energy using em-probability moment More...
bool	m_interpolate
	interpolate correction coefficients More...
bool	m_updateSamplingVars
	update also sampling variables More...
std::map< std::string, std::vector< std::string > >	m_interpolateDimensionNames
	vector of names of dimensions to interpolate (for different correction types different set of dimensions) More...
std::vector< int >	m_interpolateDimensionsFit
	actual set of dimension id's to interpolate (in the DM areas corrected with TProfile approach) More...
std::vector< int >	m_interpolateDimensionsLookup
	actual set of dimension id's to interpolate (in the DM areas corrected with lookup approach) More...
std::vector< int >	m_interpolateDimensionsSampling
	actual set of dimension id's to interpolate (in the DM areas corrected with sampling weight approach) More...
bool	m_absOpt
	In Abs Option case, DM calculation has to be handled in a slightly different way. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

dead material correction tool for local hadronic calibration

Author

Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch

Date

09-September-2009 Calculates dead material energy of given cluster. Cluster energy, lambda and eta are used to get appropriate set of DM correction coefficients for appropriate dead material area ( dead material area definition and set of correction coefficients are holded by CaloHadDMCoeff2 class). DM coefficients are applied to cluster cells sums to calculate DM energy in different calorimeter areas. Finally, calculated DM energy is added to the cluster by changing (increasing) cluster cells weights in appropriate samplings.

Definition at line 39 of file CaloLCDeadMaterialTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

dm_area_keys

enum CaloLCDeadMaterialTool::dm_area_keys

Dead Material area number.

These keys are used to identify specific dead material areas in the calorimeter where procedure of DM correction will be applied

Enumerator
sDM_EMB0_EMB1
sDM_EMB3_TILE0
sDM_SCN
sDM_EME0_EME12
sDM_EME3_HEC0
sDM_FCAL
sDM_LEAKAGE
sDM_UNCLASS
sDM

Definition at line 47 of file CaloLCDeadMaterialTool.h.

    {
      sDM_EMB0_EMB1,   // 0 before PreSamplerB, between PreSamplerB and EMB1
      sDM_EMB3_TILE0,  // 1 between barrel and tile
      sDM_SCN,         // 2 before TileGap3 (scintillator)
      sDM_EME0_EME12,  // 3 before PreSamplerE, between PreSamplerE and EME1
      sDM_EME3_HEC0,   // 4 between EME3 and HEC0
      sDM_FCAL,        // 5 between HEC and FCAL, before FCAL
      sDM_LEAKAGE,     // 6 leakage behind calorimeter
      sDM_UNCLASS,     // 7 unclassified DM enegry
      sDM
    };

Constructor & Destructor Documentation

~CaloLCDeadMaterialTool()

CaloLCDeadMaterialTool::~CaloLCDeadMaterialTool ( )

overridevirtualdefault

CaloLCDeadMaterialTool()

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

Definition at line 32 of file CaloLCDeadMaterialTool.cxx.

  : AthAlgTool(type,name,parent),
    m_key("HadDMCoeff2"),
    m_recoStatus(CaloRecoStatus::UNKNOWNSTATUS),
    m_weightModeDM(1),
    m_MinClusterEnergyToDeal(200.0*MeV),
    m_MinLookupBinNentry(40),
    m_MinCellEnergyToDeal(0.0),
    m_MaxChangeInCellWeight(30.0),
    m_useHadProbability(false),
    m_interpolate(false),
    m_absOpt(false)
{
  declareInterface<IClusterCellWeightTool>(this);
  declareProperty("HadDMCoeffKey",m_key);
  declareProperty("ClusterRecoStatus",m_recoStatus);
  declareProperty("WeightModeDM",m_weightModeDM) ;
  declareProperty("MinClusterEnergyToDeal", m_MinClusterEnergyToDeal);
  declareProperty("MinLookupBinNentry", m_MinLookupBinNentry);
  declareProperty("MinCellEnergyToDeal", m_MinCellEnergyToDeal);
  declareProperty("MaxChangeInCellWeight", m_MaxChangeInCellWeight);
  declareProperty("UseHadProbability",m_useHadProbability);
  // Use Interpolation or not
  declareProperty("Interpolate",m_interpolate);
  // list of dimensions to interpolate trought in 3 different type of areas
  std::vector<std::string > vstr;
  vstr.resize(2);
  vstr[0] = "DIMD_ETA";
  vstr[1] = "DIMD_ENER";
  m_interpolateDimensionNames[std::string("AREA_DMFIT")] = vstr;
  vstr.resize(3);
  vstr[0] = "DIMD_ETA";
  vstr[1] = "DIMD_ENER";
  vstr[2] = "DIMD_LAMBDA";
  m_interpolateDimensionNames[std::string("AREA_DMLOOKUP")] = vstr;
  vstr.resize(2);
  vstr[0] = "DIMD_ETA";
  vstr[1] = "DIMD_LAMBDA";
  m_interpolateDimensionNames[std::string("AREA_DMSMPW")] = vstr;
  declareProperty("InterpolateDimensionNames", m_interpolateDimensionNames);
  declareProperty("UpdateSamplingVars",m_updateSamplingVars=false);
  //Use weighting of negative clusters?
  declareProperty("WeightingOfNegClusters",m_absOpt);
}

Member Function Documentation

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

initialize()

StatusCode CaloLCDeadMaterialTool::initialize ( )

overridevirtual

Definition at line 90 of file CaloLCDeadMaterialTool.cxx.

{
  if(m_interpolate) {
    msg(MSG::INFO) << "Interpolation is ON, dimensions: ";
    for(std::map<std::string, std::vector<std::string> >::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      msg(MSG::INFO) << " " << (*it).first << " (";
      for(std::vector<std::string >::iterator it2 = (*it).second.begin(); it2!=(*it).second.end(); ++it2) {
        msg() << (*it2) << " ";
      }
      msg() << ")";
    }
    msg() << endmsg;
    for(std::map<std::string, std::vector<std::string> >::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      std::vector<int > *vtmp=nullptr;
      if((*it).first == "AREA_DMFIT") {
        vtmp = &m_interpolateDimensionsFit;
      }else if((*it).first == "AREA_DMLOOKUP") {
        vtmp = &m_interpolateDimensionsLookup;
      }else if((*it).first == "AREA_DMSMPW") {
        vtmp = &m_interpolateDimensionsSampling;
      }else{
        msg(MSG::WARNING) << "Unkown dead material area type '" << (*it).first << "'" << std::endl;
        continue;
      }
      for(std::vector<std::string >::iterator it2 = (*it).second.begin(); it2!=(*it).second.end(); ++it2) {
        CaloLocalHadDefs::LocalHadDimensionId id = CaloLCCoeffHelper::getDimensionId( (*it2) );
        if(id!=CaloLocalHadDefs::DIMU_UNKNOWN) {
          vtmp->push_back(int(id));
        }else{
          ATH_MSG_WARNING( "Dimension '" << (*it2) << "' is invalid and will be excluded."  );
        }
      }
    }
  } // m_interpolate
 
  ATH_MSG_INFO( "Initializing " << name()  );
 
 
  ATH_CHECK(m_key.initialize());
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

static const InterfaceID& IClusterCellWeightTool::interfaceID ( )

inlinestaticinherited

Definition at line 28 of file IClusterCellWeightTool.h.

                                          { 
    static const InterfaceID IID_IClusterCellWeightTool("IClusterCellWeightTool", 1 , 0);
    return IID_IClusterCellWeightTool; 
  }

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

prepare_for_cluster()

StatusCode CaloLCDeadMaterialTool::prepare_for_cluster ( const xAOD::CaloCluster *  theCluster, std::vector< Area > &  areas, std::vector< Cell > &  cells, float *  smp_energy, float &  cls_unweighted_energy, const CaloLocalHadCoeff *  data  ) const

private

Definition at line 531 of file CaloLCDeadMaterialTool.cxx.

{
  areas.resize(data->getSizeAreaSet());
  cells.reserve (theCluster->size());
 
  bzero(smp_energy, CaloSampling::Unknown*sizeof(float));
 
  // Finding of energy and noise in different "areas" of cluster. Some of these
  // areas correspond to CaloSamplings, others are special.
  CaloCluster::const_cell_iterator itrCell = theCluster->cell_begin();
  CaloCluster::const_cell_iterator itrCellEnd = theCluster->cell_end();
  cls_unweighted_energy = 0;
  for (;itrCell!=itrCellEnd; ++itrCell) {
    CxxUtils::prefetchNext(itrCell, itrCellEnd);
    const CaloCell* thisCell = *itrCell;
    //Identifier id = thisCell->ID();
    CaloSampling::CaloSample nsmp=thisCell->caloDDE()->getSampling();
    //CaloSampling::CaloSample nsmp = CaloSampling::CaloSample(m_calo_id->calo_sample(id));
 
    float energy = thisCell->e();
    float weight = itrCell.weight();
    cls_unweighted_energy += energy;
 
    Cell cell{};
    cell.weight = weight;
    cell.energy = energy;
    cell.dm = sDM;
 
    smp_energy[nsmp] += energy; // unweighted energy in samplings for given cluster
 
    if(energy > m_MinCellEnergyToDeal) {
 
      if ( nsmp == CaloSampling::PreSamplerB  || nsmp == CaloSampling::EMB1) {
        cell.dm = sDM_EMB0_EMB1;
 
      } else if( nsmp == CaloSampling::TileGap3 ) {
        cell.dm = sDM_SCN;
 
      } else if ( nsmp == CaloSampling::PreSamplerE || nsmp == CaloSampling::EME1 ) {
        cell.dm = sDM_EME0_EME12;
 
      } else if (nsmp == CaloSampling::EME3) {
        cell.dm = sDM_EME3_HEC0;
 
      } else if (nsmp == CaloSampling::HEC0) {
        cell.dm = sDM_EME3_HEC0;
 
      } else if (nsmp == CaloSampling::EMB3) {
        cell.dm = sDM_EMB3_TILE0;
 
      } else if (nsmp == CaloSampling::TileBar0) {
        cell.dm = sDM_EMB3_TILE0;
      }
 
    } // cell_ener > cell_min_energy
    cells.push_back (cell);
  } // itrCell
 
//   Realculate sampling energy as the abs value of the original cluster, if you summed up energies, fluctuations wouldn't cancel and sample energy would be huge   
 if(m_absOpt){
    
    for(unsigned int i=0; i != CaloSampling::Unknown; ++ i)   smp_energy[i] = fabs(theCluster->eSample((CaloSampling::CaloSample)i));
    
  } 
  
  
  // calculation of 'signal' which will be used for DM energy estimation
  float x(0), y(0);
 
  // sDM_EMB0_EMB1: energy before EMB0 and between EMB0 and EMB1
  x = smp_energy[CaloSampling::PreSamplerB];
  if ( x > 0.) {
    areas[sDM_EMB0_EMB1].eprep = x;
    areas[sDM_EMB0_EMB1].edm_wrong = x;
  }
 
  // sDM_EMB3_TILE0: to correct energy between barrel and tile
  x = smp_energy[CaloSampling::EMB3];
  y = smp_energy[CaloSampling::TileBar0];
  if ( x > 0. && y>0.) areas[sDM_EMB3_TILE0].eprep = sqrt(x*y);
 
  // sDM_SCN: to correct energy before scintillator
  x = smp_energy[CaloSampling::TileGap3];
  if ( x > 0.) {
    areas[sDM_SCN].eprep = x;
    areas[sDM_SCN].edm_wrong = x;
  }
 
  // sDM_EME0_EME12: sum of energy before EME0 and between EME0 and EME1
  x = smp_energy[CaloSampling::PreSamplerE];
  if ( x > 0.) {
    areas[sDM_EME0_EME12].eprep = x;
    areas[sDM_EME0_EME12].edm_wrong = x;
  }
 
  // sDM_EME3_HEC0: to correct energy between EMEC and HEC
  x = smp_energy[CaloSampling::EME3];
  y = smp_energy[CaloSampling::HEC0];
  if ( x > 0. && y>0.) areas[sDM_EME3_HEC0].eprep = sqrt(x*y);
 
  areas[sDM_FCAL].eprep = cls_unweighted_energy;
  areas[sDM_LEAKAGE].eprep = cls_unweighted_energy;
  areas[sDM_UNCLASS].eprep = cls_unweighted_energy;
 
 return StatusCode::SUCCESS;
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

weight()

StatusCode CaloLCDeadMaterialTool::weight ( xAOD::CaloCluster *  thisCluster, const EventContext &  ctx  ) const

overridevirtual

method to weight the cells in a cluster

Parameters

theCluster

the pointer to the CaloCluster to be weighted

this method is purely virtual because every derived class needs to implement it.

Implements IClusterCellWeightTool.

Definition at line 138 of file CaloLCDeadMaterialTool.cxx.

{
  CaloLCCoeffHelper hp;
  CaloLocalHadCoeff::LocalHadCoeff parint;
 
  float wrong_dm_energy = 0.0;
  float dm_total = 0.0;
 
   
  double weightMom (1);
  if (!theCluster->retrieveMoment(CaloCluster::DM_WEIGHT,weightMom)) {
    ATH_MSG_WARNING ("Cannot find cluster moment DM_WEIGHT");
  }
  /* WTF?? re-setting the same moment??
  theCluster->insertMoment(CaloClusterMoment::DM_WEIGHT,CaloClusterMoment(new_weight),true); 
  */
 
  double eWeighted = theCluster->e();
 
//   // check desired reco status
//   float cls_em_fraction = 0.0;
//   if ( theCluster->checkRecoStatus(CaloRecoStatus::TAGGEDHAD)) {
//      cls_em_fraction = 0.25;
//   } else if( theCluster->checkRecoStatus(CaloRecoStatus::TAGGEDEM)) {
//     cls_em_fraction = 0.99;
//   }else {
//     log << MSG::DEBUG<<"Cluster was not selected for local DM calibration. Cluster reco status differs from TAGGEDHAD or TAGGEDEM."
//         << " Cluster energy " << theCluster->e() << " remains the same." << endmsg;
// #ifdef MAKE_MOMENTS
//     set_zero_moments(theCluster);
// #endif
//     return StatusCode::SUCCESS;
//   }
 
  if ( theCluster->e() <= m_MinClusterEnergyToDeal) {
    ATH_MSG_DEBUG("Cluster was not selected for local DM calibration, ecls < m_MinClusterEnergyToDeal (=" <<m_MinClusterEnergyToDeal << ").");
#ifdef MAKE_MOMENTS
    set_zero_moments(theCluster);
#endif
    return StatusCode::SUCCESS;
  }
 
  double pi0Prob = 0;
  if ( m_useHadProbability) {
    if (!theCluster->retrieveMoment(CaloCluster::EM_PROBABILITY,pi0Prob)) {
      ATH_MSG_ERROR("Cannot retrieve EM_PROBABILITY cluster moment, "
                    << " cluster energy " << theCluster->e() << " remains the same."  );
      return StatusCode::FAILURE;
    }
    if ( pi0Prob < 0 ) {
      pi0Prob = 0;
    } else if ( pi0Prob > 1 ) {
      pi0Prob = 1;
    }
  } else if (theCluster->recoStatus().checkStatus(CaloRecoStatus::TAGGEDEM)) {
    pi0Prob = 1;
  }
 
  double center_lambda = 0;
  if ( !theCluster->retrieveMoment(CaloCluster::CENTER_LAMBDA, center_lambda) ){
    ATH_MSG_ERROR("Cannot retrieve CENTER_LAMBDA cluster moment, "
                  << " cluster energy " << theCluster->e() << " remains the same."  );
    return StatusCode::FAILURE;
  }
 
  const CaloLocalHadCoeff* data(nullptr);
  SG::ReadCondHandle<CaloLocalHadCoeff> rch(m_key,ctx);
  data = *rch;
  if(data==nullptr) {
    ATH_MSG_ERROR("Unable to access conditions object");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Cluster is selected for local DM calibration."
        << " Old cluster energy:" << theCluster->e() 
        << " m_weightModeDM:" << m_weightModeDM);
 
  // calculation of specific cluster quantities for DM correction (i.e. core of procedure)
  std::vector<Area> areas;
  std::vector<Cell> cells;
  float smp_energy[CaloSampling::Unknown];
  float cls_unweighted_energy = 0;
  StatusCode sc = prepare_for_cluster(theCluster, areas, cells,
                                      smp_energy, cls_unweighted_energy, data);
  if ( !sc.isSuccess() ) {
#ifdef MAKE_MOMENTS
    set_zero_moments(theCluster);
#endif
    ATH_MSG_ERROR(  "prepare for cluster failed!"  );
    return sc;
  }
 
  float cls_initial_energy =  theCluster->e();
  float cls_side = (theCluster->eta()<0?-1.0:1.0);
  float cls_eta = fabs(theCluster->eta());
  float cls_phi = theCluster->phi();
  float log10ener = 0.0;
  if(cls_unweighted_energy > 0.0) {
    log10ener = log10(cls_unweighted_energy);
  }
  float log10lambda;
  if(center_lambda > 0.0) {
    log10lambda = log10(center_lambda);
    if(log10lambda >=4.0) log10lambda = 3.9999;
  }else{
    log10lambda = 0.0;
  }
#ifdef DEBUG_DMTHINGS
  std::cout << " cls_initial_energy: " << cls_initial_energy << " cls_eta: " << cls_eta << std::endl;
  std::cout << " log10ener: " << log10ener << " log10lambda: " << log10lambda << std::endl;
  for(int i_smp=0; i_smp<CaloSampling::Unknown; i_smp++){
    std::cout << " i_smp: " << i_smp << " smp_energy: " << smp_energy[i_smp] << std::endl;
  }
#endif
 
  std::vector<float > vars;
  vars.resize(6, 0.0);
  vars[CaloLocalHadDefs::DIMD_EMFRAC] = pi0Prob;
  vars[CaloLocalHadDefs::DIMD_SIDE] = cls_side;
  vars[CaloLocalHadDefs::DIMD_ETA] = cls_eta;
  vars[CaloLocalHadDefs::DIMD_PHI] = cls_phi;
  vars[CaloLocalHadDefs::DIMD_ENER] = log10ener;
  vars[CaloLocalHadDefs::DIMD_LAMBDA] = log10lambda;
 
  size_t n_dm = data->getSizeAreaSet();
 
  // loop over HAD/EM possibilities for mixing different correction types
  for(int i_mix=0; i_mix<2; i_mix++){ // 0 - pure HAD case, 1-pure EM case
    float mixWeight = (i_mix==0?(1-pi0Prob):pi0Prob);
    if(mixWeight == 0) continue;
 
    vars[CaloLocalHadDefs::DIMD_EMFRAC] = float(i_mix);
 
    // loop over DM areas defined and calculation of cluster DM energy deposited in these areas
    for(size_t i_dm=0; i_dm < n_dm; i_dm++){
      if(areas[i_dm].eprep <= 0.0) continue; // no appropriate signal to reconstruct dm energy in this area
 
      const CaloLocalHadCoeff::LocalHadArea *area = data->getArea(i_dm);
      float emax = area->getDimension(CaloLocalHadDefs::DIMD_ENER)->getXmax();
      if(log10ener > emax) log10ener = emax - 0.0001;
      vars[CaloLocalHadDefs::DIMD_ENER] = log10ener;
 
      const CaloLocalHadCoeff::LocalHadCoeff *pars = data->getCoeff(i_dm, vars);
      if( !pars ) continue;
 
      float edm = 0.0;
      // if dm area is reconstructed using polynom fit approach
      if(area->getType() == CaloLocalHadDefs::AREA_DMFIT) {
        edm = (*pars)[CaloLocalHadDefs::BIN_P0] + (*pars)[CaloLocalHadDefs::BIN_P1]*areas[i_dm].eprep;
        if(m_interpolate) {
          bool isa = CaloLCCoeffHelper::Interpolate(data, i_dm, vars, parint, m_interpolateDimensionsFit, areas[i_dm].eprep);
          // calculation of fitted values is done already in the interpolator
          if(isa) edm = parint[CaloLocalHadDefs::BIN_P0];
        }
 
      // if dm area is reconstructed using lookup table approach
      }else if(area->getType() == CaloLocalHadDefs::AREA_DMLOOKUP){
        if( (*pars)[CaloLocalHadDefs::BIN_ENTRIES] > m_MinLookupBinNentry) edm = cls_unweighted_energy*((*pars)[CaloLocalHadDefs::BIN_WEIGHT] - 1.0 );
        if(m_interpolate) {
          bool isa = CaloLCCoeffHelper::Interpolate(data, i_dm, vars, parint, m_interpolateDimensionsLookup);
          if(isa && parint[CaloLocalHadDefs::BIN_ENTRIES] > m_MinLookupBinNentry) edm = cls_unweighted_energy*(parint[CaloLocalHadDefs::BIN_WEIGHT] - 1.0 );
        }
 
      // if dm area is reconstructed using new sampling weights
      }else if(area->getType() == CaloLocalHadDefs::AREA_DMSMPW){
    const int nSmp=pars->size()-1;
    //std::cout << "size=" << nSmp << ", unkown value=" << CaloSampling::Unknown << ", minifcal=" << CaloSampling::MINIFCAL0 << std::endl;
        double ecalonew = 0.0;
        double ecaloold = 0.0;
        for(int i_smp=0; i_smp<nSmp; i_smp++){
          ecaloold += smp_energy[i_smp];
          ecalonew += smp_energy[i_smp] * (*pars)[i_smp];
        }
        ecalonew += (*pars)[nSmp]; // const Used to be CaloSampling::Unknown but the value of this enum has changed to include the miniFCAL. 
        edm = ecalonew - ecaloold;
 
//         if(m_interpolate) {
//           bool isa = hp.Interpolate(data, i_dm, vars, parint, m_interpolateDimensionsSampling);
//           if(isa) {
//             ecalonew = 0.0;
//             ecaloold = 0.0;
//             for(int i_smp=0; i_smp<CaloSampling::Unknown; i_smp++){
//               ecaloold += smp_energy[i_smp];
//               ecalonew += smp_energy[i_smp] * parint[i_smp];
//             }
//             ecalonew += parint[CaloSampling::Unknown]; // const
//             edm = ecalonew - ecaloold;
//           }
//         }
 
      } else{
        std::cout << "CaloLCDeadMaterialTool -> Error! Unknown correction type " << area->getType() 
          << " with number of parameters " << area->getNpars() << std::endl;
      }
      wrong_dm_energy += areas[i_dm].edm_wrong;
 
#ifdef DEBUG_DMTHINGS
      std::cout << "   result> edm: " << edm << " edm_wrong:" << edm_wrong << std::endl;
#endif
      edm -= areas[i_dm].edm_wrong;
      if(edm > 0.0) {
        areas[i_dm].erec = areas[i_dm].erec + edm*mixWeight;
        dm_total += edm;
      }
    } // i_dm
  } // i_mix
 
  // giving of calculated DM energy to cluster by one of 3 methods
  // m_weightModeDM=0 - simple setting of cluster energy to new value
  // m_weightModeDM=1 - changing (increasing) of weights of cluster cells
  // m_weightModeDM=2 - changing (increasing) of weights of cluster cells (which were invloved into DM calculation)
 
#ifdef DEBUG_DMTHINGS
  std::cout << "wc> calculation of weights" << std::endl;
#endif
 
  if(dm_total > 0.0) {
    if (m_weightModeDM == 0) {
      // method 0: setting cluster energy to new value without changing of cells weights
      theCluster->setE(cls_initial_energy + dm_total - wrong_dm_energy);
 
    } else if (m_weightModeDM == 1) {
      // method1: calculation of weights of all cluster cells to treat DM energy.
      // Weights of all cluster cells will be changed proportionally
      float sub_ener_old = 0.0;
      for(size_t i_c = 0; i_c < cells.size(); i_c++)
      {
        const Cell& cell = cells[i_c];
        if (cell.energy <= m_MinCellEnergyToDeal) continue;
        sub_ener_old += cell.weight*cell.energy;
      }
      if(sub_ener_old > 0.0) {
        float corr = (sub_ener_old + dm_total)/sub_ener_old;
        for(size_t i_c = 0; i_c < cells.size(); i_c++)
        {
          if(cells[i_c].energy <= m_MinCellEnergyToDeal) continue;
          cells[i_c].weight *= corr;
        }
      }
 
    } else if (m_weightModeDM == 2) {
      // method2: calculation of weights of all cluster cells to treat DM energy.
      // only weights for cells involved into DM calculation will be changed
 
      for (size_t cell_index = 0; cell_index < cells.size(); ++cell_index)
      {
        const Cell& cell = cells[cell_index];
        if (cell.energy <= m_MinCellEnergyToDeal) continue;
        float we = cell.weight * cell.energy;
        if (cell.dm != sDM)
          areas[cell.dm].sub_ener_old += we;
        areas[sDM_FCAL].sub_ener_old += we;
        areas[sDM_LEAKAGE].sub_ener_old += we;
        areas[sDM_UNCLASS].sub_ener_old += we;
      }
 
      for(size_t i_dm=0; i_dm < areas.size(); i_dm++) {
        Area& dma = areas[i_dm];
        float corrfac = 1;
        if (i_dm >= n_dm || dma.eprep <= 0)
          corrfac = 1;
        else if (dma.sub_ener_old > 0)
          corrfac = (dma.sub_ener_old + dma.erec) / dma.sub_ener_old;
 
        if (i_dm < sDM_FCAL)
          areas[sDM_FCAL].sub_ener_old += (corrfac-1)*dma.sub_ener_old;
        if (i_dm < sDM_LEAKAGE)
          areas[sDM_LEAKAGE].sub_ener_old += (corrfac-1)*dma.sub_ener_old;
        if (i_dm < sDM_UNCLASS)
          areas[sDM_UNCLASS].sub_ener_old += (corrfac-1)*dma.sub_ener_old;
 
        dma.corr = corrfac;
      }
 
      float gblfac = areas[sDM_FCAL].corr * areas[sDM_LEAKAGE].corr * areas[sDM_UNCLASS].corr;
      for (size_t cell_index = 0; cell_index < cells.size(); ++cell_index)
      {
        Cell& cell = cells[cell_index];
        if (cell.energy <= m_MinCellEnergyToDeal) continue;
        if (cell.dm != sDM)
          cell.weight *= areas[cell.dm].corr;
        cell.weight *= gblfac;
      }
    } else {
      ATH_MSG_ERROR( "Unknown m_weightModeDM " << m_weightModeDM  );
    }
 
    // setting of calculated weights to the cluster cells
    if (m_weightModeDM == 1 || m_weightModeDM == 2){
      int cell_index = 0;
      CaloCluster::cell_iterator itrCell = theCluster->cell_begin();
      CaloCluster::cell_iterator itrCellEnd = theCluster->cell_end();
      for (;itrCell!=itrCellEnd; ++itrCell) {
        //CaloPrefetch::nextDDE(itrCell, itrCellEnd); no DDE info needed
        const float old_weight = itrCell.weight();
        float new_weight = cells[cell_index].weight;
        if( new_weight < m_MaxChangeInCellWeight*old_weight ){
          theCluster->reweightCell(itrCell, new_weight);
        }else{
          new_weight = old_weight; //Why that? Just for the printout below?
        }
#ifdef DEBUG_DMTHINGS
        std::cout << "    cells> " << cell_index << " ener: " << cells[cell_index].energy << " old_w: " << old_weight << " new_w:" << new_weight << std::endl;
        if( new_weight > 100) std::cout << "DeadMaterialCorrectionTool2 -> Panic! Too large weight" << std::endl;
#endif
        cell_index++;
      }//end loop over cells
      CaloClusterKineHelper::calculateKine(theCluster,true,m_updateSamplingVars);
    }//end if method 1 or 2
 
  } // dm_total > 0.0
 
  ATH_MSG_DEBUG("cls_initial_energy: " << cls_initial_energy 
        << " (contains wrongly estimated DM energy: " << wrong_dm_energy << ")"
        << " calculated DM energy (to be added):" << dm_total
        << " new cluster energy:" << theCluster->e());
 
#ifdef MAKE_MOMENTS
  // to save reconstructed energy in different DM areas as cluster moments
  CaloCluster::MomentType xtype = CaloCluster::ENG_CALIB_DEAD_TOT;
  double xmom;
  bool result = theCluster->retrieveMoment(xtype, xmom, false);
 
  if(result) {
    double x;
    bool useLink = true;
 
    x = (double)smp_energy[CaloSampling::PreSamplerB];
    theCluster->insertMoment(CaloCluster::ENG_RECO_EMB0, x);
 
    x = (double)smp_energy[CaloSampling::PreSamplerE];
    theCluster->insertMoment(CaloCluster::ENG_RECO_EME0, x);
 
    x = (double)smp_energy[CaloSampling::TileGap3];
    theCluster->insertMoment(CaloCluster::ENG_RECO_TILEG3, x);
 
    x = (double)(dm_total+wrong_dm_energy);
    theCluster->insertMoment(CaloCluster::ENG_RECO_DEAD_TOT, x);
 
    for(size_t i_dm=0; i_dm < areas.size(); i_dm++) {
      Area& dma = areas[i_dm];
      CaloCluster::MomentType m_type = (CaloCluster::MomentType) (int(CaloCluster::ENG_RECO_DEAD_EMB0)+i_dm);
      x = (double)dma.erec;
      if(i_dm == sDM_EMB0_EMB1 && smp_energy[CaloSampling::PreSamplerB]>0.0) x+= smp_energy[CaloSampling::PreSamplerB];
      if(i_dm == sDM_EME0_EME12 && smp_energy[CaloSampling::PreSamplerE] > 0.0) x+= smp_energy[CaloSampling::PreSamplerE];
      if(i_dm == sDM_SCN && smp_energy[CaloSampling::TileGap3] > 0.0) x+= smp_energy[CaloSampling::TileGap3];
      theCluster->insertMoment(m_type, CaloClusterMoment(x));
    }
  }
 
#endif
 
  // assume that the weighting could be called more than once. In that
  // case eWeighted is the result of the previous step and the current
  // e/eWeighted ratio should be multiplied with the existing
  // DM_WEIGHT moment
 
  if ( eWeighted > 0 || eWeighted < 0 ) {
    weightMom *= theCluster->e()/eWeighted;
  }
  theCluster->insertMoment(CaloCluster::DM_WEIGHT,weightMom); 
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_absOpt

bool CaloLCDeadMaterialTool::m_absOpt

private

In Abs Option case, DM calculation has to be handled in a slightly different way.

Definition at line 160 of file CaloLCDeadMaterialTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_interpolate

bool CaloLCDeadMaterialTool::m_interpolate

private

interpolate correction coefficients

Definition at line 138 of file CaloLCDeadMaterialTool.h.

m_interpolateDimensionNames

std::map<std::string, std::vector<std::string > > CaloLCDeadMaterialTool::m_interpolateDimensionNames

private

vector of names of dimensions to interpolate (for different correction types different set of dimensions)

Definition at line 146 of file CaloLCDeadMaterialTool.h.

m_interpolateDimensionsFit

std::vector<int > CaloLCDeadMaterialTool::m_interpolateDimensionsFit

private

actual set of dimension id's to interpolate (in the DM areas corrected with TProfile approach)

Definition at line 150 of file CaloLCDeadMaterialTool.h.

m_interpolateDimensionsLookup

std::vector<int > CaloLCDeadMaterialTool::m_interpolateDimensionsLookup

private

actual set of dimension id's to interpolate (in the DM areas corrected with lookup approach)

Definition at line 153 of file CaloLCDeadMaterialTool.h.

m_interpolateDimensionsSampling

std::vector<int > CaloLCDeadMaterialTool::m_interpolateDimensionsSampling

private

actual set of dimension id's to interpolate (in the DM areas corrected with sampling weight approach)

Definition at line 156 of file CaloLCDeadMaterialTool.h.

m_key

SG::ReadCondHandleKey<CaloLocalHadCoeff> CaloLCDeadMaterialTool::m_key

private

name of the key for DM cell weights

Definition at line 97 of file CaloLCDeadMaterialTool.h.

m_MaxChangeInCellWeight

float CaloLCDeadMaterialTool::m_MaxChangeInCellWeight

private

maximum allowed change in cell weights

Definition at line 125 of file CaloLCDeadMaterialTool.h.

m_MinCellEnergyToDeal

float CaloLCDeadMaterialTool::m_MinCellEnergyToDeal

private

minimum cell energy to deal

Definition at line 121 of file CaloLCDeadMaterialTool.h.

m_MinClusterEnergyToDeal

float CaloLCDeadMaterialTool::m_MinClusterEnergyToDeal

private

Minimum energy of clusters to apply correction.

Definition at line 113 of file CaloLCDeadMaterialTool.h.

m_MinLookupBinNentry

int CaloLCDeadMaterialTool::m_MinLookupBinNentry

private

minimum number of events in one lookup bin to use

Definition at line 117 of file CaloLCDeadMaterialTool.h.

m_recoStatus

int CaloLCDeadMaterialTool::m_recoStatus

private

Required Reco Status for the clusters in order to be calibrated.

Definition at line 101 of file CaloLCDeadMaterialTool.h.

m_updateSamplingVars

bool CaloLCDeadMaterialTool::m_updateSamplingVars

private

update also sampling variables

Definition at line 142 of file CaloLCDeadMaterialTool.h.

m_useHadProbability

bool CaloLCDeadMaterialTool::m_useHadProbability

private

calculate DM energy using em-probability moment

The classification provides the probability p for the current cluster to be em-like. Dead material enegry of cluster is calculated as a mixture of DM energies for pure EM and pure HAD clusters using p as engDM = p *engDM_EM+(1-p)*endDM_HAD

Definition at line 134 of file CaloLCDeadMaterialTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_weightModeDM

int CaloLCDeadMaterialTool::m_weightModeDM

private

method of assignment of DM energy to cluster

if 0: setting cluster energy to the new value without changing of cells weights if 1: weights of all cells in the cluster with energy > m_MinCellEnergyToDeal will be changed if 2: changing only weights of cells which have been involved into DM calculation

Definition at line 109 of file CaloLCDeadMaterialTool.h.

---

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

• CaloLCDeadMaterialTool.h
• CaloLCDeadMaterialTool.cxx