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
Gaudi::Property< std::string >	m_directionCalculation {this, "Direction", s_defName}
	Property controlling negative signal handling.
Gaudi::Property< bool >	m_calibNoiseLikeAll {this, "BelowThresholdLikeAll", true}
	Property controlling calibration of noise clusters.
Gaudi::Property< std::string >	m_noiseDirectionCalculation {this, "BelowThresholdDirection", s_defName}
	Property controlling calibration method for noise clusters.
Gaudi::Property< double >	m_eThreshold {this, "EnergyThreshold", 0.}
	Energy threshold for direction calculation.
Gaudi::Property< bool >	m_ignoreGeoWghts {this, "IgnoreGeoWeights", false}
	Flag to ignore geometrical cell weights in clusters.
ToolHandle< ICellWeightTool >	m_cellWeight {this, "CellSignalWeightTool", {}}
	Handle for cell weight tool.
CALCULATOR	m_calc {nullptr}
	Pointer to direction calculation implementation.
CALCULATOR	m_calc_noise {nullptr}
	Pointer to direction calculation for noise clusters.

Static Protected Attributes
static constexpr std::string	s_posName = "Signal"
	Negative signal handling: positive signal tag.
static constexpr std::string	s_absName = "AbsSignal"
	Negative signal handling: absolute signal tag.
static constexpr std::string	s_rawName = "RawSignal"
	Negative signal handling: raw signal tag.
static constexpr std::string	s_defName = s_absName
	Negative signal handling: default 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 115 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 25 of file CaloClusterCellWeightCalib.cxx.

  : CaloClusterProcessor(type,name,pParent)
{
}

~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 210 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 75 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 342 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 377 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 272 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 309 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 233 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 254 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 40 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 156 of file CaloClusterCellWeightCalib.cxx.

{
  if ( CaloClusterCellWeightCalib::cmpNoCase(name,s_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,s_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,s_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(s_defName,tag,calc,conf,report);
    }
}

setupAll()

StatusCode CaloClusterCellWeightCalib::setupAll ( MsgStream & report )

protected

Setup for calculation for all or non-noise clusters.

Definition at line 137 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 145 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_calc

CALCULATOR CaloClusterCellWeightCalib::m_calc {nullptr}

protected

Pointer to direction calculation implementation.

Definition at line 160 of file CaloClusterCellWeightCalib.h.

{nullptr};

m_calc_noise

CALCULATOR CaloClusterCellWeightCalib::m_calc_noise {nullptr}

protected

Pointer to direction calculation for noise clusters.

Definition at line 163 of file CaloClusterCellWeightCalib.h.

{nullptr};

m_calibNoiseLikeAll

Gaudi::Property<bool> CaloClusterCellWeightCalib::m_calibNoiseLikeAll {this, "BelowThresholdLikeAll", true}

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 69 of file CaloClusterCellWeightCalib.h.

{this, "BelowThresholdLikeAll", true};

m_cellWeight

ToolHandle<ICellWeightTool> CaloClusterCellWeightCalib::m_cellWeight {this, "CellSignalWeightTool", {}}

protected

Handle for cell weight tool.

Definition at line 98 of file CaloClusterCellWeightCalib.h.

{this, "CellSignalWeightTool", {}};

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

Gaudi::Property<std::string> CaloClusterCellWeightCalib::m_directionCalculation {this, "Direction", s_defName}

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 60 of file CaloClusterCellWeightCalib.h.

{this, "Direction", s_defName};

m_eThreshold

Gaudi::Property<double> CaloClusterCellWeightCalib::m_eThreshold {this, "EnergyThreshold", 0.}

protected

Energy threshold for direction calculation.

Definition at line 83 of file CaloClusterCellWeightCalib.h.

{this, "EnergyThreshold", 0.};

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

Gaudi::Property<bool> CaloClusterCellWeightCalib::m_ignoreGeoWghts {this, "IgnoreGeoWeights", false}

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 95 of file CaloClusterCellWeightCalib.h.

{this, "IgnoreGeoWeights", false};

m_noiseDirectionCalculation

Gaudi::Property<std::string> CaloClusterCellWeightCalib::m_noiseDirectionCalculation {this, "BelowThresholdDirection", s_defName}

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 80 of file CaloClusterCellWeightCalib.h.

{this, "BelowThresholdDirection", s_defName};

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.

s_absName

std::string CaloClusterCellWeightCalib::s_absName = "AbsSignal"

staticconstexprprotected

Negative signal handling: absolute signal tag.

Definition at line 40 of file CaloClusterCellWeightCalib.h.

s_defName

std::string CaloClusterCellWeightCalib::s_defName = s_absName

staticconstexprprotected

Negative signal handling: default tag.

Definition at line 44 of file CaloClusterCellWeightCalib.h.

s_posName

std::string CaloClusterCellWeightCalib::s_posName = "Signal"

staticconstexprprotected

Negative signal handling: positive signal tag.

Definition at line 38 of file CaloClusterCellWeightCalib.h.

s_rawName

std::string CaloClusterCellWeightCalib::s_rawName = "RawSignal"

staticconstexprprotected

Negative signal handling: raw signal tag.

Definition at line 42 of file CaloClusterCellWeightCalib.h.

---

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

• CaloClusterCellWeightCalib.h
• CaloClusterCellWeightCalib.cxx