diff --git a/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.cxx b/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.cxx
index 4a52a704bee1968c34892df956390086fb366761..b2d683b7b41efe79be3e9a2f36b28d072f1892f4 100644
--- a/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.cxx
+++ b/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.cxx
@@ -4,55 +4,69 @@
Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
-// IsolationBuilder.cxx
+// IsolationBuilder.cxx
// Implementation file for class IsolationBuilder
-///////////////////////////////////////////////////////////////////
-
+///////////////////////////////////////////////////////////////////
// Isolation includes
#include "IsolationBuilder.h"
#include "xAODEgamma/Egamma.h"
-#include "xAODEgamma/Photon.h"
#include "xAODEgamma/EgammaxAODHelpers.h"
+#include "xAODEgamma/Photon.h"
-IsolationBuilder::IsolationBuilder( const std::string& name,
- ISvcLocator* pSvcLocator ) :
- ::AthAlgorithm( name, pSvcLocator )
-{
-}
+IsolationBuilder::IsolationBuilder(const std::string& name,
+ ISvcLocator* pSvcLocator)
+ : ::AthReentrantAlgorithm(name, pSvcLocator)
+{}
IsolationBuilder::~IsolationBuilder() {}
-StatusCode IsolationBuilder::initialize()
+StatusCode
+IsolationBuilder::initialize()
{
- ATH_MSG_INFO ("Initializing " << name() << "...");
-
+ ATH_MSG_INFO("Initializing " << name() << "...");
+
std::set<xAOD::Iso::IsolationFlavour> runIsoType;
-
+
ATH_MSG_DEBUG("Initializing central electrons");
- ATH_CHECK(initializeIso(runIsoType, &m_elCaloIso, &m_elTrackIso,
- m_ElectronContainerName,
- m_elisoInts, m_elcorInts, m_elcorIntsExtra,
- m_customConfigEl));
-
+ ATH_CHECK(initializeIso(runIsoType,
+ &m_elCaloIso,
+ &m_elTrackIso,
+ m_ElectronContainerName,
+ m_elisoInts,
+ m_elcorInts,
+ m_elcorIntsExtra,
+ m_customConfigEl));
+
ATH_MSG_DEBUG("Initializing central photons");
- ATH_CHECK(initializeIso(runIsoType, &m_phCaloIso, &m_phTrackIso,
- m_PhotonContainerName,
- m_phisoInts, m_phcorInts, m_phcorIntsExtra,
- m_customConfigPh));
-
+ ATH_CHECK(initializeIso(runIsoType,
+ &m_phCaloIso,
+ &m_phTrackIso,
+ m_PhotonContainerName,
+ m_phisoInts,
+ m_phcorInts,
+ m_phcorIntsExtra,
+ m_customConfigPh));
+
ATH_MSG_DEBUG("Initializing forward electrons");
- ATH_CHECK(initializeIso(runIsoType, &m_feCaloIso, nullptr,
- m_FwdElectronContainerName,
- m_feisoInts, m_fecorInts, m_fecorIntsExtra,
- m_customConfigFwd));
+ ATH_CHECK(initializeIso(runIsoType,
+ &m_feCaloIso,
+ nullptr,
+ m_FwdElectronContainerName,
+ m_feisoInts,
+ m_fecorInts,
+ m_fecorIntsExtra,
+ m_customConfigFwd));
ATH_MSG_DEBUG("Initializing muons");
- ATH_CHECK(initializeIso(runIsoType, &m_muCaloIso, &m_muTrackIso,
- m_MuonContainerName,
- m_muisoInts, m_mucorInts, m_mucorIntsExtra,
- m_customConfigMu));
-
+ ATH_CHECK(initializeIso(runIsoType,
+ &m_muCaloIso,
+ &m_muTrackIso,
+ m_MuonContainerName,
+ m_muisoInts,
+ m_mucorInts,
+ m_mucorIntsExtra,
+ m_customConfigMu));
// declare the dependencies
// (need to do this since the WriteDecorHandleKeys are not properties
@@ -66,72 +80,76 @@ StatusCode IsolationBuilder::initialize()
declareIso(m_muTrackIso);
// Retrieve the tools (there three Calo ones are the same in fact)
- if (!m_cellIsolationTool.empty() && runIsoType.find(xAOD::Iso::etcone) != runIsoType.end()) {
+ if (!m_cellIsolationTool.empty() &&
+ runIsoType.find(xAOD::Iso::etcone) != runIsoType.end()) {
ATH_CHECK(m_cellIsolationTool.retrieve());
} else {
m_cellIsolationTool.disable();
}
- if (!m_topoIsolationTool.empty() && runIsoType.find(xAOD::Iso::topoetcone) != runIsoType.end()) {
+ if (!m_topoIsolationTool.empty() &&
+ runIsoType.find(xAOD::Iso::topoetcone) != runIsoType.end()) {
ATH_CHECK(m_topoIsolationTool.retrieve());
} else {
m_topoIsolationTool.disable();
}
- if (!m_pflowIsolationTool.empty() && runIsoType.find(xAOD::Iso::neflowisol) != runIsoType.end()) {
+ if (!m_pflowIsolationTool.empty() &&
+ runIsoType.find(xAOD::Iso::neflowisol) != runIsoType.end()) {
ATH_CHECK(m_pflowIsolationTool.retrieve());
} else {
m_pflowIsolationTool.disable();
}
- if (!m_trackIsolationTool.empty() && runIsoType.find(xAOD::Iso::IsolationFlavour::ptcone) != runIsoType.end()) {
+ if (!m_trackIsolationTool.empty() &&
+ runIsoType.find(xAOD::Iso::IsolationFlavour::ptcone) !=
+ runIsoType.end()) {
ATH_CHECK(m_trackIsolationTool.retrieve());
} else {
m_trackIsolationTool.disable();
}
-
- //initialise data handles
+
+ // initialise data handles
ATH_CHECK(m_cellsKey.initialize(!m_cellIsolationTool.empty()));
return StatusCode::SUCCESS;
}
-StatusCode IsolationBuilder::finalize()
+StatusCode
+IsolationBuilder::finalize()
{
- ATH_MSG_INFO ("Finalizing " << name() << "...");
+ ATH_MSG_INFO("Finalizing " << name() << "...");
return StatusCode::SUCCESS;
}
-StatusCode IsolationBuilder::execute()
-{
- ATH_MSG_DEBUG ("Executing " << name() << "...");
+StatusCode
+IsolationBuilder::execute(const EventContext& ctx) const
+{
+ ATH_MSG_DEBUG("Executing " << name() << "...");
// For etcone, needs the cells
+
+ const CaloCellContainer* cellColl = nullptr;
if (!m_cellIsolationTool.empty()) {
- SG::ReadHandle<CaloCellContainer> cellcoll(m_cellsKey);
-
+ SG::ReadHandle<CaloCellContainer> cellcoll(m_cellsKey, ctx);
// check is only used for serial running; remove when MT scheduler used
- if(!cellcoll.isValid()) {
- ATH_MSG_FATAL("Failed to retrieve cell container: "<< m_cellsKey.key());
+ if (!cellcoll.isValid()) {
+ ATH_MSG_FATAL("Failed to retrieve cell container: " << m_cellsKey.key());
return StatusCode::FAILURE;
}
-
- m_cellColl = cellcoll.cptr();
- } else {
- m_cellColl = nullptr;
+ cellColl = cellcoll.cptr();
}
-
// Compute isolations
ATH_MSG_DEBUG("About to execute Electron calo iso");
- ATH_CHECK(executeCaloIso(m_elCaloIso));
+ ATH_CHECK(executeCaloIso(m_elCaloIso, cellColl));
ATH_MSG_DEBUG("About to execute Photon calo iso");
- ATH_CHECK(executeCaloIso(m_phCaloIso));
+ ATH_CHECK(executeCaloIso(m_phCaloIso, cellColl));
ATH_MSG_DEBUG("About to execute Forwerd Electron calo iso");
- ATH_CHECK(executeCaloIso(m_feCaloIso));
+ ATH_CHECK(executeCaloIso(m_feCaloIso, cellColl));
ATH_MSG_DEBUG("About to execute muon calo iso");
- ATH_CHECK(executeCaloIso(m_muCaloIso));
+ ATH_CHECK(executeCaloIso(m_muCaloIso, cellColl));
ATH_MSG_DEBUG("About to execute Electron track iso");
ATH_CHECK(executeTrackIso(m_elTrackIso));
@@ -139,7 +157,7 @@ StatusCode IsolationBuilder::execute()
ATH_CHECK(executeTrackIso(m_phTrackIso));
ATH_MSG_DEBUG("About to execute Muon track iso");
ATH_CHECK(executeTrackIso(m_muTrackIso));
-
+
return StatusCode::SUCCESS;
}
@@ -151,7 +169,8 @@ IsolationBuilder::CaloIsoHelpKey::CaloIsoHelpKey(IDataHandleHolder* owningAlg)
}
// declare dependencies
-void IsolationBuilder::CaloIsoHelpKey::declare(IDataHandleHolder* owningAlg)
+void
+IsolationBuilder::CaloIsoHelpKey::declare(IDataHandleHolder* owningAlg)
{
isoDeco.declare(owningAlg);
owningAlg->declare(corrBitsetDeco);
@@ -174,7 +193,8 @@ IsolationBuilder::TrackIsoHelpKey::TrackIsoHelpKey(IDataHandleHolder* owningAlg)
}
// declare dependencies
-void IsolationBuilder::TrackIsoHelpKey::declare(IDataHandleHolder* owningAlg)
+void
+IsolationBuilder::TrackIsoHelpKey::declare(IDataHandleHolder* owningAlg)
{
isoDeco.declare(owningAlg);
isoDecoV.declare(owningAlg);
@@ -186,8 +206,9 @@ void IsolationBuilder::TrackIsoHelpKey::declare(IDataHandleHolder* owningAlg)
}
// constructor
-IsolationBuilder::CaloIsoHelpHandles::CaloIsoHelpHandles(const IsolationBuilder::CaloIsoHelpKey& keys) :
- corrBitsetDeco(keys.corrBitsetDeco)
+IsolationBuilder::CaloIsoHelpHandles::CaloIsoHelpHandles(
+ const IsolationBuilder::CaloIsoHelpKey& keys)
+ : corrBitsetDeco(keys.corrBitsetDeco)
{
for (const auto& key : keys.isoDeco) {
isoDeco.emplace_back(key);
@@ -196,15 +217,16 @@ IsolationBuilder::CaloIsoHelpHandles::CaloIsoHelpHandles(const IsolationBuilder:
coreCorDeco.emplace(coreCor);
}
for (const auto& noncoreCor : keys.noncoreCorDeco) {
- noncoreCorDeco.emplace(noncoreCor.first,
- std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float> >{
- std::begin(noncoreCor.second),
- std::end(noncoreCor.second)});
+ noncoreCorDeco.emplace(
+ noncoreCor.first,
+ std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float>>{
+ std::begin(noncoreCor.second), std::end(noncoreCor.second) });
}
}
-IsolationBuilder::TrackIsoHelpHandles::TrackIsoHelpHandles(const IsolationBuilder::TrackIsoHelpKey& keys) :
- corrBitsetDeco(keys.corrBitsetDeco)
+IsolationBuilder::TrackIsoHelpHandles::TrackIsoHelpHandles(
+ const IsolationBuilder::TrackIsoHelpKey& keys)
+ : corrBitsetDeco(keys.corrBitsetDeco)
{
for (const auto& key : keys.isoDeco) {
isoDeco.emplace_back(key);
@@ -217,26 +239,29 @@ IsolationBuilder::TrackIsoHelpHandles::TrackIsoHelpHandles(const IsolationBuilde
}
}
-bool IsolationBuilder::isCoreCor(xAOD::Iso::IsolationCaloCorrection cor) {
- return (cor == xAOD::Iso::coreCone ||
- cor == xAOD::Iso::coreConeSC ||
- cor == xAOD::Iso::coreMuon ||
- cor == xAOD::Iso::core57cells);
+bool
+IsolationBuilder::isCoreCor(xAOD::Iso::IsolationCaloCorrection cor)
+{
+ return (cor == xAOD::Iso::coreCone || cor == xAOD::Iso::coreConeSC ||
+ cor == xAOD::Iso::coreMuon || cor == xAOD::Iso::core57cells);
}
-
-StatusCode IsolationBuilder::initializeIso(std::set<xAOD::Iso::IsolationFlavour>& runIsoType, // out
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> >* caloIsoMap, // out
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> >* trackIsoMap, // out
- const std::string& containerName,
- const std::vector<std::vector<int> >& isoInts,
- const std::vector<std::vector<int> >& corInts,
- const std::vector<std::vector<int> >& corIntsExtra,
- const std::string& customConfig)
+StatusCode
+IsolationBuilder::initializeIso(
+ std::set<xAOD::Iso::IsolationFlavour>& runIsoType, // out
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>*
+ caloIsoMap, // out
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>*
+ trackIsoMap, // out
+ const std::string& containerName,
+ const std::vector<std::vector<int>>& isoInts,
+ const std::vector<std::vector<int>>& corInts,
+ const std::vector<std::vector<int>>& corIntsExtra,
+ const std::string& customConfig)
{
-
+
std::string prefix = containerName + ".";
-
+
for (size_t flavor = 0; flavor < isoInts.size(); flavor++) {
// iterate over the flavor (cell, topo, eflow, track
// Note: it is a configuration error if different types
@@ -244,50 +269,56 @@ StatusCode IsolationBuilder::initializeIso(std::set<xAOD::Iso::IsolationFlavour>
CaloIsoHelpKey cisoH(this);
TrackIsoHelpKey tisoH(this);
-
- //std::vector<SG::AuxElement::Decorator<float>*> Deco;
- xAOD::Iso::IsolationFlavour isoFlav =
- xAOD::Iso::numIsolationFlavours;
- xAOD::Iso::IsolationFlavour oldIsoFlav =
- xAOD::Iso::numIsolationFlavours;
-
- for (size_t type = 0; type < isoInts[flavor].size();type++) {
+
+ // std::vector<SG::AuxElement::Decorator<float>*> Deco;
+ xAOD::Iso::IsolationFlavour isoFlav = xAOD::Iso::numIsolationFlavours;
+ xAOD::Iso::IsolationFlavour oldIsoFlav = xAOD::Iso::numIsolationFlavours;
+
+ for (size_t type = 0; type < isoInts[flavor].size(); type++) {
// iterate over the cone sizes for a given flavor.
- // (also check that the cone sizes really are of the same flavor; otherwise an error)
-
- xAOD::Iso::IsolationType isoType = static_cast<xAOD::Iso::IsolationType>(isoInts[flavor][type]);
+ // (also check that the cone sizes really are of the same flavor;
+ // otherwise an error)
+
+ xAOD::Iso::IsolationType isoType =
+ static_cast<xAOD::Iso::IsolationType>(isoInts[flavor][type]);
isoFlav = xAOD::Iso::isolationFlavour(isoType);
ATH_MSG_DEBUG("Saw isoType " << isoType << " and isoFlav " << isoFlav);
- if (oldIsoFlav != xAOD::Iso::numIsolationFlavours && oldIsoFlav != isoFlav) {
- ATH_MSG_FATAL("Configuration error: can only have one type of isolation in inner vector");
- return StatusCode::FAILURE;
+ if (oldIsoFlav != xAOD::Iso::numIsolationFlavours &&
+ oldIsoFlav != isoFlav) {
+ ATH_MSG_FATAL("Configuration error: can only have one type of "
+ "isolation in inner vector");
+ return StatusCode::FAILURE;
}
oldIsoFlav = isoFlav;
std::string isoName = prefix + xAOD::Iso::toString(isoType);
- if (customConfig != "") {
- isoName += "_" + customConfig;
+ if (!customConfig.empty()) {
+ isoName += "_" + customConfig;
}
- if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone || isoFlav == xAOD::Iso::neflowisol) {
- cisoH.isoTypes.push_back(isoType);
- cisoH.isoDeco.emplace_back(isoName);
+ if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
+ isoFlav == xAOD::Iso::neflowisol) {
+ cisoH.isoTypes.push_back(isoType);
+ cisoH.isoDeco.emplace_back(isoName);
} else if (isoFlav == xAOD::Iso::ptcone) {
- tisoH.isoTypes.push_back(isoType);
- tisoH.isoDeco.emplace_back(isoName);
- auto coneSize = static_cast<int>(round(100*xAOD::Iso::coneSize(isoType)));
- std::string isoNameV = prefix + "ptvarcone" + std::to_string(coneSize);
- if (customConfig != "") {
- isoNameV += "_" + customConfig;
- }
- tisoH.isoDecoV.emplace_back(isoNameV);
+ tisoH.isoTypes.push_back(isoType);
+ tisoH.isoDeco.emplace_back(isoName);
+ auto coneSize =
+ static_cast<int>(round(100 * xAOD::Iso::coneSize(isoType)));
+ std::string isoNameV = prefix + "ptvarcone" + std::to_string(coneSize);
+ if (!customConfig.empty()) {
+ isoNameV += "_" + customConfig;
+ }
+ tisoH.isoDecoV.emplace_back(isoNameV);
} else {
- ATH_MSG_FATAL("Configuration error: Isolation flavor " << isoFlav << " not supported.");
- return StatusCode::FAILURE;
- }
+ ATH_MSG_FATAL("Configuration error: Isolation flavor "
+ << isoFlav << " not supported.");
+ return StatusCode::FAILURE;
+ }
}
-
+
// check that there were isolations configured
if (isoFlav == xAOD::Iso::numIsolationFlavours) {
- ATH_MSG_WARNING("The configuration was malformed: an empty inner vector was added; ignoring");
+ ATH_MSG_WARNING("The configuration was malformed: an empty inner vector "
+ "was added; ignoring");
continue;
}
@@ -298,133 +329,149 @@ StatusCode IsolationBuilder::initializeIso(std::set<xAOD::Iso::IsolationFlavour>
// and finally add it to the IsoMap.
///////////////////////////////
- if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone || isoFlav == xAOD::Iso::neflowisol) {
-
+ if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
+ isoFlav == xAOD::Iso::neflowisol) {
+
// let's initialize the decos
ATH_MSG_DEBUG("Initializing cisoH.isoDeco");
ATH_CHECK(cisoH.isoDeco.initialize());
- ATH_CHECK(addCaloIsoCorrections(flavor, isoFlav, cisoH, corInts, false, prefix, customConfig));
- ATH_CHECK(addCaloIsoCorrections(flavor, isoFlav, cisoH, corIntsExtra, true, prefix, customConfig));
-
+ ATH_CHECK(addCaloIsoCorrections(
+ flavor, isoFlav, cisoH, corInts, false, prefix, customConfig));
+ ATH_CHECK(addCaloIsoCorrections(
+ flavor, isoFlav, cisoH, corIntsExtra, true, prefix, customConfig));
+
if (caloIsoMap) {
- caloIsoMap->push_back(std::make_pair(isoFlav,cisoH));
+ caloIsoMap->push_back(std::make_pair(isoFlav, cisoH));
} else {
- ATH_MSG_FATAL("caloIsoMap was nullptr but the configuration attempted to use it");
- return StatusCode::FAILURE;
+ ATH_MSG_FATAL(
+ "caloIsoMap was nullptr but the configuration attempted to use it");
+ return StatusCode::FAILURE;
}
} else if (isoFlav == xAOD::Iso::ptcone) {
-
+
// let's initialize the decos
ATH_MSG_DEBUG("Initializing tisoH.isoDeco");
ATH_CHECK(tisoH.isoDeco.initialize());
ATH_MSG_DEBUG("Initializing tisoH.isoDecoV");
ATH_CHECK(tisoH.isoDecoV.initialize());
-
- ATH_CHECK(addTrackIsoCorrections(flavor, isoFlav, tisoH, corInts, false, prefix, customConfig));
- ATH_CHECK(addTrackIsoCorrections(flavor, isoFlav, tisoH, corIntsExtra, true, prefix, customConfig));
-
+
+ ATH_CHECK(addTrackIsoCorrections(
+ flavor, isoFlav, tisoH, corInts, false, prefix, customConfig));
+ ATH_CHECK(addTrackIsoCorrections(
+ flavor, isoFlav, tisoH, corIntsExtra, true, prefix, customConfig));
+
if (trackIsoMap) {
- trackIsoMap->push_back(std::make_pair(isoFlav,tisoH));
+ trackIsoMap->push_back(std::make_pair(isoFlav, tisoH));
} else {
- ATH_MSG_FATAL("trackIsoMap was nullptr but the configuration attempted to use it");
- return StatusCode::FAILURE;
- }
+ ATH_MSG_FATAL(
+ "trackIsoMap was nullptr but the configuration attempted to use it");
+ return StatusCode::FAILURE;
+ }
} else {
- ATH_MSG_WARNING("Isolation flavour " << xAOD::Iso::toCString(isoFlav) << " does not exist ! Check your inputs");
+ ATH_MSG_WARNING("Isolation flavour "
+ << xAOD::Iso::toCString(isoFlav)
+ << " does not exist ! Check your inputs");
}
runIsoType.insert(isoFlav);
}
return StatusCode::SUCCESS;
}
-
-StatusCode IsolationBuilder::addCaloIsoCorrections(size_t flavor,
- xAOD::Iso::IsolationFlavour isoFlav,
- CaloIsoHelpKey& cisoH,
- const std::vector<std::vector<int> >& corInts,
- bool corrsAreExtra,
- const std::string& prefix,
- const std::string& customConfig )
+StatusCode
+IsolationBuilder::addCaloIsoCorrections(
+ size_t flavor,
+ xAOD::Iso::IsolationFlavour isoFlav,
+ CaloIsoHelpKey& cisoH,
+ const std::vector<std::vector<int>>& corInts,
+ bool corrsAreExtra,
+ const std::string& prefix,
+ const std::string& customConfig)
{
-
+
if (!corrsAreExtra) {
- std::string bitsetName = prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
- if (customConfig != "") {
+ std::string bitsetName =
+ prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
+ if (!customConfig.empty()) {
bitsetName += "_" + customConfig;
}
-
+
cisoH.corrBitsetDeco = bitsetName;
ATH_MSG_DEBUG("Initializing " << cisoH.corrBitsetDeco.key());
ATH_CHECK(cisoH.corrBitsetDeco.initialize());
}
for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
-
+
// iterate over the calo isolation corrections
const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
- if (!corrsAreExtra) cisoH.CorrList.calobitset.set(cor);
- const xAOD::Iso::IsolationCaloCorrection isoCor = static_cast<xAOD::Iso::IsolationCaloCorrection>(cor);
-
- // ATH_MSG_DEBUG("for corrections, prefix = " << prefix << ", flavor = " << xAOD::Iso::toString(isoFlav)
- // << ", cor = " << xAOD::Iso::toString(isoCor) << ", coreEnergy " << xAOD::Iso::toString(xAOD::Iso::coreEnergy));
-
-
+ if (!corrsAreExtra)
+ cisoH.CorrList.calobitset.set(cor);
+ const xAOD::Iso::IsolationCaloCorrection isoCor =
+ static_cast<xAOD::Iso::IsolationCaloCorrection>(cor);
+
if (isCoreCor(isoCor)) {
std::string isoCorName = prefix;
-
+
if (isoCor != xAOD::Iso::core57cells) {
- isoCorName += xAOD::Iso::toString(isoFlav); // since this doesn't depend on the flavor, just have one
+ isoCorName += xAOD::Iso::toString(
+ isoFlav); // since this doesn't depend on the flavor, just have one
}
-
+
// a core correction; only store core energy, not the core area
- isoCorName += xAOD::Iso::toString(isoCor) + xAOD::Iso::toString(xAOD::Iso::coreEnergy)
- + "Correction";
- if (customConfig != "") {
- isoCorName += "_" + customConfig;
+ isoCorName += xAOD::Iso::toString(isoCor) +
+ xAOD::Iso::toString(xAOD::Iso::coreEnergy) + "Correction";
+ if (!customConfig.empty()) {
+ isoCorName += "_" + customConfig;
}
cisoH.coreCorDeco.emplace(isoCor, isoCorName);
cisoH.coreCorDeco[isoCor].setOwner(this);
ATH_MSG_DEBUG("initializing " << cisoH.coreCorDeco[isoCor].key());
ATH_CHECK(cisoH.coreCorDeco[isoCor].initialize());
} else if (isoCor == xAOD::Iso::pileupCorrection) {
- // do not store pileup corrections as they are rho * pi * (R**2 - areaCore) and rho is stored...
+ // do not store pileup corrections as they are rho * pi * (R**2 -
+ // areaCore) and rho is stored...
continue;
- } else {
+ } else {
// noncore correction
- cisoH.noncoreCorDeco.emplace(isoCor, SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer>() );
+ cisoH.noncoreCorDeco.emplace(
+ isoCor, SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer>());
auto& vec = cisoH.noncoreCorDeco[isoCor];
vec.setOwner(this);
for (auto type : cisoH.isoTypes) {
- std::string corName = prefix + xAOD::Iso::toString(type) + xAOD::Iso::toString(isoCor) + "Correction";
- if (customConfig != "") {
- corName += "_" + customConfig;
- }
- vec.emplace_back(corName);
+ std::string corName = prefix + xAOD::Iso::toString(type) +
+ xAOD::Iso::toString(isoCor) + "Correction";
+ if (!customConfig.empty()) {
+ corName += "_" + customConfig;
+ }
+ vec.emplace_back(corName);
}
- ATH_MSG_DEBUG("Initializing " << xAOD::Iso::toString(isoCor) << " Corrections");
+ ATH_MSG_DEBUG("Initializing " << xAOD::Iso::toString(isoCor)
+ << " Corrections");
ATH_CHECK(vec.initialize());
}
}
return StatusCode::SUCCESS;
}
-
-StatusCode IsolationBuilder::addTrackIsoCorrections(size_t flavor,
- xAOD::Iso::IsolationFlavour isoFlav,
- TrackIsoHelpKey& tisoH,
- const std::vector<std::vector<int> >& corInts,
- bool corrsAreExtra,
- const std::string& prefix,
- const std::string& customConfig)
+StatusCode
+IsolationBuilder::addTrackIsoCorrections(
+ size_t flavor,
+ xAOD::Iso::IsolationFlavour isoFlav,
+ TrackIsoHelpKey& tisoH,
+ const std::vector<std::vector<int>>& corInts,
+ bool corrsAreExtra,
+ const std::string& prefix,
+ const std::string& customConfig)
{
if (!corrsAreExtra) {
- std::string bitsetName = prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
- if (customConfig != "") {
+ std::string bitsetName =
+ prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
+ if (!customConfig.empty()) {
bitsetName += "_" + customConfig;
}
-
+
tisoH.corrBitsetDeco = bitsetName;
ATH_MSG_DEBUG("Initializing " << tisoH.corrBitsetDeco.key());
ATH_CHECK(tisoH.corrBitsetDeco.initialize());
@@ -432,14 +479,16 @@ StatusCode IsolationBuilder::addTrackIsoCorrections(size_t flavor,
for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
- if (!corrsAreExtra) tisoH.CorrList.trackbitset.set(cor);
- const xAOD::Iso::IsolationTrackCorrection isoCor = static_cast<xAOD::Iso::IsolationTrackCorrection>(cor);
-
+ if (!corrsAreExtra)
+ tisoH.CorrList.trackbitset.set(cor);
+ const xAOD::Iso::IsolationTrackCorrection isoCor =
+ static_cast<xAOD::Iso::IsolationTrackCorrection>(cor);
+
// all pt corrections are core type
- std::string isoCorName = prefix + xAOD::Iso::toString(isoFlav) +
- xAOD::Iso::toString(isoCor) + "Correction";
-
- if (customConfig != "") {
+ std::string isoCorName = prefix + xAOD::Iso::toString(isoFlav) +
+ xAOD::Iso::toString(isoCor) + "Correction";
+
+ if (!customConfig.empty()) {
isoCorName += "_" + customConfig;
}
tisoH.coreCorDeco.emplace(isoCor, isoCorName);
@@ -450,227 +499,236 @@ StatusCode IsolationBuilder::addTrackIsoCorrections(size_t flavor,
return StatusCode::SUCCESS;
}
-StatusCode IsolationBuilder::executeCaloIso(const std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> >& caloIsoMap)
+StatusCode
+IsolationBuilder::executeCaloIso(
+ const std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>&
+ caloIsoMap,
+ const CaloCellContainer* cellColl) const
{
for (const auto& pr : caloIsoMap) {
const xAOD::Iso::IsolationFlavour flav = pr.first;
- const auto& keys = pr.second;
+ const auto& keys = pr.second;
CaloIsoHelpHandles handles(keys);
ATH_MSG_DEBUG("Executing calo iso flavor: " << xAOD::Iso::toString(flav));
if (handles.isoDeco.empty()) {
- ATH_MSG_FATAL("Have a CaloIsoHelpHandles with no actual isolations; something wrong happened");
+ ATH_MSG_FATAL("Have a CaloIsoHelpHandles with no actual isolations; "
+ "something wrong happened");
return StatusCode::FAILURE;
}
- auto& readHandle = handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
+ auto& readHandle =
+ handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
if (!readHandle.isValid()) {
- ATH_MSG_FATAL("Could not retrieve read handle for " << keys.isoDeco[0].key());
+ ATH_MSG_FATAL("Could not retrieve read handle for "
+ << keys.isoDeco[0].key());
return StatusCode::FAILURE;
}
- for (auto part : *readHandle) {
+ for (const auto *part : *readHandle) {
xAOD::CaloIsolation CaloIsoResult;
bool successfulCalc = false;
- if (flav == xAOD::Iso::IsolationFlavour::etcone && m_cellColl) {
- successfulCalc = m_cellIsolationTool->caloCellIsolation(CaloIsoResult, *part, keys.isoTypes, keys.CorrList, m_cellColl);
+ if (flav == xAOD::Iso::IsolationFlavour::etcone && cellColl) {
+ successfulCalc = m_cellIsolationTool->caloCellIsolation(
+ CaloIsoResult, *part, keys.isoTypes, keys.CorrList, cellColl);
} else if (flav == xAOD::Iso::IsolationFlavour::topoetcone) {
- successfulCalc = m_topoIsolationTool->caloTopoClusterIsolation(CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
+ successfulCalc = m_topoIsolationTool->caloTopoClusterIsolation(
+ CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
} else if (flav == xAOD::Iso::IsolationFlavour::neflowisol) {
- successfulCalc = m_pflowIsolationTool->neutralEflowIsolation(CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
+ successfulCalc = m_pflowIsolationTool->neutralEflowIsolation(
+ CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
}
if (successfulCalc) {
- for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
- float iso = CaloIsoResult.etcones[i];
- ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i]) << " = " << iso/1e3);
- (handles.isoDeco[i])(*part) = iso;
- }
- // corrections
- (handles.corrBitsetDeco)(*part) = keys.CorrList.calobitset.to_ulong();
-
- // // let's do the core corrections
- // for (const auto& coreCorPr : CaloIsoResult.coreCorrections) {
- // std::map<xAOD::Iso::IsolationCorrectionParameter,float>::const_iterator it =
- // coreCorPr.second.find(xAOD::Iso::coreEnergy);
- // if (it != coreCorPr.second.end()) {
- // ATH_MSG_DEBUG("About to write core correction: " << coreCorPr.first);
- // try {
- // (handles.coreCorDeco.at(coreCorPr.first))(*part) = it->second;
- // } catch (const std::exception& e) {
- // ATH_MSG_FATAL("Failed writing the core iso correction: " << e.what());
- // return StatusCode::FAILURE;
- // }
- // }
- // }
-
- // let's do the core corrections
-
- // iterate over the values we want to store
- for (auto& coreCorDecoPr : handles.coreCorDeco) {
- // find the matching result
- auto corIter = CaloIsoResult.coreCorrections.find(coreCorDecoPr.first);
- if (corIter == CaloIsoResult.coreCorrections.end()) {
- ATH_MSG_FATAL("Could not find core correction of required type: " << xAOD::Iso::toCString(coreCorDecoPr.first));
- ATH_MSG_FATAL("Check configuration");
- return StatusCode::FAILURE;
- }
- // now that we have the match, let's find the energy
- std::map<xAOD::Iso::IsolationCorrectionParameter,float>::const_iterator it =
- corIter->second.find(xAOD::Iso::coreEnergy);
- if (it == corIter->second.end()) {
- ATH_MSG_FATAL("Could not find coreEnergy correction for: " << xAOD::Iso::toCString(coreCorDecoPr.first));
- ATH_MSG_FATAL("Check configuration");
- return StatusCode::FAILURE;
- }
- ATH_MSG_DEBUG("About to write core correction: " << xAOD::Iso::toCString(coreCorDecoPr.first));
- (coreCorDecoPr.second)(*part) = it->second;
- }
-
- // // let's do the noncore corrections
- // for (const auto& noncoreCorPr : CaloIsoResult.noncoreCorrections) {
- // auto& vecHandles = handles.noncoreCorDeco[noncoreCorPr.first];
- // if (vecHandles.size() != noncoreCorPr.second.size()) {
- // ATH_MSG_FATAL("Got back the wrong number of corrections for " << noncoreCorPr.first);
- // ATH_MSG_FATAL(" Expected: " << vecHandles.size() << ", received: " << noncoreCorPr.second.size());
- // return StatusCode::FAILURE;
- // }
- // for (size_t i = 0; i < vecHandles.size(); i++) {
- // (vecHandles[i])(*part) = noncoreCorPr.second[i];
- // }
- // }
-
- // let's do the noncore corrections
- for (auto& noncoreCorDecoPr : handles.noncoreCorDeco) {
- // find the matching result
- auto corIter = CaloIsoResult.noncoreCorrections.find(noncoreCorDecoPr.first);
- if (corIter == CaloIsoResult.noncoreCorrections.end()) {
- ATH_MSG_FATAL("Could not find noncore correction of required type: " << xAOD::Iso::toCString(noncoreCorDecoPr.first));
- ATH_MSG_FATAL("Check configuration");
- return StatusCode::FAILURE;
- }
-
- ATH_MSG_DEBUG("About to write noncore correction: " << xAOD::Iso::toCString(noncoreCorDecoPr.first));
- auto& vecHandles = noncoreCorDecoPr.second;
- for (size_t i = 0; i < vecHandles.size(); i++) {
- (vecHandles[i])(*part) = corIter->second[i];
- }
- }
+ for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
+ float iso = CaloIsoResult.etcones[i];
+ ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
+ << " = " << iso / 1e3);
+ (handles.isoDeco[i])(*part) = iso;
+ }
+ // corrections
+ (handles.corrBitsetDeco)(*part) = keys.CorrList.calobitset.to_ulong();
+
+ // let's do the core corrections
+
+ // iterate over the values we want to store
+ for (auto& coreCorDecoPr : handles.coreCorDeco) {
+ // find the matching result
+ auto corIter =
+ CaloIsoResult.coreCorrections.find(coreCorDecoPr.first);
+ if (corIter == CaloIsoResult.coreCorrections.end()) {
+ ATH_MSG_FATAL("Could not find core correction of required type: "
+ << xAOD::Iso::toCString(coreCorDecoPr.first));
+ ATH_MSG_FATAL("Check configuration");
+ return StatusCode::FAILURE;
+ }
+ // now that we have the match, let's find the energy
+ std::map<xAOD::Iso::IsolationCorrectionParameter,
+ float>::const_iterator it =
+ corIter->second.find(xAOD::Iso::coreEnergy);
+ if (it == corIter->second.end()) {
+ ATH_MSG_FATAL("Could not find coreEnergy correction for: "
+ << xAOD::Iso::toCString(coreCorDecoPr.first));
+ ATH_MSG_FATAL("Check configuration");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_DEBUG("About to write core correction: "
+ << xAOD::Iso::toCString(coreCorDecoPr.first));
+ (coreCorDecoPr.second)(*part) = it->second;
+ }
+
+ // let's do the noncore corrections
+ for (auto& noncoreCorDecoPr : handles.noncoreCorDeco) {
+ // find the matching result
+ auto corIter =
+ CaloIsoResult.noncoreCorrections.find(noncoreCorDecoPr.first);
+ if (corIter == CaloIsoResult.noncoreCorrections.end()) {
+ ATH_MSG_FATAL("Could not find noncore correction of required type: "
+ << xAOD::Iso::toCString(noncoreCorDecoPr.first));
+ ATH_MSG_FATAL("Check configuration");
+ return StatusCode::FAILURE;
+ }
+
+ ATH_MSG_DEBUG("About to write noncore correction: "
+ << xAOD::Iso::toCString(noncoreCorDecoPr.first));
+ auto& vecHandles = noncoreCorDecoPr.second;
+ for (size_t i = 0; i < vecHandles.size(); i++) {
+ (vecHandles[i])(*part) = corIter->second[i];
+ }
+ }
} else {
- ATH_MSG_FATAL("Call to CaloIsolationTool failed for flavor " << xAOD::Iso::toCString(flav));
- return StatusCode::FAILURE;
+ ATH_MSG_FATAL("Call to CaloIsolationTool failed for flavor "
+ << xAOD::Iso::toCString(flav));
+ return StatusCode::FAILURE;
}
}
}
return StatusCode::SUCCESS;
}
-// FIXME: need to add the electron bremAssoc
-StatusCode IsolationBuilder::executeTrackIso(const std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey > >& trackIsoMap)
+StatusCode
+IsolationBuilder::executeTrackIso(
+ const std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>&
+ trackIsoMap) const
{
for (const auto& pr : trackIsoMap) {
const xAOD::Iso::IsolationFlavour flav = pr.first;
- const auto& keys = pr.second;
+ const auto& keys = pr.second;
TrackIsoHelpHandles handles(keys);
ATH_MSG_DEBUG("Executing track iso flavor: " << xAOD::Iso::toString(flav));
if (handles.isoDeco.empty()) {
- ATH_MSG_FATAL("Have a TrackIsoHelpHandles with no actual isolations; something wrong happened");
+ ATH_MSG_FATAL("Have a TrackIsoHelpHandles with no actual isolations; "
+ "something wrong happened");
return StatusCode::FAILURE;
}
- auto& readHandle = handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
+ auto& readHandle =
+ handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
if (!readHandle.isValid()) {
- ATH_MSG_FATAL("Could not retrieve read handle for " << keys.isoDeco[0].key());
+ ATH_MSG_FATAL("Could not retrieve read handle for "
+ << keys.isoDeco[0].key());
return StatusCode::FAILURE;
}
- for (auto part : *readHandle) {
+ for (const auto *part : *readHandle) {
xAOD::TrackIsolation TrackIsoResult;
bool successfulCalc = false;
// check to see if we are dealing with an electron
- auto *eg = dynamic_cast<const xAOD::Egamma*>(part);
+ const auto * eg = dynamic_cast<const xAOD::Egamma*>(part);
if (eg) {
- ATH_MSG_DEBUG("Doing track isolation on an egamma particle");
- std::set<const xAOD::TrackParticle*> tracksToExclude;
- if (xAOD::EgammaHelpers::isElectron(eg)) {
- tracksToExclude = xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
- } else {
- if (m_allTrackRemoval) { //New (from ??/??/16) : now this gives all tracks
- tracksToExclude = xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
- } else { // this is just to be able to have the 2015+2016 default case (only tracks from first vertex)
- auto *gam = dynamic_cast<const xAOD::Photon *>(eg);
- if (gam && gam->nVertices() > 0) {
- const xAOD::Vertex *phvtx = gam->vertex(0);
- for (unsigned int itk = 0; itk < phvtx->nTrackParticles(); itk++)
- tracksToExclude.insert(m_useBremAssoc ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(phvtx->trackParticle(itk)) : phvtx->trackParticle(itk));
- }
- }
- }
- successfulCalc = m_trackIsolationTool->trackIsolation(TrackIsoResult, *part, keys.isoTypes, keys.CorrList, nullptr, &tracksToExclude);
+ ATH_MSG_DEBUG("Doing track isolation on an egamma particle");
+ std::set<const xAOD::TrackParticle*> tracksToExclude;
+ if (xAOD::EgammaHelpers::isElectron(eg)) {
+ tracksToExclude =
+ xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
+ } else {
+ if (m_allTrackRemoval) { // New (from ??/??/16) : now this gives all
+ // tracks
+ tracksToExclude =
+ xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
+ } else { // this is just to be able to have the 2015+2016 default case
+ // (only tracks from first vertex)
+ const auto * gam = dynamic_cast<const xAOD::Photon*>(eg);
+ if (gam && gam->nVertices() > 0) {
+ const xAOD::Vertex* phvtx = gam->vertex(0);
+ for (unsigned int itk = 0; itk < phvtx->nTrackParticles(); itk++)
+ tracksToExclude.insert(
+ m_useBremAssoc
+ ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(
+ phvtx->trackParticle(itk))
+ : phvtx->trackParticle(itk));
+ }
+ }
+ }
+ successfulCalc = m_trackIsolationTool->trackIsolation(TrackIsoResult,
+ *part,
+ keys.isoTypes,
+ keys.CorrList,
+ nullptr,
+ &tracksToExclude);
} else {
- ATH_MSG_DEBUG("Not doing track isolation on an egamma particle");
- successfulCalc = m_trackIsolationTool->trackIsolation(TrackIsoResult, *part, keys.isoTypes, keys.CorrList);
+ ATH_MSG_DEBUG("Not doing track isolation on an egamma particle");
+ successfulCalc = m_trackIsolationTool->trackIsolation(
+ TrackIsoResult, *part, keys.isoTypes, keys.CorrList);
}
if (successfulCalc) {
- for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
- float iso = TrackIsoResult.ptcones[i];
- float isoV = TrackIsoResult.ptvarcones_10GeVDivPt[i];
- ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i]) << " = " << iso/1e3 << ", var cone = " << isoV/1e3);
- (handles.isoDeco[i])(*part) = iso;
- (handles.isoDecoV[i])(*part) = isoV;
- }
-
- // corrections
- (handles.corrBitsetDeco)(*part) = keys.CorrList.trackbitset.to_ulong();
-
- // // let's do the core corrections
- // for (const auto& coreCorPr : TrackIsoResult.coreCorrections) {
- // ATH_MSG_DEBUG("About to write track correction: " << coreCorPr.first);
- // try {
- // (handles.coreCorDeco.at(coreCorPr.first))(*part) = coreCorPr.second;
- // } catch (const std::exception& e) {
- // ATH_MSG_FATAL("Failed writing the track iso correction: " << e.what());
- // return StatusCode::FAILURE;
- // }
- // }
-
- // let's do the core corrections
-
- // iterate over the values we want to store
- for (auto& coreCorDecoPr : handles.coreCorDeco) {
- // find the matching result
- auto corIter = TrackIsoResult.coreCorrections.find(coreCorDecoPr.first);
- if (corIter == TrackIsoResult.coreCorrections.end()) {
- ATH_MSG_FATAL("Could not find core correction of required type: " << xAOD::Iso::toCString(coreCorDecoPr.first));
- ATH_MSG_FATAL("Check configuration");
- return StatusCode::FAILURE;
- }
- ATH_MSG_DEBUG("About to write tracking core correction: " << xAOD::Iso::toCString(coreCorDecoPr.first));
- (coreCorDecoPr.second)(*part) = corIter->second;
- }
+ for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
+ float iso = TrackIsoResult.ptcones[i];
+ float isoV = TrackIsoResult.ptvarcones_10GeVDivPt[i];
+ ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
+ << " = " << iso / 1e3
+ << ", var cone = " << isoV / 1e3);
+ (handles.isoDeco[i])(*part) = iso;
+ (handles.isoDecoV[i])(*part) = isoV;
+ }
+
+ // corrections
+ (handles.corrBitsetDeco)(*part) = keys.CorrList.trackbitset.to_ulong();
+ // let's do the core corrections
+ // iterate over the values we want to store
+ for (auto& coreCorDecoPr : handles.coreCorDeco) {
+ // find the matching result
+ auto corIter =
+ TrackIsoResult.coreCorrections.find(coreCorDecoPr.first);
+ if (corIter == TrackIsoResult.coreCorrections.end()) {
+ ATH_MSG_FATAL("Could not find core correction of required type: "
+ << xAOD::Iso::toCString(coreCorDecoPr.first));
+ ATH_MSG_FATAL("Check configuration");
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_DEBUG("About to write tracking core correction: "
+ << xAOD::Iso::toCString(coreCorDecoPr.first));
+ (coreCorDecoPr.second)(*part) = corIter->second;
+ }
} else {
- ATH_MSG_FATAL("Call to TrackIsolationTool failed for flavor " << xAOD::Iso::toCString(flav));
- return StatusCode::FAILURE;
+ ATH_MSG_FATAL("Call to TrackIsolationTool failed for flavor "
+ << xAOD::Iso::toCString(flav));
+ return StatusCode::FAILURE;
}
}
}
return StatusCode::SUCCESS;
}
-void IsolationBuilder::declareIso(std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> >& caloIso)
+void
+IsolationBuilder::declareIso(
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>& caloIso)
{
- for (auto &iso : caloIso) {
+ for (auto& iso : caloIso) {
iso.second.declare(this);
}
}
-void IsolationBuilder::declareIso(std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> >& trackIso)
+void
+IsolationBuilder::declareIso(
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>&
+ trackIso)
{
- for (auto &iso : trackIso) {
+ for (auto& iso : trackIso) {
iso.second.declare(this);
}
}
diff --git a/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.h b/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.h
index a9cfafa0df2157707a2030a250f07d7c026f3108..fe82e54b96b0f8a8d7e12309077e2dd27656266e 100644
--- a/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.h
+++ b/Reconstruction/RecoAlgs/IsolationAlgs/src/IsolationBuilder.h
@@ -1,12 +1,12 @@
///////////////////////// -*- C++ -*- /////////////////////////////
/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
-// IsolationBuilder.h
+// IsolationBuilder.h
// Header file for class IsolationBuilder
-///////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////
#ifndef ISOLATIONALGS_ISOLATIONBUILDER_H
#define ISOLATIONALGS_ISOLATIONBUILDER_H 1
@@ -14,204 +14,287 @@
#include "VectorVectorIntParser.h"
// STL includes
-#include <string>
#include <set>
-#include <vector>
+#include <string>
#include <utility>
+#include <vector>
// FrameWork includes
-#include "AthenaBaseComps/AthAlgorithm.h"
-#include "GaudiKernel/ToolHandle.h"
#include "AthContainers/AuxElement.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
#include "StoreGate/ReadHandleKey.h"
-#include "StoreGate/WriteDecorHandleKeyArray.h"
-#include "StoreGate/WriteDecorHandleKey.h"
#include "StoreGate/WriteDecorHandle.h"
+#include "StoreGate/WriteDecorHandleKey.h"
+#include "StoreGate/WriteDecorHandleKeyArray.h"
-#include "xAODPrimitives/IsolationType.h"
-#include "xAODPrimitives/IsolationFlavour.h"
#include "RecoToolInterfaces/IsolationCommon.h"
+#include "xAODPrimitives/IsolationFlavour.h"
+#include "xAODPrimitives/IsolationType.h"
#include "IsolationCorrections/IIsolationCorrectionTool.h"
+#include "xAODBase/IParticleContainer.h"
#include "xAODPrimitives/IsolationConeSize.h"
#include "xAODPrimitives/IsolationHelpers.h"
-#include "xAODBase/IParticleContainer.h"
#include "RecoToolInterfaces/ICaloCellIsolationTool.h"
#include "RecoToolInterfaces/ICaloTopoClusterIsolationTool.h"
-#include "RecoToolInterfaces/ITrackIsolationTool.h"
#include "RecoToolInterfaces/INeutralEFlowIsolationTool.h"
+#include "RecoToolInterfaces/ITrackIsolationTool.h"
#include "CaloEvent/CaloCellContainer.h"
+class IsolationBuilder : public AthReentrantAlgorithm
+{
-class IsolationBuilder
- : public ::AthAlgorithm
-{
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Copy constructor:
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+ // Copy constructor:
- /// Constructor with parameters:
- IsolationBuilder( const std::string& name, ISvcLocator* pSvcLocator );
+ /// Constructor with parameters:
+ IsolationBuilder(const std::string& name, ISvcLocator* pSvcLocator);
- /// Destructor:
- virtual ~IsolationBuilder();
+ /// Destructor:
+ virtual ~IsolationBuilder();
// Athena algorithm's Hooks
- virtual StatusCode initialize();
- virtual StatusCode execute();
- virtual StatusCode finalize();
+ virtual StatusCode initialize() override final;
+ virtual StatusCode execute(const EventContext& ctx) const override final;
+ virtual StatusCode finalize() override final;
- ///////////////////////////////////////////////////////////////////
- // Const methods:
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
///////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- private:
+ ///////////////////////////////////////////////////////////////////
+ // Non-const methods:
+ ///////////////////////////////////////////////////////////////////
- /// Default constructor:
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+ /// Default constructor:
IsolationBuilder();
/// Containers (Is it best to make them as strings? Used by multiple handles)
- Gaudi::Property <std::string> m_ElectronContainerName {this,
- "ElectronCollectionContainerName", "Electrons"};
+ Gaudi::Property<std::string> m_ElectronContainerName{
+ this,
+ "ElectronCollectionContainerName",
+ "Electrons"
+ };
- Gaudi::Property <std::string> m_FwdElectronContainerName {this,
- "FwdElectronCollectionContainerName", "ForwardElectrons"};
+ Gaudi::Property<std::string> m_FwdElectronContainerName{
+ this,
+ "FwdElectronCollectionContainerName",
+ "ForwardElectrons"
+ };
- Gaudi::Property <std::string> m_PhotonContainerName {this,
- "PhotonCollectionContainerName", "Photons"};
+ Gaudi::Property<std::string> m_PhotonContainerName{
+ this,
+ "PhotonCollectionContainerName",
+ "Photons"
+ };
- Gaudi::Property <std::string> m_MuonContainerName {this,
- "MuonCollectionContainerName", "Muons"};
+ Gaudi::Property<std::string> m_MuonContainerName{
+ this,
+ "MuonCollectionContainerName",
+ "Muons"
+ };
/** @brief Tool for cell isolation calculation */
- ToolHandle<xAOD::ICaloCellIsolationTool> m_cellIsolationTool {this,
- "CaloCellIsolationTool", "", "Handle of the calo cell IsolationTool"};
+ ToolHandle<xAOD::ICaloCellIsolationTool> m_cellIsolationTool{
+ this,
+ "CaloCellIsolationTool",
+ "",
+ "Handle of the calo cell IsolationTool"
+ };
/** @brief Cell container*/
- SG::ReadHandleKey<CaloCellContainer> m_cellsKey {this,
- "CellCollectionName", "AllCalo", "Name of container which contain calo cells"};
- const CaloCellContainer* m_cellColl = nullptr;
-
+ SG::ReadHandleKey<CaloCellContainer> m_cellsKey{
+ this,
+ "CellCollectionName",
+ "AllCalo",
+ "Name of container which contain calo cells"
+ };
/** @brief Tool for topo isolation calculation */
- ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_topoIsolationTool {this,
- "CaloTopoIsolationTool", "", "Handle of the calo topo IsolationTool"};
+ ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_topoIsolationTool{
+ this,
+ "CaloTopoIsolationTool",
+ "",
+ "Handle of the calo topo IsolationTool"
+ };
/** @brief Tool for neutral pflow isolation calculation */
- ToolHandle<xAOD::INeutralEFlowIsolationTool> m_pflowIsolationTool {this,
- "PFlowIsolationTool", "", "Handle of the pflow IsolationTool"};
+ ToolHandle<xAOD::INeutralEFlowIsolationTool> m_pflowIsolationTool{
+ this,
+ "PFlowIsolationTool",
+ "",
+ "Handle of the pflow IsolationTool"
+ };
/** @brief Tool for neutral pflow isolation calculation */
- ToolHandle<xAOD::ITrackIsolationTool> m_trackIsolationTool {this,
- "TrackIsolationTool", "", "Handle of the track IsolationTool"};
+ ToolHandle<xAOD::ITrackIsolationTool> m_trackIsolationTool{
+ this,
+ "TrackIsolationTool",
+ "",
+ "Handle of the track IsolationTool"
+ };
// FIXME: need to add the electron bremAssoc stuff
- Gaudi::Property<bool> m_useBremAssoc {this,
- "useBremAssoc", true, "use track to track assoc after brem"};
+ Gaudi::Property<bool> m_useBremAssoc{ this,
+ "useBremAssoc",
+ true,
+ "use track to track assoc after brem" };
- Gaudi::Property<bool> m_allTrackRemoval {this,
- "AllTrackRemoval", true};
+ Gaudi::Property<bool> m_allTrackRemoval{ this, "AllTrackRemoval", true };
/** @brief Isolation types */
- Gaudi::Property<std::vector<std::vector<int> > > m_elisoInts {this,
- "ElIsoTypes", {},
- "The isolation types to do for electrons: vector of vector of enum type Iso::IsolationType"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_elisoInts{
+ this,
+ "ElIsoTypes",
+ {},
+ "The isolation types to do for electrons: vector of vector of enum type "
+ "Iso::IsolationType"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_elcorInts {this,
- "ElCorTypes", {},
- "The correction types to do for electron iso: vector of vector of enum type Iso::IsolationCalo/TrackCorrection"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_elcorInts{
+ this,
+ "ElCorTypes",
+ {},
+ "The correction types to do for electron iso: vector of vector of enum "
+ "type Iso::IsolationCalo/TrackCorrection"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_elcorIntsExtra {this,
- "ElCorTypesExtra", {},
- "The extra correction types to store but not apply for electrons"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_elcorIntsExtra{
+ this,
+ "ElCorTypesExtra",
+ {},
+ "The extra correction types to store but not apply for electrons"
+ };
- /** @brief Isolation types (for the alg. properties, only vector<vector<double>> available */
- Gaudi::Property<std::vector<std::vector<int> > > m_phisoInts {this,
- "PhIsoTypes", {},
- "The isolation types to do for photons: vector of vector of enum type Iso::IsolationType"};
+ /** @brief Isolation types (for the alg. properties, only
+ * vector<vector<double>> available */
+ Gaudi::Property<std::vector<std::vector<int>>> m_phisoInts{
+ this,
+ "PhIsoTypes",
+ {},
+ "The isolation types to do for photons: vector of vector of enum type "
+ "Iso::IsolationType"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_phcorInts {this,
- "PhCorTypes", {},
- "The correction types to do for photons iso: vector of vector of enum type Iso::IsolationCalo/TrackCorrection"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_phcorInts{
+ this,
+ "PhCorTypes",
+ {},
+ "The correction types to do for photons iso: vector of vector of enum type "
+ "Iso::IsolationCalo/TrackCorrection"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_phcorIntsExtra {this,
- "PhCorTypesExtra", {},
- "The extra correction types to store but not apply for photons"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_phcorIntsExtra{
+ this,
+ "PhCorTypesExtra",
+ {},
+ "The extra correction types to store but not apply for photons"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_muisoInts {this,
- "MuIsoTypes", {},
- "The isolation types to do for Muons : vector of vector of enum type Iso::IsolationType"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_muisoInts{
+ this,
+ "MuIsoTypes",
+ {},
+ "The isolation types to do for Muons : vector of vector of enum type "
+ "Iso::IsolationType"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_mucorInts {this,
- "MuCorTypes", {},
- "The correction types to do for Muon iso: vector of vector of enum type Iso::IsolationCalo/TrackCorrection"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_mucorInts{
+ this,
+ "MuCorTypes",
+ {},
+ "The correction types to do for Muon iso: vector of vector of enum type "
+ "Iso::IsolationCalo/TrackCorrection"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_mucorIntsExtra {this,
- "MuCorTypesExtra", {},
- "The extra correction types to store but not apply for muons"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_mucorIntsExtra{
+ this,
+ "MuCorTypesExtra",
+ {},
+ "The extra correction types to store but not apply for muons"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_feisoInts {this,
- "FeIsoTypes", {},
- "The isolation types to do for forward electron: vector of vector of enum type Iso::IsolationType"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_feisoInts{
+ this,
+ "FeIsoTypes",
+ {},
+ "The isolation types to do for forward electron: vector of vector of enum "
+ "type Iso::IsolationType"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_fecorInts {this,
- "FeCorTypes", {},
- "The correction types to do for forward electron iso: vector of vector of enum type Iso::IsolationCalo/TrackCorrection"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_fecorInts{
+ this,
+ "FeCorTypes",
+ {},
+ "The correction types to do for forward electron iso: vector of vector of "
+ "enum type Iso::IsolationCalo/TrackCorrection"
+ };
- Gaudi::Property<std::vector<std::vector<int> > > m_fecorIntsExtra {this,
- "FeCorTypesExtra", {},
- "The extra correction types to store but not apply for forward electrons"};
+ Gaudi::Property<std::vector<std::vector<int>>> m_fecorIntsExtra{
+ this,
+ "FeCorTypesExtra",
+ {},
+ "The extra correction types to store but not apply for forward electrons"
+ };
- struct CaloIsoHelpKey {
+ struct CaloIsoHelpKey
+ {
/// constructor
CaloIsoHelpKey(IDataHandleHolder* owningAlg);
- /// only to be called after placed in the final location, to propagate dependencies
+ /// only to be called after placed in the final location, to propagate
+ /// dependencies
void declare(IDataHandleHolder* owningAlg);
/// The actual isolations
SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer> isoDeco;
/// The corrections (one per flavor)
- std::map<xAOD::Iso::IsolationCaloCorrection,
- SG::WriteDecorHandleKey<xAOD::IParticleContainer> > coreCorDeco;
+ std::map<xAOD::Iso::IsolationCaloCorrection,
+ SG::WriteDecorHandleKey<xAOD::IParticleContainer>>
+ coreCorDeco;
/// The corrections (one per flavor/type combination)
- std::map<xAOD::Iso::IsolationCaloCorrection,
- SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer> > noncoreCorDeco;
+ std::map<xAOD::Iso::IsolationCaloCorrection,
+ SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer>>
+ noncoreCorDeco;
/// the types of isolations to calculate
std::vector<xAOD::Iso::IsolationType> isoTypes;
/// to keep track of the corrections
- xAOD::CaloCorrection CorrList;
- // xAOD::CaloCorrection CorrListExtra; // should ideally pass this, but not possible yet
+ xAOD::CaloCorrection CorrList;
+ // xAOD::CaloCorrection CorrListExtra; // should ideally pass this, but not
+ // possible yet
SG::WriteDecorHandleKey<xAOD::IParticleContainer> corrBitsetDeco;
};
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> > m_elCaloIso;
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> > m_phCaloIso;
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> > m_feCaloIso;
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> > m_muCaloIso;
-
- struct TrackIsoHelpKey {
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>
+ m_elCaloIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>
+ m_phCaloIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>
+ m_feCaloIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>
+ m_muCaloIso;
+
+ struct TrackIsoHelpKey
+ {
/// constructor
TrackIsoHelpKey(IDataHandleHolder* owningAlg);
- /// only to be called after placed in the final location, to propagate dependencies
+ /// only to be called after placed in the final location, to propagate
+ /// dependencies
void declare(IDataHandleHolder* owningAlg);
/// The actual isolations
@@ -219,103 +302,134 @@ class IsolationBuilder
SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer> isoDecoV;
/// The corrections
- std::map<xAOD::Iso::IsolationTrackCorrection,
- SG::WriteDecorHandleKey<xAOD::IParticleContainer> > coreCorDeco;
+ std::map<xAOD::Iso::IsolationTrackCorrection,
+ SG::WriteDecorHandleKey<xAOD::IParticleContainer>>
+ coreCorDeco;
/// the types of isolations to calculate
std::vector<xAOD::Iso::IsolationType> isoTypes;
/// to keep track of the corrections
xAOD::TrackCorrection CorrList;
- // xAOD::TrackCorrection CorrListExtra; // should ideally pass this, but not possible yet
+ // xAOD::TrackCorrection CorrListExtra; // should ideally pass this, but not
+ // possible yet
SG::WriteDecorHandleKey<xAOD::IParticleContainer> corrBitsetDeco;
};
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> > m_elTrackIso;
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> > m_phTrackIso;
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> > m_muTrackIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>
+ m_elTrackIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>
+ m_phTrackIso;
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>
+ m_muTrackIso;
- struct CaloIsoHelpHandles {
+ struct CaloIsoHelpHandles
+ {
CaloIsoHelpHandles(const CaloIsoHelpKey& keys);
- std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float> > isoDeco;
- std::map<xAOD::Iso::IsolationCaloCorrection,
- SG::WriteDecorHandle<xAOD::IParticleContainer, float> > coreCorDeco;
- std::map<xAOD::Iso::IsolationCaloCorrection,
- std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float> > > noncoreCorDeco;
+ std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float>> isoDeco;
+ std::map<xAOD::Iso::IsolationCaloCorrection,
+ SG::WriteDecorHandle<xAOD::IParticleContainer, float>>
+ coreCorDeco;
+ std::map<xAOD::Iso::IsolationCaloCorrection,
+ std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float>>>
+ noncoreCorDeco;
SG::WriteDecorHandle<xAOD::IParticleContainer, uint32_t> corrBitsetDeco;
};
-
- struct TrackIsoHelpHandles {
+ struct TrackIsoHelpHandles
+ {
TrackIsoHelpHandles(const TrackIsoHelpKey& keys);
- std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float> > isoDeco;
- std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float> > isoDecoV;
- std::map<xAOD::Iso::IsolationTrackCorrection,
- SG::WriteDecorHandle<xAOD::IParticleContainer, float> > coreCorDeco;
+ std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float>> isoDeco;
+ std::vector<SG::WriteDecorHandle<xAOD::IParticleContainer, float>> isoDecoV;
+ std::map<xAOD::Iso::IsolationTrackCorrection,
+ SG::WriteDecorHandle<xAOD::IParticleContainer, float>>
+ coreCorDeco;
SG::WriteDecorHandle<xAOD::IParticleContainer, uint32_t> corrBitsetDeco;
};
-
// for the time being, only mu vs eg, no separation in eg
- Gaudi::Property<std::string> m_customConfigEl {this,
- "CustomConfigurationNameEl", "",
- "use a custom configuration for electron"};
-
- Gaudi::Property<std::string> m_customConfigPh {this,
- "CustomConfigurationNamePh", "",
- "use a custom configuration for photon"};
+ Gaudi::Property<std::string> m_customConfigEl{
+ this,
+ "CustomConfigurationNameEl",
+ "",
+ "use a custom configuration for electron"
+ };
- Gaudi::Property<std::string> m_customConfigFwd {this,
- "CustomConfigurationNameFwd", "",
- "use a custom configuration for forward electron"};
+ Gaudi::Property<std::string> m_customConfigPh{
+ this,
+ "CustomConfigurationNamePh",
+ "",
+ "use a custom configuration for photon"
+ };
- Gaudi::Property<std::string> m_customConfigMu {this,
- "CustomConfigurationNameMu", "",
- "use a custom configuration for muon"};
+ Gaudi::Property<std::string> m_customConfigFwd{
+ this,
+ "CustomConfigurationNameFwd",
+ "",
+ "use a custom configuration for forward electron"
+ };
+ Gaudi::Property<std::string> m_customConfigMu{
+ this,
+ "CustomConfigurationNameMu",
+ "",
+ "use a custom configuration for muon"
+ };
static bool isCoreCor(xAOD::Iso::IsolationCaloCorrection corr);
- /// called by algorithm initialize per object (electron, photon, forward electron, muon)
- StatusCode initializeIso(std::set<xAOD::Iso::IsolationFlavour>& runIsoType, // out
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey > >* caloIsoMap, // out
- std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey > >* trackIsoMap, // out
- const std::string& containerName,
- const std::vector<std::vector<int> >& isoInts,
- const std::vector<std::vector<int> >& corInts,
- const std::vector<std::vector<int> >& corIntsExtra,
- const std::string& customConfig);
+ /// called by algorithm initialize per object (electron, photon, forward
+ /// electron, muon)
+ StatusCode initializeIso(
+ std::set<xAOD::Iso::IsolationFlavour>& runIsoType, // out
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>*
+ caloIsoMap, // out
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>*
+ trackIsoMap, // out
+ const std::string& containerName,
+ const std::vector<std::vector<int>>& isoInts,
+ const std::vector<std::vector<int>>& corInts,
+ const std::vector<std::vector<int>>& corIntsExtra,
+ const std::string& customConfig);
/// called by initializeIso
- StatusCode addCaloIsoCorrections(size_t flavor,
- xAOD::Iso::IsolationFlavour isoFlav,
- CaloIsoHelpKey& cisoH, // in-out
- const std::vector<std::vector<int> >& corInts,
- bool corrsAreExtra,
- const std::string& prefix,
- const std::string& customConfig);
+ StatusCode addCaloIsoCorrections(size_t flavor,
+ xAOD::Iso::IsolationFlavour isoFlav,
+ CaloIsoHelpKey& cisoH, // in-out
+ const std::vector<std::vector<int>>& corInts,
+ bool corrsAreExtra,
+ const std::string& prefix,
+ const std::string& customConfig);
/// called by initializeIso
- StatusCode addTrackIsoCorrections(size_t flavor,
- xAOD::Iso::IsolationFlavour isoFlav,
- TrackIsoHelpKey& tisoH, // in-out
- const std::vector<std::vector<int> >& corInts,
- bool corrsAreExtra,
- const std::string& prefix,
- const std::string& customConfig);
-
- StatusCode executeCaloIso(const std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> >& caloIsoMap);
-
- StatusCode executeTrackIso(const std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> >& trackIsoMap);
-
- void declareIso(std::vector<std::pair<xAOD::Iso::IsolationFlavour,CaloIsoHelpKey> >& caloIso);
- void declareIso(std::vector<std::pair<xAOD::Iso::IsolationFlavour,TrackIsoHelpKey> >& trackIso);
-
-};
-
+ StatusCode addTrackIsoCorrections(
+ size_t flavor,
+ xAOD::Iso::IsolationFlavour isoFlav,
+ TrackIsoHelpKey& tisoH, // in-out
+ const std::vector<std::vector<int>>& corInts,
+ bool corrsAreExtra,
+ const std::string& prefix,
+ const std::string& customConfig);
+
+ StatusCode executeCaloIso(
+ const std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>&
+ caloIsoMap,
+ const CaloCellContainer* cellColl) const;
+
+ StatusCode executeTrackIso(
+ const std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>&
+ trackIsoMap) const;
+
+ void declareIso(
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey>>&
+ caloIso);
+ void declareIso(
+ std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey>>&
+ trackIso);
+};
#endif //> !ISOLATIONALGS_ISOLATIONBUILDER_H