PFLCCalibTool Class Reference

This tool can either use a series of CaloClusterProcessor to calibrate the modified xAOD::CaloCluster (modified when we do the charged shower subtraction) using recalculated LC weights or its own internal method to use the stored LC weights in the eflowRecCluster objects. More...

#include <PFLCCalibTool.h>

Inheritance diagram for PFLCCalibTool:

Collaboration diagram for PFLCCalibTool:

Public Member Functions
	PFLCCalibTool (const std::string &type, const std::string &name, const IInterface *parent)
	~PFLCCalibTool ()
virtual StatusCode	initialize () override
virtual StatusCode	execute (eflowCaloObjectContainer &theEflowCaloObjectContainer) override
virtual StatusCode	finalize () override

Private Member Functions
StatusCode	apply (const EventContext &ctx, ToolHandle< CaloClusterProcessor > &calibTool, xAOD::CaloCluster *cluster)

Static Private Member Functions
static void	applyLocalWeight (eflowRecCluster *theEFRecCluster, const CaloDetDescrManager &calo_dd_man)

Private Attributes
ToolHandle< IPFClusterCollectionTool >	m_clusterCollectionTool {this,"eflowRecClusterCollectionTool","eflowRecClusterCollectionTool","Tool to put all clusters into a temporary container - then we use this to calculate moments, some of which depend on configuration of nearby clusters"}
	Tool to put all clusters into a temporary container - then we use this to calculate moments, some of which depend on configuration of nearby clusters.
ToolHandle< CaloClusterProcessor >	m_clusterLocalCalibTool {this,"CaloClusterLocalCalib","CaloClusterLocalCalib","Tool for applying local hadronc calibration weights to cells"}
ToolHandle< CaloClusterProcessor >	m_clusterLocalCalibOOCCTool {this,"CaloClusterLocalCalibOOCC","CaloClusterLocalCalib","Tool to deal with out of cluster corrections"}
ToolHandle< CaloClusterProcessor >	m_clusterLocalCalibOOCCPi0Tool {this,"CaloClusterLocalCalibOOCCPi0","CaloClusterLocalCalib","Tool to do Pi0 corrections"}
ToolHandle< CaloClusterProcessor >	m_clusterLocalCalibDMTool {this,"CaloClusterLocalCalibDM","CaloClusterLocalCalib","Tool for correcting clusters at cell level for dead material"}
Gaudi::Property< bool >	m_useLocalWeight {this,"UseLocalWeight",false,"Toggle which LC weights scheme to use - default is to recalculate weights, rather than use saved weights"}
	Toggle which LC weights scheme to use - default is to recalculate weights, rather than use saved weights.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
	ReadCondHandleKey for CaloDetDescrManager.

Detailed Description

This tool can either use a series of CaloClusterProcessor to calibrate the modified xAOD::CaloCluster (modified when we do the charged shower subtraction) using recalculated LC weights or its own internal method to use the stored LC weights in the eflowRecCluster objects.

If using the LC weights which were stored in the eflowRecCluster then we use the container of eflowRecCluster, but if using recalculated LC weights for the modified xAOD::CaloCluster (modified when we remove calorimeter cells in the charged shower subtraction) then we need the container of xAOD::CaloCluster. The PFClusterCollectionTool provides both of these containers.

Definition at line 22 of file PFLCCalibTool.h.

Constructor & Destructor Documentation

PFLCCalibTool()

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

Definition at line 18 of file PFLCCalibTool.cxx.

                                                                                                   :
  base_class(type, name, parent)
{
}

~PFLCCalibTool()

PFLCCalibTool::~PFLCCalibTool ( )

inline

Definition at line 28 of file PFLCCalibTool.h.

{}

Member Function Documentation

apply()

StatusCode PFLCCalibTool::apply ( const EventContext & ctx, ToolHandle< CaloClusterProcessor > & calibTool, xAOD::CaloCluster * cluster )

private

Definition at line 81 of file PFLCCalibTool.cxx.

                                                                                                                              {
  if (m_useLocalWeight) ATH_MSG_WARNING("Applying recalculated weights, when configuration requested to use original weights");
  ATH_CHECK(calibTool->execute(ctx,cluster));
  return StatusCode::SUCCESS;  
}

