CaloClusterCellWeightCalib Class Reference

Tool calculates alternative cluster calibration using an external cell weight tool with interface ICellWeightTool . More...

#include <CaloClusterCellWeightCalib.h>

Inheritance diagram for CaloClusterCellWeightCalib:

Collaboration diagram for CaloClusterCellWeightCalib:

Public Member Functions
	CaloClusterCellWeightCalib (const std::string &type, const std::string &name, const IInterface *pParent)
	Algorithm tool constructor.
virtual	~CaloClusterCellWeightCalib () override
	Base tool destructor.
virtual StatusCode	initialize () override
	Tool initialization.
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloCluster *theCluster) const override
	Execute on a single cluster.
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const
	Tool execution.
virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters.
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
	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Standard Gaudi interface ID method.

Protected Types
typedef StatusCode(CaloClusterCellWeightCalib::*	CALCULATOR) (xAOD::CaloCluster *pClus) const
	Processor type for cluster calibration.

Protected Member Functions
StatusCode	f_dirRaw (xAOD::CaloCluster *pClus) const
	Calculator implementation for energy only update.
StatusCode	f_dirRawNW (xAOD::CaloCluster *pClus) const
	Calculator implementation for energy only update.
StatusCode	f_dirPos (xAOD::CaloCluster *pClus) const
	Calculator implementation for direction from positive signal.
StatusCode	f_dirPosNW (xAOD::CaloCluster *pClus) const
	Calculator implementation for direction from positive signal.
StatusCode	f_dirAbs (xAOD::CaloCluster *pClus) const
	Calculator implementation for direction from absolute signal.
StatusCode	f_dirAbsNW (xAOD::CaloCluster *pClus) const
	Calculator implementation for direction from absolute signal.
StatusCode	setupAll (MsgStream &report)
	Setup for calculation for all or non-noise clusters.
StatusCode	setupSpc (MsgStream &report)
	Setup for different calculation for noise clusters.
bool	setup (const std::string &name, const std::string &tag, CALCULATOR &calc, std::string &conf, MsgStream &report)
	Common setup function.
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.

Static Protected Member Functions
static bool	cmpNoCase (const std::string &a, const std::string &b)
	Helper for non-case sensitive string comparison.

Protected Attributes
std::string	m_directionCalculation
	Property controlling negative signal handling.
bool	m_calibNoiseLikeAll
	Property controlling calibration of noise clusters.
std::string	m_noiseDirectionCalculation
	Property controlling calibration method for noise clusters.
double	m_eThreshold
	Energy threshold for direction calculation.
bool	m_ignoreGeoWghts
	Flag to ignore geometrical cell weights in clusters.
ToolHandle< ICellWeightTool >	m_cellWeight
	Handle for cell weight tool.
CALCULATOR	m_calc
	Pointer to direction calculation implementation.
CALCULATOR	m_calc_noise
	Pointer to direction calculation for noise clusters.

Static Protected Attributes
static const std::string	m_defName = m_absName
	Negative signal handling: default tag.
static const std::string	m_posName = "Signal"
	Negative signal handling: positive signal tag.
static const std::string	m_absName = "AbsSignal"
	Negative signal handling: absolute signal tag.
static const std::string	m_rawName = "RawSignal"
	Negative signal handling: raw signal tag.

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

Tool calculates alternative cluster calibration using an external cell weight tool with interface ICellWeightTool .

It only modifies the cluster 4-vector from alternative calibration, i.e. it switches the CaloCluster to signal state P4SignalState::ALTCALIBRATED and puts the result of the cell weight calibration into this state. Previously set alternative calibrations are overwritten, but the basic (P4SignalState::UNCALIBRATED ) and (local hadronic) calibrated (P4SignalState::CALIBRATED ) are not changed. The cluster is returned to the signal state it has been received in. Even though with this behaviour the tool could run at any time in the cluster algorithm, it should run right after the cluster formation, i.e. it should be the first calibration/correction tool, as it is using the geometrical weights, which are lost in local hadronic calibration. Note that the tool can be configured to ignore these weights, but this can lead to unexpected signal calibrations.

