CaloLCClassificationTool Class Reference

classify clusters according to their probability to stem from an em object More...

#include <CaloLCClassificationTool.h>

Inheritance diagram for CaloLCClassificationTool:

Collaboration diagram for CaloLCClassificationTool:

Public Member Functions
virtual	~CaloLCClassificationTool ()
virtual CaloRecoStatus::StatusIndicator	classify (xAOD::CaloCluster *thisCluster) const override
	method to return the classification status of a cluster.
virtual StatusCode	initialize () override
	CaloLCClassificationTool (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.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () 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
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< CaloLocalHadCoeff >	m_key {this, "ClassificationKey", "EMFracClassify"}
	name of the key for em fraction data
Gaudi::Property< bool >	m_useSpread {this, "UseSpread", false}
	if set to true the spread of EM probabilities in each bin is taken into account for classification otherwise only the mean is used
Gaudi::Property< bool >	m_useNormalizedEnergyDensity {this, "UseNormalizedEnergyDensity", true}
	old data depends on energy density while new data depends on energy density over energy.
Gaudi::Property< double >	m_maxProbability {this, "MaxProbability", 0.5}
	cut value on EM probability below which all clusters are classified as hadronic
Gaudi::Property< bool >	m_storeClassificationProbabilityInAOD {this, "StoreClassificationProbabilityInAOD", true}
	if true the phase space probability based on single pions that the current cluster stems from a pi0 is saved on AOD as a moment.
Gaudi::Property< bool >	m_interpolate {this, "Interpolate", false}
	interpolate correction coefficients
Gaudi::Property< std::vector< std::string > >	m_interpolateDimensionNames
	vector of names of dimensions in look-up tables to interpolate
std::vector< int >	m_interpolateDimensions
	actual set of dimension id's to interpolate
Gaudi::Property< bool >	m_absOpt {this, "WeightingOfNegClusters", false}
	is set to true, classify neg.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

classify clusters according to their probability to stem from an em object

Version

$Id: CaloLCClassificationTool.h,v 1.6 2009-01-27 09:09:14 gunal Exp $

Author

Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de

Date

27-September-2005

concrete class implementing a IClusterClassificationTool to classify clusters according to their probability to be caused by an electromagnetic decaying particle or shower. Clusters with high em probability should not be weighted. This tool reads its data from pool containing TProfile2D based em-probability data.

Definition at line 28 of file CaloLCClassificationTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~CaloLCClassificationTool()

CaloLCClassificationTool::~CaloLCClassificationTool ( )

virtualdefault

CaloLCClassificationTool()

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

Definition at line 30 of file CaloLCClassificationTool.cxx.

  : AthAlgTool(type,name,parent)
{ 
  declareInterface<IClusterClassificationTool>(this);
}

Member Function Documentation

classify()

CaloRecoStatus::StatusIndicator CaloLCClassificationTool::classify ( xAOD::CaloCluster * thisCluster ) const

overridevirtual

method to return the classification status of a cluster.

Parameters

theCluster

the pointer to the CaloCluster to be classified

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

Implements IClusterClassificationTool.

Definition at line 63 of file CaloLCClassificationTool.cxx.

{
  const CaloLocalHadCoeff* condObject(nullptr);
  SG::ReadCondHandle<CaloLocalHadCoeff> rch(m_key);
  condObject = *rch;
  if(condObject==nullptr) {
    ATH_MSG_ERROR("Unable to access conditions object");
    return CaloRecoStatus::TAGGEDUNKNOWN;
  }
 
  CaloLCCoeffHelper hp;
  CaloLocalHadCoeff::LocalHadCoeff parint;
 
  CaloRecoStatus::StatusIndicator recStat = CaloRecoStatus::TAGGEDUNKNOWN; 
  double probPi0 = 0;
  // on ESD only
  std::vector<float> vars(6);
  if ( thisCluster->e() > 0 || m_absOpt ) { //with abs option, always weight cluster
    double log10cluse = log10(thisCluster->e());
    if( m_absOpt ) log10cluse = log10(fabs(thisCluster->e()));
    double log10cluseOrig = log10cluse;
    
    const CaloLocalHadCoeff::LocalHadDimension *logeDim = condObject->getArea(0)->getDimension(3);
    double lemax = logeDim->getXmax()-0.5*logeDim->getDx();
    double lemin = logeDim->getXmin()+0.5*logeDim->getDx();
    if ( log10cluse > lemax ) 
      log10cluse = lemax;
    if ( log10cluse < lemin ) 
      log10cluse = lemin;
    
    double m1_dens,center_lambda;
    //Fixme ... check moavailability ..
    if (thisCluster->retrieveMoment(CaloCluster::FIRST_ENG_DENS,m1_dens) &&
    thisCluster->retrieveMoment(CaloCluster::CENTER_LAMBDA,center_lambda)) { 
      if ( m1_dens > 0  &&  center_lambda > 0) {
    const double abseta = fabs(thisCluster->eta());
    double log10edens = log10(m1_dens);
    if ( m_useNormalizedEnergyDensity ) log10edens -= log10cluseOrig;
    double log10lambda = log10(center_lambda);
 
    vars[CaloLocalHadDefs::DIMC_SIDE]   = static_cast<float> ((thisCluster->eta()<0?-1.0:1.0));
    vars[CaloLocalHadDefs::DIMC_ETA]    = static_cast<float> (abseta);
    vars[CaloLocalHadDefs::DIMC_PHI]    = static_cast<float> (thisCluster->phi());
    vars[CaloLocalHadDefs::DIMC_ENER]   = static_cast<float> (log10cluse);
    vars[CaloLocalHadDefs::DIMC_EDENS]  = static_cast<float> (log10edens);
    vars[CaloLocalHadDefs::DIMC_LAMBDA] = static_cast<float> (log10lambda);
 
    bool isDataOK = false;
    double emProb(0);
 
    int iBin = condObject->getBin(0,vars);
    if ( iBin >= 0 ) {
      const CaloLocalHadCoeff::LocalHadCoeff * pData = condObject->getCoeff(iBin);
      if ( pData && (*pData)[CaloLocalHadDefs::BIN_ENTRIES] > 0 ) {
        isDataOK = true;
        emProb = (*pData)[CaloLocalHadDefs::BIN_WEIGHT];
        if (m_useSpread) {
          double emErr = sqrt((*pData)[CaloLocalHadDefs::BIN_ENTRIES])*(*pData)[CaloLocalHadDefs::BIN_ERROR];
          emProb += emErr;
        }
 
        if(m_interpolate) {
          // accesing interpolated coefficients
          bool isa = CaloLCCoeffHelper::Interpolate(condObject, 0,vars,parint, m_interpolateDimensions);
          if(isa) {
        if ( parint[CaloLocalHadDefs::BIN_ENTRIES] > 0 ) {
          isDataOK = true;
          emProb = parint[CaloLocalHadDefs::BIN_WEIGHT];
          if (m_useSpread) {
            double emErr = sqrt(parint[CaloLocalHadDefs::BIN_ENTRIES])*parint[CaloLocalHadDefs::BIN_ERROR];
            emProb += emErr;
          }
        }
          }//end if isa
        }//end if m_interpolate
      } //end if pData
    } //end if iBin
 
    if(isDataOK) {
      probPi0 = emProb;
      if ( emProb < m_maxProbability )
        recStat = CaloRecoStatus::TAGGEDHAD;
      else 
        recStat = CaloRecoStatus::TAGGEDEM;
    }
 
      } // if >0
    } //if got sucessfully retrieved moments
    else {
      ATH_MSG_ERROR( "Can not retrieve one or more of the cluster moments "
                     << "CENTER_LAMBDA, FIRST_ENG_DENS for current cluster"
                     << "- classification not possible - "
                     << "you need to enable those moments in the cluster maker!"
                     );
      recStat = CaloRecoStatus::TAGGEDUNKNOWN;
    } 
  }
  
  thisCluster->insertMoment(CaloCluster::EM_PROBABILITY,probPi0);
  thisCluster->insertMoment(CaloCluster::HAD_WEIGHT,1.0);
  thisCluster->insertMoment(CaloCluster::OOC_WEIGHT,1.0);
  thisCluster->insertMoment(CaloCluster::DM_WEIGHT,1.0);
 
  return recStat;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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()

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

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 CaloLCClassificationTool::initialize ( )

overridevirtual

Definition at line 38 of file CaloLCClassificationTool.cxx.

{
  ATH_MSG_INFO( "Initializing " << name()  );
 
  ATH_CHECK( m_key.initialize() );
 
  if(m_interpolate) {
    msg(MSG::INFO) << "Interpolation is ON, dimensions: ";
    for(std::vector<std::string>::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      msg() << " " << (*it);
    }
    msg() << endmsg;
    for(std::vector<std::string>::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      CaloLocalHadDefs::LocalHadDimensionId id = CaloLCCoeffHelper::getDimensionId( (*it) );
      if(id!=CaloLocalHadDefs::DIMU_UNKNOWN) {
        m_interpolateDimensions.push_back(int(id));
      }else{
        ATH_MSG_WARNING( "Dimension '" << (*it) << "' is invalid and will be excluded."  );
      }
    }
  }
 
  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()

const InterfaceID & IClusterClassificationTool::interfaceID ( )

inlinestaticinherited

Definition at line 28 of file IClusterClassificationTool.h.

                                          { 
    static const InterfaceID IID_IClusterClassificationTool("IClusterClassificationTool", 1 , 0);
    return IID_IClusterClassificationTool; 
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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.

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

Member Data Documentation

m_absOpt

Gaudi::Property<bool> CaloLCClassificationTool::m_absOpt {this, "WeightingOfNegClusters", false}

private

is set to true, classify neg.

Clusters as well

Definition at line 115 of file CaloLCClassificationTool.h.

{this, "WeightingOfNegClusters", false};

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

Gaudi::Property<bool> CaloLCClassificationTool::m_interpolate {this, "Interpolate", false}

private

interpolate correction coefficients

Definition at line 100 of file CaloLCClassificationTool.h.

{this, "Interpolate", false};

m_interpolateDimensionNames

Gaudi::Property<std::vector<std::string> > CaloLCClassificationTool::m_interpolateDimensionNames

private

Initial value:

{this, "InterpolateDimensionNames"
    , {"DIMC_ETA", "DIMC_EDENS", "DIMC_LAMBDA"}}

vector of names of dimensions in look-up tables to interpolate

Definition at line 104 of file CaloLCClassificationTool.h.

                                                                  {this, "InterpolateDimensionNames"
    , {"DIMC_ETA", "DIMC_EDENS", "DIMC_LAMBDA"}};

m_interpolateDimensions

std::vector<int> CaloLCClassificationTool::m_interpolateDimensions

private

actual set of dimension id's to interpolate

Definition at line 110 of file CaloLCClassificationTool.h.

m_key

SG::ReadCondHandleKey<CaloLocalHadCoeff> CaloLCClassificationTool::m_key {this, "ClassificationKey", "EMFracClassify"}

private

name of the key for em fraction data

Definition at line 47 of file CaloLCClassificationTool.h.

{this, "ClassificationKey", "EMFracClassify"};

m_maxProbability

Gaudi::Property<double> CaloLCClassificationTool::m_maxProbability {this, "MaxProbability", 0.5}

private

cut value on EM probability below which all clusters are classified as hadronic

Useful values are around 0.5. Clusters in Bins with an average EM probability below this cut value are tagged as hadronic. Clusters in Bins with an average EM probability above this value are considered electromagnetic and clusters falling in bins with no information are tagged as unknown.

Definition at line 83 of file CaloLCClassificationTool.h.

{this, "MaxProbability", 0.5};

m_storeClassificationProbabilityInAOD

Gaudi::Property<bool> CaloLCClassificationTool::m_storeClassificationProbabilityInAOD {this, "StoreClassificationProbabilityInAOD", true}

private

if true the phase space probability based on single pions that the current cluster stems from a pi0 is saved on AOD as a moment.

If false the moment goes to ESD only.

Classification histos report this quantity. The subsequent calibration functions can retrieve this probability if stored as moment and weight the respective calibration by this (or 1 minus it) to avoid overcorrections.

Definition at line 95 of file CaloLCClassificationTool.h.

{this, "StoreClassificationProbabilityInAOD", true};

m_useNormalizedEnergyDensity

Gaudi::Property<bool> CaloLCClassificationTool::m_useNormalizedEnergyDensity {this, "UseNormalizedEnergyDensity", true}

private

old data depends on energy density while new data depends on energy density over energy.

This bool is needed to switch.

Classification histos have energy density or normalized energy density for the x-axis. The old cond data is not normalized which causes problems for neutral pions. The new cond data is and this switch selects the proper normalization for the tool.

Definition at line 71 of file CaloLCClassificationTool.h.

{this, "UseNormalizedEnergyDensity", true};

m_useSpread

Gaudi::Property<bool> CaloLCClassificationTool::m_useSpread {this, "UseSpread", false}

private

if set to true the spread of EM probabilities in each bin is taken into account for classification otherwise only the mean is used

For some regions of phase space the spread in the EM probability values can be quite large. If this property is set to true the EM probability which is maximaly consistent with the current bin is calculated (mean+spread) and in case the property is false just the mean is used to estimate the EM probability.

Definition at line 60 of file CaloLCClassificationTool.h.

{this, "UseSpread", false};

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.

---

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

• CaloLCClassificationTool.h
• CaloLCClassificationTool.cxx