PFUnifiedLCCalibTool 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 <PFUnifiedLCCalibTool.h>

Inheritance diagram for PFUnifiedLCCalibTool:

Collaboration diagram for PFUnifiedLCCalibTool:

Public Member Functions
	PFUnifiedLCCalibTool (const std::string &type, const std::string &name, const IInterface *parent)
	~PFUnifiedLCCalibTool ()
virtual StatusCode	initialize () override
virtual StatusCode	processPFlowData (const EventContext &ctx, PFData &thePFData) const override

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

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 PFUnifiedLCCalibTool.h.

Constructor & Destructor Documentation

PFUnifiedLCCalibTool()

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

Definition at line 19 of file PFUnifiedLCCalibTool.cxx.

                                                                                                                 :
  base_class(type, name, parent)
{
}

~PFUnifiedLCCalibTool()

PFUnifiedLCCalibTool::~PFUnifiedLCCalibTool ( )

inline

Definition at line 28 of file PFUnifiedLCCalibTool.h.

{}

Member Function Documentation

apply()

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

private

Definition at line 83 of file PFUnifiedLCCalibTool.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 PFUnifiedLCCalibTool::applyLocalWeight ( eflowRecCluster * theEFRecCluster, const CaloDetDescrManager & calo_dd_man )

staticprivate

Definition at line 89 of file PFUnifiedLCCalibTool.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);
}

initialize()

StatusCode PFUnifiedLCCalibTool::initialize ( )

overridevirtual

Definition at line 24 of file PFUnifiedLCCalibTool.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;
 
}

processPFlowData()

StatusCode PFUnifiedLCCalibTool::processPFlowData ( const EventContext & ctx, PFData & thePFData ) const

overridevirtual

Definition at line 47 of file PFUnifiedLCCalibTool.cxx.

                                                                                                  {
 
  if (!thePFData.caloObjects) {
    ATH_MSG_ERROR("PFData::caloObjects is null; caller must set it before invoking the LC calib tool");
    return StatusCode::FAILURE;
  }
 
  eflowCaloObjectContainer *theEflowCaloObjectContainer = thePFData.caloObjects;
 
  if (m_useLocalWeight) {
    std::unique_ptr<eflowRecClusterContainer> theEFRecClusterContainer = m_clusterCollectionTool->retrieve(*theEflowCaloObjectContainer, true);
    /* Calibrate each cluster */
    SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
    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);
    /* 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;
}

Member Data Documentation

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> PFUnifiedLCCalibTool::m_caloMgrKey

private

Initial value:

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

ReadCondHandleKey for CaloDetDescrManager.

Definition at line 57 of file PFUnifiedLCCalibTool.h.

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

m_clusterCollectionTool

ToolHandle<IPFClusterCollectionTool> PFUnifiedLCCalibTool::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 39 of file PFUnifiedLCCalibTool.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> PFUnifiedLCCalibTool::m_clusterLocalCalibDMTool {this,"CaloClusterLocalCalibDM","CaloClusterLocalCalib","Tool for correcting clusters at cell level for dead material"}

private

Definition at line 51 of file PFUnifiedLCCalibTool.h.

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

m_clusterLocalCalibOOCCPi0Tool

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

private

Definition at line 48 of file PFUnifiedLCCalibTool.h.

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

m_clusterLocalCalibOOCCTool

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

private

Definition at line 45 of file PFUnifiedLCCalibTool.h.

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

m_clusterLocalCalibTool

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

private

Definition at line 42 of file PFUnifiedLCCalibTool.h.

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

m_useLocalWeight

Gaudi::Property<bool> PFUnifiedLCCalibTool::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 54 of file PFUnifiedLCCalibTool.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:

• PFUnifiedLCCalibTool.h
• PFUnifiedLCCalibTool.cxx