Definition at line 16 of file CaloClusterCellWeightCalib.h.

Member Typedef Documentation

CALCULATOR

typedef StatusCode(CaloClusterCellWeightCalib::* CaloClusterCellWeightCalib::CALCULATOR) (xAOD::CaloCluster *pClus) const

protected

Processor type for cluster calibration.

Processor implementation for all clusters

Processor implementation for dedicated noise cluster treatment

Pointer to cluster processor

Calculator type for direction calculation

Definition at line 116 of file CaloClusterCellWeightCalib.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CaloClusterCellWeightCalib()

CaloClusterCellWeightCalib::CaloClusterCellWeightCalib	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pParent )

Algorithm tool constructor.

Definition at line 31 of file CaloClusterCellWeightCalib.cxx.

  : CaloClusterProcessor(type,name,pParent)
  , m_directionCalculation(m_defName)
  , m_calibNoiseLikeAll(true)
  , m_noiseDirectionCalculation(m_defName)
  , m_eThreshold(0.)
  , m_ignoreGeoWghts(false)
  , m_cellWeight(this)
  , m_calc(nullptr)
  , m_calc_noise(nullptr)
{
  declareProperty("Direction",                m_directionCalculation);
  declareProperty("BelowThresholdLikeAll",    m_calibNoiseLikeAll);
  declareProperty("BelowThresholdDirection",  m_noiseDirectionCalculation);
  declareProperty("EnergyThreshold",          m_eThreshold);
  declareProperty("IgnoreGeoWeights",         m_ignoreGeoWghts);
  declareProperty("CellSignalWeightTool",     m_cellWeight);
}

~CaloClusterCellWeightCalib()

CaloClusterCellWeightCalib::~CaloClusterCellWeightCalib ( )

overridevirtualdefault

Base tool destructor.

Member Function Documentation

cmpNoCase()

bool CaloClusterCellWeightCalib::cmpNoCase ( const std::string & a, const std::string & b )

staticprotected

Helper for non-case sensitive string comparison.

Definition at line 230 of file CaloClusterCellWeightCalib.cxx.

{
  // same length required
  if ( a.length() != b.length() ) return false;
  // adapted from Stroustrup, The C++ Programming Language, Special
  //  Edition, (2001 printing), p 591.
  std::string::const_iterator p1(a.begin());
  std::string::const_iterator p2(b.begin());
  while ( p1 != a.end() && p2 != b.end() )
    {
      if ( std::toupper(*p1) != std::toupper(*p2) ) return false;
      ++p1;
      ++p2;
    }
  return true;
}

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

DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID ( CaloClusterCollectionProcessor , 1 , 0  )

inherited

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

execute() [1/3]

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

overridevirtual

Execute on a single cluster.

Parameters

cluster	The cluster to process.
ctx	The event context.

Implements CaloClusterProcessor.

Definition at line 95 of file CaloClusterCellWeightCalib.cxx.