applyLocalWeight()

void PFLCCalibTool::applyLocalWeight ( eflowRecCluster * theEFRecCluster, const CaloDetDescrManager & calo_dd_man )

staticprivate

Definition at line 87 of file PFLCCalibTool.cxx.

                                                                                                              {
  xAOD::CaloCluster* theCluster = theEFRecClusters->getCluster();
 
  /* Iterate over cells of old cluster and replicate them with energy weighted by -1 if negative and add it to the new cluster */
  const std::map<IdentifierHash, double> weightMap = theEFRecClusters->getCellsWeight();
 
  const CaloCell_ID* calo_id = calo_dd_man.getCaloCell_ID();
  xAOD::CaloCluster::cell_iterator cellIter = theCluster->cell_begin();
 
  for (;cellIter != theCluster->cell_end(); ++cellIter) {
    const CaloCell* pCell = *cellIter;
    IdentifierHash myHashId = calo_id->calo_cell_hash(pCell->ID());
    if (const auto pWeight = weightMap.find(myHashId); pWeight!=weightMap.end()){
      const double weight = pWeight->second;
      theCluster->reweightCell(cellIter, weight);
    }
  }
 
  CaloClusterKineHelper::calculateKine(theCluster, true, false);
 
  theCluster->recoStatus().setStatus(CaloRecoStatus::CALIBRATEDLHC);
}

execute()

StatusCode PFLCCalibTool::execute ( eflowCaloObjectContainer & theEflowCaloObjectContainer )

overridevirtual

Definition at line 46 of file PFLCCalibTool.cxx.

                                                                                       {
 
  if (m_useLocalWeight) {
    std::unique_ptr<eflowRecClusterContainer> theEFRecClusterContainer = m_clusterCollectionTool->retrieve(theEflowCaloObjectContainer, true);
    /* Calibrate each cluster */
    SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
    if (caloMgrHandle.isValid()){
      for (auto thisEFlowRecCluster : *theEFRecClusterContainer) applyLocalWeight(thisEFlowRecCluster,**caloMgrHandle);
    }
    else ATH_MSG_WARNING("Invalid pointer to CaloDetDescrManage: Did NOT calibrate any topoclusters.");
  } else {
    /* Collect all the clusters in a temporary container (with VIEW_ELEMENTS!) */
    std::unique_ptr<xAOD::CaloClusterContainer> tempClusterContainer = m_clusterCollectionTool->execute(theEflowCaloObjectContainer, true);
    const EventContext& ctx=Gaudi::Hive::currentContext();
    /* Calibrate each cluster */
    for (auto thisCaloCluster : *tempClusterContainer){
      /* Subsequently apply all ClusterLocalCalibTools, print debug output at each stage, if DEBUG it set */
      ATH_CHECK(apply(ctx,m_clusterLocalCalibTool, thisCaloCluster));
 
      ATH_CHECK(apply(ctx,m_clusterLocalCalibOOCCTool, thisCaloCluster));
 
      ATH_CHECK(apply(ctx,m_clusterLocalCalibOOCCPi0Tool, thisCaloCluster));
 
      ATH_CHECK(apply(ctx,m_clusterLocalCalibDMTool, thisCaloCluster));
 
    }//loop on CaloCluster
  }//if not use local weight scheme
  return StatusCode::SUCCESS;
}

finalize()

StatusCode PFLCCalibTool::finalize ( )

overridevirtual

