PFClusterSelectorTool Class Reference

#include <PFClusterSelectorTool.h>

Inheritance diagram for PFClusterSelectorTool:

Collaboration diagram for PFClusterSelectorTool:

Public Member Functions
	PFClusterSelectorTool (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor.
	~PFClusterSelectorTool ()
	Default destructor.
StatusCode	initialize ()
	Gaudi AthAlgorithm hooks.
StatusCode	execute (eflowRecClusterContainer &theEFlowRecClusterContainer, xAOD::CaloClusterContainer &theCaloClusterContainer) const
StatusCode	finalize ()

Private Member Functions
void	retrieveLCCalCellWeight (const double &energy, const unsigned &index, std::map< IdentifierHash, double > &cellsWeight, const xAOD::CaloClusterContainer &caloCalClustersContainer, const CaloDetDescrManager &calo_dd_man) const
	for EM mode, LC weight for cells are retrieved before doing any subtraction; they will be used after subtraction

Private Attributes
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_caloClustersReadHandleKey
	ReadHandleKey for the CaloClusterContainer to be used as input.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_caloCalClustersReadHandleKey
	ReadHandleKey for the CaloClusterContainer, at LC scale, to be used as input.
SG::ReadDecorHandleKey< xAOD::CaloClusterContainer >	m_caloClusterReadDecorHandleKeyNLeadingTruthParticles {this,"CaloClusterReadDecorHandleKey_NLeadingTruthParticles",""}
	Read handle key to decorate CaloCluster with threeN leading truth particle uniqueID and energy.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
	ReadCondHandleKey for CaloDetDescrManager.

Detailed Description

Definition at line 16 of file PFClusterSelectorTool.h.

Constructor & Destructor Documentation

PFClusterSelectorTool()

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

Default constructor.

Definition at line 10 of file PFClusterSelectorTool.cxx.

                                                                                                                :
  base_class(type, name, parent)
{
}

~PFClusterSelectorTool()

PFClusterSelectorTool::~PFClusterSelectorTool ( )

inline

Default destructor.

Definition at line 22 of file PFClusterSelectorTool.h.

{};

Member Function Documentation

execute()

StatusCode PFClusterSelectorTool::execute	(	eflowRecClusterContainer &	theEFlowRecClusterContainer,
		xAOD::CaloClusterContainer &	theCaloClusterContainer ) const

Definition at line 32 of file PFClusterSelectorTool.cxx.

{
 
  SG::ReadHandle<xAOD::CaloClusterContainer> caloClustersReadHandle(m_caloClustersReadHandleKey);
  
  /* Verify the read handle has a valid pointer, and if not return */
  if (!caloClustersReadHandle.isValid()){
    ATH_MSG_WARNING(" Invalid ReadHandle for xAOD::CaloCluster with key: " <<  caloClustersReadHandle.key());
    return StatusCode::SUCCESS;
  }
 
  const xAOD::CaloClusterContainer* calclusters = nullptr;
  if (!m_caloCalClustersReadHandleKey.key().empty()) {
    SG::ReadHandle<xAOD::CaloClusterContainer> caloCalClustersReadHandle(m_caloCalClustersReadHandleKey);
    calclusters = caloCalClustersReadHandle.get();
  }
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
  ATH_CHECK(caloMgrHandle.isValid());
  
  /* Fill the vector of eflowRecClusters */
  unsigned int nClusters = caloClustersReadHandle->size();
  for (unsigned int iCluster = 0; iCluster < nClusters; ++iCluster) {
    /* Create the eflowRecCluster and put it in the container */
    std::unique_ptr<eflowRecCluster> thisEFRecCluster  = std::make_unique<eflowRecCluster>(ElementLink<xAOD::CaloClusterContainer>(*caloClustersReadHandle, iCluster), theCaloClusterContainer);
    
    if (calclusters){
      std::map<IdentifierHash,double> cellsWeightMap;
      retrieveLCCalCellWeight(caloClustersReadHandle->at(iCluster)->e(), iCluster, cellsWeightMap, *calclusters,**caloMgrHandle);
 
      thisEFRecCluster->setCellsWeight(std::move(cellsWeightMap));
    }
 
    if (!m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.empty()){
 
      std::string decorHandleName = m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.key();
      std::string::size_type pos = decorHandleName.find(".");
      std::string decorName = decorHandleName.substr(pos+1);
 
      SG::AuxElement::Accessor< std::vector< std::pair<unsigned int, double> > > accessor(decorName);
      accessor(*theCaloClusterContainer[iCluster]) = accessor(*caloClustersReadHandle->at(iCluster));
    }
 
    thisEFRecCluster->setClusterId(iCluster);
    theEFlowRecClusterContainer.push_back(std::move(thisEFRecCluster));
  }
  
  return StatusCode::SUCCESS;
}

finalize()

StatusCode PFClusterSelectorTool::finalize

(

)

Definition at line 84 of file PFClusterSelectorTool.cxx.

                                          {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode PFClusterSelectorTool::initialize

(

)

Gaudi AthAlgorithm hooks.

Definition at line 15 of file PFClusterSelectorTool.cxx.

                                            {
 
  ATH_CHECK(m_caloClustersReadHandleKey.initialize());
  if(!m_caloCalClustersReadHandleKey.key().empty()) {
    ATH_CHECK(m_caloCalClustersReadHandleKey.initialize());
  }
 
  if (!m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.empty()){
    ATH_CHECK(m_caloClusterReadDecorHandleKeyNLeadingTruthParticles.initialize());
  }
 
  ATH_CHECK(m_caloMgrKey.initialize());
 
  return StatusCode::SUCCESS;
}

retrieveLCCalCellWeight()

void PFClusterSelectorTool::retrieveLCCalCellWeight ( const double & energy, const unsigned & index, std::map< IdentifierHash, double > & cellsWeight, const xAOD::CaloClusterContainer & caloCalClustersContainer, const CaloDetDescrManager & calo_dd_man ) const

private

for EM mode, LC weight for cells are retrieved before doing any subtraction; they will be used after subtraction

Definition at line 89 of file PFClusterSelectorTool.cxx.

{
  /* match CaloCluster with CaloCalCluster to obtain cell weight */
  /* first try the position at 'index'. If we are lucky, the loop can be
   * avoided. */
  /* Note the read handle has been tested to be valid prior to the call of this
   * function */
  const xAOD::CaloCluster* matchedCalCluster = caloCalClustersContainer.at(index);
  if (matchedCalCluster){
    if (!(fabs(energy - matchedCalCluster->rawE()) < 0.001)) {
      matchedCalCluster = nullptr;
      for (const auto *iCalCalCluster : caloCalClustersContainer) {
        matchedCalCluster = iCalCalCluster;
        if (fabs(energy - matchedCalCluster->rawE()) < 0.001) {
            break;
          }
      }
      if (!matchedCalCluster) ATH_MSG_WARNING("Invalid pointer to matched cluster - failed to find cluster match");
    }
    if (not matchedCalCluster){ 
      throw std::runtime_error("matchedCluster is a null pointer in PFClusterSelectorTool::retrieveLCCalCellWeight");
    }
    /* obtain cell index and cell weight */    
    const CaloCell_ID*               calo_id  = calo_dd_man.getCaloCell_ID();
    xAOD::CaloCluster::const_cell_iterator itCell = matchedCalCluster->cell_begin();
    xAOD::CaloCluster::const_cell_iterator endCell = matchedCalCluster->cell_end();
    for (; itCell != endCell; ++itCell) {
      const CaloCell* pCell = *itCell;
      Identifier myId = pCell->ID();
      IdentifierHash myHashId = calo_id->calo_cell_hash(myId);
      cellsWeight[myHashId] = itCell.weight();
    }
  } else ATH_MSG_WARNING("Invalid pointer to matched cluster - could not look up local hadron cell weights");
}

Member Data Documentation

m_caloCalClustersReadHandleKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> PFClusterSelectorTool::m_caloCalClustersReadHandleKey

private

Initial value:

{
    this,
    "calClustersName",
    "CaloCalTopoClusters",
    "ReadHandleKey for the CaloClusterContainer, at LC scale, to be used as "
    "input"
  }

ReadHandleKey for the CaloClusterContainer, at LC scale, to be used as input.

Definition at line 50 of file PFClusterSelectorTool.h.

                                                                          {
    this,
    "calClustersName",
    "CaloCalTopoClusters",
    "ReadHandleKey for the CaloClusterContainer, at LC scale, to be used as "
    "input"
  };

m_caloClusterReadDecorHandleKeyNLeadingTruthParticles

SG::ReadDecorHandleKey<xAOD::CaloClusterContainer> PFClusterSelectorTool::m_caloClusterReadDecorHandleKeyNLeadingTruthParticles {this,"CaloClusterReadDecorHandleKey_NLeadingTruthParticles",""}

private

Read handle key to decorate CaloCluster with threeN leading truth particle uniqueID and energy.

Definition at line 59 of file PFClusterSelectorTool.h.

{this,"CaloClusterReadDecorHandleKey_NLeadingTruthParticles",""};

m_caloClustersReadHandleKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> PFClusterSelectorTool::m_caloClustersReadHandleKey

private

Initial value:

{
    this,
    "clustersName",
    "CaloTopoClusters",
    "ReadHandleKey for the CaloClusterContainer to be used as input"
  }

ReadHandleKey for the CaloClusterContainer to be used as input.

Definition at line 41 of file PFClusterSelectorTool.h.

                                                                       {
    this,
    "clustersName",
    "CaloTopoClusters",
    "ReadHandleKey for the CaloClusterContainer to be used as input"
  };

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> PFClusterSelectorTool::m_caloMgrKey

private

Initial value:

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

ReadCondHandleKey for CaloDetDescrManager.

Definition at line 62 of file PFClusterSelectorTool.h.

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

---

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

• PFClusterSelectorTool.h
• PFClusterSelectorTool.cxx