{
 
  // retrieve raw cluster signals  
  double clusterE(pClus->rawE());
  double clusterEta(pClus->rawEta());
  double clusterPhi(pClus->rawPhi());
 
 //   report << MSG::INFO << "<UNCALIBRATED> cluster kinematics ("
 //      << pClus->e() << ","
 //      << pClus->eta() << ","
 //      << pClus->phi() << ")" << endmsg;
 
  CaloClusterChangeSignalState chss(pClus,xAOD::CaloCluster::ALTCALIBRATED);
 
  pClus->setE(clusterE);
  pClus->setEta(clusterEta);
  pClus->setPhi(clusterPhi);
 
  //   report << MSG::INFO << "<ALTCALIBRATED> cluster kinematics, initial ("
  //     << pClus->e() << "/" << clusterE << ","
  //     << pClus->eta() << "/" << clusterEta << ","
  //     << pClus->phi() << "/" << clusterPhi << ")" << endmsg;
 
  // calculate new 4-vector
  StatusCode checkOut(StatusCode::SUCCESS);
  if ( m_calibNoiseLikeAll ) 
    {
      checkOut = (this->*m_calc)(pClus);
    }
  else
    {
      checkOut = pClus->e() > 0. 
    ? (this->*m_calc)(pClus) : (this->*m_calc_noise)(pClus);
    }
 
  //   report << MSG::INFO << "<ALTCALIBRATED> cluster kinematics, final ("
  //     << pClus->e() << ","
  //     << pClus->eta() << ","
  //     << pClus->phi() << ")" << endmsg;
 
  // check result
  if ( checkOut.isFailure() )
    {
      msg(MSG::WARNING)
         << "problem in calculation of cell weighted signal state"
         << endmsg;
      return StatusCode::SUCCESS;
    }
  else
    {
      // change reco status
      pClus->recoStatus().setStatus(CaloRecoStatus::CALIBRATEDALT);
      return checkOut;
    }
}

execute() [2/3]

StatusCode CaloClusterProcessor::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * collection ) const

virtual

Tool execution.

Reimplemented from CaloClusterProcessor.

Definition at line 65 of file CaloClusterProcessor.cxx.

{
  for (xAOD::CaloCluster* clu : *collection) {
    ATH_CHECK( execute (ctx, clu) );
  }
  return StatusCode::SUCCESS;
}

execute() [3/3]

virtual StatusCode CaloClusterCollectionProcessor::execute ( xAOD::CaloClusterContainer * collection )

inlinefinalvirtualinherited

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters. (deprecated)

Reimplemented from CaloClusterCollectionProcessor.

Definition at line 50 of file CaloClusterCollectionProcessor.h.

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

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

f_dirAbs()

StatusCode CaloClusterCellWeightCalib::f_dirAbs ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for direction from absolute signal.

The absolute signal is used to re-calculate the cluster direction. This is stable for all clusters but changes the direction with respect to the fixed scenario somewhat.

Definition at line 362 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  double eRef(0.);
  double etaRef(0.);
  double phiRef(0.);
  xAOD::CaloCluster::cell_iterator fCell(pClus->cell_begin());
  xAOD::CaloCluster::cell_iterator lCell(pClus->cell_end());
  for ( ; fCell != lCell; fCell++ )
    {
      const CaloCell* cell = *fCell;
      //
      double eWght(fCell.weight() *
           cell->e()               *
           m_cellWeight->wtCell(cell));
      double phiCell(proxim(cell->phi(),phiRef)); 
      //
      eCal   += eWght;
      eWght   = fabs(eWght);
      etaRef += cell->eta() * eWght;
      phiRef  = CaloPhiRange::fix((phiCell * eWght + eRef * phiRef)/(eRef+eWght));
      eRef   += eWght;
    }
  // set cluster kinematics
  pClus->setE(eCal);
  if ( eRef > 0. )
    {
      pClus->setEta(etaRef/eRef);
      pClus->setPhi(phiRef);
    }
  //
  return StatusCode::SUCCESS;
}

f_dirAbsNW()

StatusCode CaloClusterCellWeightCalib::f_dirAbsNW ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for direction from absolute signal.

The absolute signal is used to re-calculate the cluster direction. This is stable for all clusters but changes the direction with respect to the fixed scenario somewhat. Geometrical weights are ignored.

Definition at line 397 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  double eRef(0.);
  double etaRef(0.);
  double phiRef(0.);
  for (const CaloCell* cell : *pClus)
    {
      //
      double eWght(cell->e() * m_cellWeight->wtCell(cell));
      double phiCell(proxim(cell->phi(),phiRef)); 
      //
      eCal   += eWght;
      eWght   = fabs(eWght);
      etaRef += cell->eta() * eWght;
      phiRef  = CaloPhiRange::fix((phiCell * eWght + eRef * phiRef)/(eRef+eWght));
      eRef   += eWght;
    }
  // set cluster kinematics
  pClus->setE(eCal);
  if ( eRef > 0. )
    {
      pClus->setEta(etaRef/eRef);
      pClus->setPhi(phiRef);
    }
  //
  return StatusCode::SUCCESS;
}