Definition at line 76 of file PFLCCalibTool.cxx.

                                   {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode PFLCCalibTool::initialize ( )

overridevirtual

Definition at line 23 of file PFLCCalibTool.cxx.

                                     {
 
  /* Retrieve the cluster collection tool */
  ATH_CHECK(m_clusterCollectionTool.retrieve());
 
  /* Retrieve basic local-hadron calibration tool */
  ATH_CHECK(m_clusterLocalCalibTool.retrieve());
 
  /* Retrieve tools for out-of-cluster corrections */
  ATH_CHECK(m_clusterLocalCalibOOCCTool.retrieve());
 
  ATH_CHECK(m_clusterLocalCalibOOCCPi0Tool.retrieve());
 
  /* Retrieve tool for DM corrections */
  ATH_CHECK(m_clusterLocalCalibDMTool.retrieve());
 
  /* Retrieve calorimeter detector manager */
  ATH_CHECK(m_caloMgrKey.initialize());
 
  return StatusCode::SUCCESS;
 
}

Member Data Documentation

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> PFLCCalibTool::m_caloMgrKey

private

Initial value:

{ this
    , "CaloDetDescrManager"
    , "CaloDetDescrManager"
    , "SG Key for CaloDetDescrManager in the Condition Store" }

ReadCondHandleKey for CaloDetDescrManager.

Definition at line 58 of file PFLCCalibTool.h.

                                                        { this
    , "CaloDetDescrManager"
    , "CaloDetDescrManager"
    , "SG Key for CaloDetDescrManager in the Condition Store" };

m_clusterCollectionTool

ToolHandle<IPFClusterCollectionTool> PFLCCalibTool::m_clusterCollectionTool {this,"eflowRecClusterCollectionTool","eflowRecClusterCollectionTool","Tool to put all clusters into a temporary container - then we use this to calculate moments, some of which depend on configuration of nearby clusters"}

private

Tool to put all clusters into a temporary container - then we use this to calculate moments, some of which depend on configuration of nearby clusters.

Definition at line 40 of file PFLCCalibTool.h.

{this,"eflowRecClusterCollectionTool","eflowRecClusterCollectionTool","Tool to put all clusters into a temporary container - then we use this to calculate moments, some of which depend on configuration of nearby clusters"};

m_clusterLocalCalibDMTool

ToolHandle<CaloClusterProcessor> PFLCCalibTool::m_clusterLocalCalibDMTool {this,"CaloClusterLocalCalibDM","CaloClusterLocalCalib","Tool for correcting clusters at cell level for dead material"}

private

Definition at line 52 of file PFLCCalibTool.h.

{this,"CaloClusterLocalCalibDM","CaloClusterLocalCalib","Tool for correcting clusters at cell level for dead material"};

m_clusterLocalCalibOOCCPi0Tool

ToolHandle<CaloClusterProcessor> PFLCCalibTool::m_clusterLocalCalibOOCCPi0Tool {this,"CaloClusterLocalCalibOOCCPi0","CaloClusterLocalCalib","Tool to do Pi0 corrections"}

private

Definition at line 49 of file PFLCCalibTool.h.

{this,"CaloClusterLocalCalibOOCCPi0","CaloClusterLocalCalib","Tool to do Pi0 corrections"};

m_clusterLocalCalibOOCCTool

ToolHandle<CaloClusterProcessor> PFLCCalibTool::m_clusterLocalCalibOOCCTool {this,"CaloClusterLocalCalibOOCC","CaloClusterLocalCalib","Tool to deal with out of cluster corrections"}

private

Definition at line 46 of file PFLCCalibTool.h.

{this,"CaloClusterLocalCalibOOCC","CaloClusterLocalCalib","Tool to deal with out of cluster corrections"};

m_clusterLocalCalibTool

ToolHandle<CaloClusterProcessor> PFLCCalibTool::m_clusterLocalCalibTool {this,"CaloClusterLocalCalib","CaloClusterLocalCalib","Tool for applying local hadronc calibration weights to cells"}

private

Definition at line 43 of file PFLCCalibTool.h.

{this,"CaloClusterLocalCalib","CaloClusterLocalCalib","Tool for applying local hadronc calibration weights to cells"};

m_useLocalWeight

Gaudi::Property<bool> PFLCCalibTool::m_useLocalWeight {this,"UseLocalWeight",false,"Toggle which LC weights scheme to use - default is to recalculate weights, rather than use saved weights"}

private

Toggle which LC weights scheme to use - default is to recalculate weights, rather than use saved weights.

Definition at line 55 of file PFLCCalibTool.h.

{this,"UseLocalWeight",false,"Toggle which LC weights scheme to use - default is to recalculate weights, rather than use saved weights"};

---

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

• PFLCCalibTool.h
• PFLCCalibTool.cxx