f_dirPos()

StatusCode CaloClusterCellWeightCalib::f_dirPos ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for direction from positive signal.

Direction is calculated using E>0 cell signals only. This may be highly fluctuating for noise clusters.

Definition at line 292 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  double eRef(0.);
  double etaRef(0.);
  double phiRef(0.);
  xAOD::CaloCluster::cell_iterator fCell(pClus->cell_begin());
  xAOD::CaloCluster::cell_iterator lCell(pClus->cell_end());
  for ( ; fCell != lCell; fCell++ )
    {
      const CaloCell* cell = *fCell;
      //
      double eWght(fCell.weight() *
           cell->e()               *
           m_cellWeight->wtCell(cell));
      eCal += eWght;
      //
      if ( eWght > m_eThreshold )
    {
      double phiCell(proxim(cell->phi(),phiRef)); 
      etaRef += cell->eta() * eWght;
      phiRef  = CaloPhiRange::fix((phiCell * eWght + eRef * phiRef)/(eRef+eWght));
      eRef   += eWght;
    }
    }
  // set cluster kinematics
  pClus->setE(eCal);
  if ( eRef > 0. )
    {
      pClus->setEta(etaRef/eRef);
      pClus->setPhi(phiRef);
    }
  //
  return StatusCode::SUCCESS;
}

f_dirPosNW()

StatusCode CaloClusterCellWeightCalib::f_dirPosNW ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for direction from positive signal.

Direction is calculated using E>0 cell signals only. This may be highly fluctuating for noise clusters. Geometrical weights are ignored.

Definition at line 329 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  double eRef(0.);
  double etaRef(0.);
  double phiRef(0.);
  for (const CaloCell* cell : *pClus)
    {
      //
      double eWght(cell->e() *
           m_cellWeight->wtCell(cell));
      eCal += eWght;
      //
      if ( eWght > m_eThreshold )
    {
      double phiCell(proxim(cell->phi(),phiRef)); 
      etaRef += cell->eta() * eWght;
      phiRef  = CaloPhiRange::fix((phiCell * eWght + eRef * phiRef)/(eRef+eWght));
      eRef   += eWght;
    }
    }
  // set cluster kinematics
  pClus->setE(eCal);
  if ( eRef > 0. )
    {
      pClus->setEta(etaRef/eRef);
      pClus->setPhi(phiRef);
    }
  //
  return StatusCode::SUCCESS;
}

f_dirRaw()

StatusCode CaloClusterCellWeightCalib::f_dirRaw ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for energy only update.

Direction is taken from electromagnetic scale. This is safe for all clusters.

Definition at line 253 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  xAOD::CaloCluster::cell_iterator fCell(pClus->cell_begin());
  xAOD::CaloCluster::cell_iterator lCell(pClus->cell_end());
  for ( ; fCell != lCell; fCell++ )
    {
      const CaloCell* cell = *fCell;
      // 
      eCal += 
    fCell.weight()     * 
    cell->e()                   *
        m_cellWeight->wtCell(cell);
    }
  // set cluster kinematics (cluster is in ALTCALIBRATED state
  pClus->setE(eCal);
  //
  return StatusCode::SUCCESS;
}

f_dirRawNW()

StatusCode CaloClusterCellWeightCalib::f_dirRawNW ( xAOD::CaloCluster * pClus ) const

protected

Calculator implementation for energy only update.

Direction is taken from electromagnetic scale. This is safe for all clusters. The energy calculation ignores geometrical weights.

Definition at line 274 of file CaloClusterCellWeightCalib.cxx.

{
  // loop cells in clusters
  double eCal(0.);
  for (const CaloCell* cell : *pClus)
    {
      // 
      eCal += 
    cell->e()                   *
        m_cellWeight->wtCell(cell);
    }
  // set cluster kinematics (cluster is in ALTCALIBRATED state
  pClus->setE(eCal);
  //
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CaloClusterCellWeightCalib::initialize ( )

overridevirtual

Tool initialization.

Definition at line 60 of file CaloClusterCellWeightCalib.cxx.

{
  MsgStream report(msgSvc(),name());
 
  // configure direction calculations
  StatusCode checkOut = m_calibNoiseLikeAll
    ? this->setupAll(report)  // all clusters the same
    : this->setupSpc(report); // dedicated noise cluster treatment
  if ( checkOut.isFailure() )
    {
      report << MSG::ERROR
         << "failed to configure direction calculations."
         << endmsg;
      return StatusCode::FAILURE;
    }
 
  // retrieve tool
  if ( m_cellWeight.empty() || (m_cellWeight.retrieve()).isFailure() )
    {
      report << MSG::ERROR
         << "*** configuration insufficient *** "
         << "no hadronic cell calibration tool configured"
         << endmsg;
      return StatusCode::FAILURE;
    }
 
  //
  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 & CaloClusterProcessor::interfaceID ( )

inlinestaticinherited

Standard Gaudi interface ID method.

Definition at line 72 of file CaloClusterProcessor.h.

{return IID_CaloClusterProcessor;}

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

setup()

bool CaloClusterCellWeightCalib::setup ( const std::string & name, const std::string & tag, CALCULATOR & calc, std::string & conf, MsgStream & report )

protected

Common setup function.

Definition at line 176 of file CaloClusterCellWeightCalib.cxx.

{
  if ( CaloClusterCellWeightCalib::cmpNoCase(name,m_posName) )
    {
      report << MSG::INFO
         << "cluster direction ("
         << tag
         << ") from positive cells only"
         << endmsg;
      conf = name;
      calc = m_ignoreGeoWghts 
    ? &CaloClusterCellWeightCalib::f_dirPosNW
    : &CaloClusterCellWeightCalib::f_dirPos;
      return true;
    }
  else if ( CaloClusterCellWeightCalib::cmpNoCase(name,m_absName) )
    {
      report << MSG::INFO
         << "cluster direction ("
         << tag 
         << ") from absolute cell signals"
         << endmsg;
      conf = name;
      calc = m_ignoreGeoWghts 
    ? &CaloClusterCellWeightCalib::f_dirAbsNW
    : &CaloClusterCellWeightCalib::f_dirAbs;
      return true;
    }
  else if ( CaloClusterCellWeightCalib::cmpNoCase(name,m_rawName) )
    {
      report << MSG::INFO
         << "cluster direction ("
         << tag
         << ") from raw signals (unchanged by this tool)"
         << endmsg;
      conf = name;
      calc = m_ignoreGeoWghts 
    ? &CaloClusterCellWeightCalib::f_dirRawNW
    : &CaloClusterCellWeightCalib::f_dirRaw;
      return true;
    }
  else
    {
      report << MSG::WARNING
         << "invalid configuration, use default!"
         << endmsg;
      return this->setup(m_defName,tag,calc,conf,report);
    }
}

setupAll()

StatusCode CaloClusterCellWeightCalib::setupAll ( MsgStream & report )

protected

Setup for calculation for all or non-noise clusters.

Definition at line 157 of file CaloClusterCellWeightCalib.cxx.

{
  std::string conf;
  std::string tag("all");
  return this->setup(m_directionCalculation,tag,m_calc,conf,report)
    ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

setupSpc()

StatusCode CaloClusterCellWeightCalib::setupSpc ( MsgStream & report )

protected

Setup for different calculation for noise clusters.

Definition at line 165 of file CaloClusterCellWeightCalib.cxx.

{
  std::string conf;
  std::string aboveTag("above threshold");
  std::string belowTag("below threshold");
  return 
    this->setup(m_directionCalculation,aboveTag,m_calc,conf,report) &&
    this->setup(m_noiseDirectionCalculation,belowTag,m_calc_noise,conf,report)
    ? StatusCode::SUCCESS : StatusCode::FAILURE;
}

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_absName

std::string const CaloClusterCellWeightCalib::m_absName = "AbsSignal"

staticprotected

Negative signal handling: absolute signal tag.

Definition at line 96 of file CaloClusterCellWeightCalib.h.

m_calc

CALCULATOR CaloClusterCellWeightCalib::m_calc

protected

Pointer to direction calculation implementation.

Definition at line 161 of file CaloClusterCellWeightCalib.h.

m_calc_noise

CALCULATOR CaloClusterCellWeightCalib::m_calc_noise

protected

Pointer to direction calculation for noise clusters.

Definition at line 164 of file CaloClusterCellWeightCalib.h.

m_calibNoiseLikeAll

bool CaloClusterCellWeightCalib::m_calibNoiseLikeAll

protected

Property controlling calibration of noise clusters.

Flags calibration of noise (E<0) clusters:

Parameters

true	(default) means noise clusters are treated as all others
false	means noise clusters are not calibrated at all

Definition at line 58 of file CaloClusterCellWeightCalib.h.

m_cellWeight

ToolHandle<ICellWeightTool> CaloClusterCellWeightCalib::m_cellWeight

protected

Handle for cell weight tool.

Definition at line 87 of file CaloClusterCellWeightCalib.h.

m_defName

std::string const CaloClusterCellWeightCalib::m_defName = m_absName

staticprotected

Negative signal handling: default tag.

Definition at line 92 of file CaloClusterCellWeightCalib.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_directionCalculation

std::string CaloClusterCellWeightCalib::m_directionCalculation

protected

Property controlling negative signal handling.

Negative cell signals are problematic for the direction calculation from cells:

Parameters

Signal	use only E>0 cells for direction
AbsSignal	(default) use w*|E| for direction
RawSignal	do not recalculate direction at all

The property is not case sensitive. The default is AbsSignal, i.e. following a strategy very similar to the direction calculation performed during cluster formation.

Definition at line 49 of file CaloClusterCellWeightCalib.h.

m_eThreshold

double CaloClusterCellWeightCalib::m_eThreshold

protected

Energy threshold for direction calculation.

Definition at line 72 of file CaloClusterCellWeightCalib.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_ignoreGeoWghts

bool CaloClusterCellWeightCalib::m_ignoreGeoWghts

protected

Flag to ignore geometrical cell weights in clusters.

This flags controls the use of geometrical cell weights in clusters:

Parameters

false	(default) geometrical weights are used
true	geometrical weights are ignored

Note that using the geometrical weights requires this tool to run before the Local Hadronic calibration tools.

Definition at line 84 of file CaloClusterCellWeightCalib.h.

m_noiseDirectionCalculation

std::string CaloClusterCellWeightCalib::m_noiseDirectionCalculation

protected

Property controlling calibration method for noise clusters.

Tags calibration method for noise (E<0) clusters. Only effective if these clusters are calibrated at all, i.e. m_calibNoise is true :

Parameters

true	(default) uses same direction correction as all other clusters
false	uses AbsSignal calibration for noise clusters.

Definition at line 69 of file CaloClusterCellWeightCalib.h.

m_posName

std::string const CaloClusterCellWeightCalib::m_posName = "Signal"

staticprotected

Negative signal handling: positive signal tag.

Definition at line 94 of file CaloClusterCellWeightCalib.h.

m_rawName

std::string const CaloClusterCellWeightCalib::m_rawName = "RawSignal"

staticprotected

Negative signal handling: raw signal tag.

Definition at line 98 of file CaloClusterCellWeightCalib.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.

---

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

• CaloClusterCellWeightCalib.h
• CaloClusterCellWeightCalib.cxx