diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METAssociationTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METAssociationTool.h
index ff0dd3b492a86547ed89488ad5126689b1399e76..6a196aa102ddd07cd09f14a06837676155a6147d 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METAssociationTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METAssociationTool.h
@@ -23,6 +23,8 @@
// FrameWork includes
#include "AsgTools/ToolHandle.h"
#include "AsgTools/AsgTool.h"
+#include "StoreGate/DataHandle.h"
+
// METRecoInterface includes
#include "METRecoInterface/IMETRecoTool.h"
@@ -99,6 +101,9 @@ namespace met{
std::string m_metsuffix;
std::string m_mapname;
std::string m_corename;
+ SG::WriteHandleKey<xAOD::MissingETContainer> m_corenameKey;
+ SG::WriteHandleKey<xAOD::MissingETAssociationMap> m_mapnameKey;
+
int m_signalstate;
bool m_overwrite;
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METAssociator.h
index 3614bd766b03457fa56e465000dd5eaa2bdc6ef6..b2cb63946697b822d394b779153dc6028247250b 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METAssociator.h
@@ -27,6 +27,12 @@
// METRecoInterface includes
#include "METRecoInterface/IMETAssocToolBase.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODTau/TauJetContainer.h"
+
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/Vertex.h"
//#include "xAODCaloEvent/CaloClusterContainer.h"
@@ -76,12 +82,23 @@ namespace met {
///////////////////////////////////////////////////////////////////
protected:
+ ToolHandle<InDet::IInDetTrackSelectionTool> m_trkseltool;
+ ToolHandle<xAOD::ITrackIsolationTool> m_trkIsolationTool;
+ ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_caloIsolationTool;
+
std::string m_input_data_key;
std::string m_pvcoll;
std::string m_trkcoll;
std::string m_clcoll;
std::string m_pfcoll;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_pvcollKey;
+ SG::ReadHandleKey<xAOD::IParticleContainer> m_clcollKey;
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trkcollKey;
+ SG::ReadHandleKey<xAOD::PFOContainer> m_pfcollKey;
+ SG::ReadHandleKey<xAOD::IParticleContainer> m_forcollKey;
+ SG::ReadHandleKey<xAOD::IParticleContainer> m_hybridContKey;
+
bool m_pflow;
bool m_useTracks;
bool m_useRapidity;
@@ -90,9 +107,6 @@ namespace met {
bool m_weight_charged_pfo;
bool m_cleanChargedPFO;
- ToolHandle<InDet::IInDetTrackSelectionTool> m_trkseltool;
- ToolHandle<xAOD::ITrackIsolationTool> m_trkIsolationTool;
- ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_caloIsolationTool;
bool m_skipconst;
std::string m_forcoll;
double m_foreta;
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METCaloRegionsTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METCaloRegionsTool.h
index f765e0d0d59ef10488dd41849a8f403d2611a9c1..6a56f3a14f2ffc7739147aa4e884863405a318e8 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METCaloRegionsTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METCaloRegionsTool.h
@@ -23,6 +23,8 @@
// FrameWork includes
#include "AsgTools/ToolHandle.h"
#include "AsgTools/AsgTool.h"
+#include "StoreGate/DataHandle.h"
+
// MET EDM
#include "xAODMissingET/MissingETContainer.h"
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METEgammaTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METEgammaTool.h
deleted file mode 100644
index 0f9a13cc4f1c6c32077812cc3f83182423100939..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METEgammaTool.h
+++ /dev/null
@@ -1,118 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METEgammaTool.h
-// Header file for class METEgammaTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METEGAMMATOOL_H
-#define METRECONSTRUCTION_METEGAMMATOOL_H 1
-
-// STL includes
-#include <string>
-
-// METReconstruction includes
-#include "METReconstruction/METBuilderTool.h"
-
-// Egamma EDM
-#include "xAODEgamma/EgammaFwd.h"
-
-// Calo EDM
-#include "xAODCaloEvent/CaloClusterContainer.h"
-
-namespace met{
-
- class METEgammaTool
- : virtual public METBuilderTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METEgammaTool, IMETToolBase)
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METEgammaTool(const std::string& name);
- virtual ~METEgammaTool();
-
- // AsgTool Hooks
- virtual StatusCode initialize();
- virtual StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- virtual StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const = 0;
- virtual bool accept(const xAOD::IParticle* object) const;
- virtual bool resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const = 0;
-
- // Identify topoclusters that share energy with the egamma SW cluster
- //
- virtual void matchTopoClusters(const xAOD::Egamma* eg, std::vector<const xAOD::IParticle*>& tclist,
- const xAOD::CaloClusterContainer* tccont) const;
- virtual void matchExtraTracks(const xAOD::Egamma* eg, std::vector<const xAOD::IParticle*>& tclist) const;
-
- // PID quality criteria and cuts
- std::string m_eg_pid;
- uint16_t m_eg_author;
- double m_eg_minPt;
- double m_eg_maxEta;
- //
- bool m_eg_rejectCrack;
- double m_eg_crkEtaLo;
- double m_eg_crkEtaHi;
- // don't currently have the interface for isEM (or equivalent)
- // allow for the possibility to select on the cluster quality
- bool m_eg_testClusOQ;
- unsigned int m_eg_clusOQ;
-
- // SW-topocluster overlap removal
- std::string m_tcCont_key;
- const xAOD::CaloClusterContainer* m_tcCont;
- double m_tcMatch_dR;
- double m_tcMatch_maxRat;
- double m_tcMatch_tolerance;
- unsigned short m_tcMatch_method;
-
- // track overlap removal
- bool m_eg_doTracks;
-
- private:
- /// Default constructor:
- METEgammaTool();
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-#endif //> !METRECONSTRUCTION_METEGAMMATOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METElectronAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METElectronAssociator.h
index 6606cca3373568a9083fb45c5c043a7b33c25e14..5cc9a3c4ccfddeac5b3384c16a25e8105592351c 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METElectronAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METElectronAssociator.h
@@ -18,6 +18,9 @@
#include "METReconstruction/METEgammaAssociator.h"
#include "xAODEgamma/ElectronFwd.h"
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
namespace met{
class METElectronAssociator final
: public METEgammaAssociator
@@ -58,6 +61,8 @@ namespace met{
/// Default constructor:
METElectronAssociator();
+ SG::ReadHandleKey<xAOD::ElectronContainer> m_elContKey;
+
};
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METElectronTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METElectronTool.h
deleted file mode 100644
index 0c7e0a5de2ce268ed5ba0f131c5a75f6c7f35b28..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METElectronTool.h
+++ /dev/null
@@ -1,88 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METElectronTool.h
-// Header file for class METElectronTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METELECTRONTOOL_H
-#define METRECONSTRUCTION_METELECTRONTOOL_H 1
-
-// METReconstruction includes
-#include "METReconstruction/METEgammaTool.h"
-
-// Egamma EDM
-#include "xAODEgamma/ElectronFwd.h"
-
-namespace met{
-
- class METElectronTool
- : public METEgammaTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METElectronTool, IMETToolBase)
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METElectronTool(const std::string& name);
- ~METElectronTool();
-
- // AsgTool Hooks
- StatusCode initialize();
- StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const;
- bool resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const;
-
-
- private:
-
- /// Default constructor:
- METElectronTool();
-
- // Identify tracks that may contribute to the electron SW cluster
- // or are associated to the electron for some other reason
- // and hence should not enter later sums
- void matchTracks(const xAOD::Electron* el, std::vector<const xAOD::IParticle*>& trklist) const;
-
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-#endif //> !METRECONSTRUCTION_METELECTRONTOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METJetAssocTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METJetAssocTool.h
index ee842d582bfff9cd3d592e4322969b02f23c9bfa..fe8d1c71b2800d4f1ab976f3a51a956728e7285f 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METJetAssocTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METJetAssocTool.h
@@ -17,6 +17,9 @@
// METReconstruction includes
#include "METReconstruction/METAssociator.h"
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
namespace met{
class METJetAssocTool final
: public METAssociator
@@ -71,7 +74,7 @@ namespace met{
/// Default constructor:
METJetAssocTool();
-
+ SG::ReadHandleKey<xAOD::JetContainer> m_jetContKey;
void getPFOs(const xAOD::Jet *jet,
std::vector<const xAOD::IParticle*> &consts,
const met::METAssociator::ConstitHolder& constits,
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METMuonAssociator.h
index 675bd6856ba2791754a6b57a785f27265e7fe357..109aa015e7bb29186785e8f456d00ddd9c78b74f 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METMuonAssociator.h
@@ -18,6 +18,9 @@
#include "METReconstruction/METAssociator.h"
#include "AsgTools/ToolHandle.h"
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
class ICaloClusterMatchingTool;
@@ -72,7 +75,9 @@ namespace met{
bool m_doMuonClusterMatch;
/// Default constructor:
- METMuonAssociator();
+ METMuonAssociator();
+ SG::ReadHandleKey<xAOD::MuonContainer> m_muContKey;
+
};
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonElossTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METMuonElossTool.h
deleted file mode 100644
index 7e952dc68a6a8f0ac886fed52c45ecc6ddc71e40..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonElossTool.h
+++ /dev/null
@@ -1,81 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METMuonElossTool.h
-// Header file for class METMuonElossTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METMUONELOSSTOOL_H
-#define METRECONSTRUCTION_METMUONELOSSTOOL_H 1
-
-// STL includes
-#include <string>
-
-// METReconstruction includes
-#include "METReconstruction/METRefinerTool.h"
-
-// Forward declaration
-#include "xAODJet/Jet.h"
-
-namespace met{
-
- class METMuonElossTool
- : public METRefinerTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METMuonElossTool, IMETToolBase)
-
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METMuonElossTool(const std::string& name);
- ~METMuonElossTool();
-
- // AsgTool Hooks
- StatusCode initialize();
- StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const;
-
- private:
- // Default constructor:
- METMuonElossTool();
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-
-#endif //> !METRECONSTRUCTION_METMUONELOSSTOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METMuonTool.h
deleted file mode 100644
index 5079641da17d7533aa6c3cb6e8cade9b3ad64a8a..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METMuonTool.h
+++ /dev/null
@@ -1,100 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METMuonTool.h
-// Header file for class METMuonTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METMUONTOOL_H
-#define METRECONSTRUCTION_METMUONTOOL_H 1
-
-// STL includes
-#include <string>
-
-// METReconstruction includes
-#include "METReconstruction/METBuilderTool.h"
-
-// Forward declaration
-
-namespace met{
-
- class METMuonTool
- : public METBuilderTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METMuonTool, IMETToolBase)
-
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METMuonTool(const std::string& name);
- ~METMuonTool();
-
- // AsgTool Hooks
- StatusCode initialize();
- StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const;
- bool accept(const xAOD::IParticle* object) const;
- bool resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const;
-
- private:
- double m_mu_minP;
- double m_mu_minPt;
- double m_mu_maxEta;
- unsigned short m_mu_qualcut; // loose, medium, tight
- int m_mu_nPixHits;
- int m_mu_nSiHits;
-
- bool m_mu_doStandAlone;
- double m_mu_minEtaSA;
- int m_mu_nPrecisionHits;
- int m_mu_nSegments;
-
- bool m_mu_doTracks;
-
- /// Default constructor:
- METMuonTool();
-
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-
-#endif //> !METRECONSTRUCTION_METMUONTOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonAssociator.h
index 91b320760538caa6c05885ef9ddad2ec33458d86..790baaa4d1b62937b385d1a5abb6c9076fecae40 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonAssociator.h
@@ -18,6 +18,10 @@
#include "METReconstruction/METEgammaAssociator.h"
#include "xAODEgamma/PhotonFwd.h"
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
+
namespace met{
class METPhotonAssociator final
: public METEgammaAssociator
@@ -58,6 +62,7 @@ namespace met{
/// Default constructor:
METPhotonAssociator();
+ SG::ReadHandleKey<xAOD::PhotonContainer> m_phContKey;
};
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonTool.h
deleted file mode 100644
index 2d67a201296ecccb4ccbbeb6dd38759a3655ef50..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METPhotonTool.h
+++ /dev/null
@@ -1,88 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METPhotonTool.h
-// Header file for class METPhotonTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METPHOTONTOOL_H
-#define METRECONSTRUCTION_METPHOTONTOOL_H 1
-
-// METReconstruction includes
-#include "METReconstruction/METEgammaTool.h"
-
-// Forward declaration
-#include "xAODEgamma/PhotonFwd.h"
-
-namespace met{
-
- class METPhotonTool
- : public METEgammaTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METPhotonTool, IMETToolBase)
-
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METPhotonTool(const std::string& name);
- ~METPhotonTool();
-
- // AsgTool Hooks
- StatusCode initialize();
- StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const;
- bool resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const;
-
- private:
- /// Default constructor:
- METPhotonTool();
-
- // Identify tracks that may contribute to the photon SW cluster
- // or are associated to the photon for some other reason
- // and hence should not enter later sums
- void matchTracks(const xAOD::Photon* ph, std::vector<const xAOD::IParticle*>& trklist) const;
-
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-
-#endif //> !METRECONSTRUCTION_METPHOTONTOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METRecoTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METRecoTool.h
index b9eeaf76677b81bb1a86cb3679b84416f630b554..5cd62fbf003a99decc84704980279c2a376aeefa 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METRecoTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METRecoTool.h
@@ -23,6 +23,8 @@
// FrameWork includes
#include "AsgTools/ToolHandle.h"
#include "AsgTools/AsgTool.h"
+#include "StoreGate/DataHandle.h"
+
// METRecoInterface includes
#include "METRecoInterface/IMETRecoTool.h"
@@ -96,8 +98,8 @@ namespace met{
// Data members
bool m_doMetSum;
bool m_warnOfDupes;
- std::string m_contname;
- std::string m_mapname;
+ SG::WriteHandleKey<xAOD::MissingETContainer> m_contname;
+ SG::WriteHandleKey<xAOD::MissingETComponentMap> m_mapname;
std::string m_metfinalname;
ToolHandleArray<IMETToolBase> m_metbuilders;
ToolHandleArray<IMETToolBase> m_metrefiners;
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METSoftAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METSoftAssociator.h
index ffdcfc94c6ff7cd28538efdf03b61864465caddd..ca5503f37ea3ca5c80dae9ab42f92e012c6fc425 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METSoftAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METSoftAssociator.h
@@ -73,10 +73,13 @@ namespace met{
METSoftAssociator();
bool m_decorateSoftTermConst;
- std::string m_lcmodclus_key;
- std::string m_emmodclus_key;
+ std::string m_lcmodclus;
+ std::string m_emmodclus;
bool m_weight_soft_pfo;
+ SG::ReadHandleKey<xAOD::CaloClusterContainer> m_lcmodclus_key;
+ SG::ReadHandleKey<xAOD::CaloClusterContainer> m_emmodclus_key;
+
};
}
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METSoftTermsTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METSoftTermsTool.h
index 22c8736ee76e3abd2c8472b98aa80d4c8be8f905..f97799da74fd7170e0bdf34a0f29db0f38815887 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METSoftTermsTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METSoftTermsTool.h
@@ -23,6 +23,9 @@
// METReconstruction includes
#include "METReconstruction/METBuilderTool.h"
+//Framework includes
+#include "StoreGate/DataHandle.h"
+
// Forward declaration
#include "xAODCaloEvent/CaloClusterFwd.h"
#include "xAODTracking/TrackParticleFwd.h"
@@ -93,7 +96,10 @@ namespace met{
bool m_cl_vetoNegE;
bool m_cl_onlyNegE;
// temporary, until a track-vertex association tool is available
- std::string m_pv_inputkey;
+ //std::string m_pv_inputkey;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_pv_inputkey;
+ SG::ReadHandleKey<xAOD::CaloClusterContainer> m_caloClusterKey;
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleKey;
ToolHandle<CP::IRetrievePFOTool> m_pfotool;
};
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METTauAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METTauAssociator.h
index df3e456db5e3f71994b2571585e9e16529f904d7..ade7512f6307086d897659b39e1d7c0d4ca6bc77 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METTauAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METTauAssociator.h
@@ -16,6 +16,9 @@
// METReconstruction includes
#include "METReconstruction/METAssociator.h"
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
namespace met{
class METTauAssociator final
@@ -69,6 +72,7 @@ namespace met{
/// Default constructor:
METTauAssociator();
+ SG::ReadHandleKey<xAOD::TauJetContainer> m_tauContKey;
};
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METTauTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METTauTool.h
deleted file mode 100644
index 0888dc34af289a75ea0c749945b45924ccfaa3ce..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METTauTool.h
+++ /dev/null
@@ -1,100 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METTauTool.h
-// Header file for class METTauTool
-//
-// This is a scheduler for the MET Reconstruction, and sets up
-// the sequence in which the individual terms are constructed.
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-#ifndef METRECONSTRUCTION_METTAUTOOL_H
-#define METRECONSTRUCTION_METTAUTOOL_H 1
-
-// STL includes
-#include <string>
-
-// METReconstruction includes
-#include "METReconstruction/METBuilderTool.h"
-
-// Forward declaration
-
-namespace met {
-
- class METTauTool
- : public METBuilderTool
- {
- // This macro defines the constructor with the interface declaration
- ASG_TOOL_CLASS(METTauTool, IMETToolBase)
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- // Constructor with name (does this have to be a non-const
- // std::string and not a const reference?)
- METTauTool(const std::string& name);
- ~METTauTool();
-
- // AsgTool Hooks
- StatusCode initialize();
- StatusCode finalize();
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Private data:
- ///////////////////////////////////////////////////////////////////
- protected:
- StatusCode executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const;
- bool accept(const xAOD::IParticle* object) const;
- bool resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const;
-
- private:
- double m_tau_minPt;
- double m_tau_maxEta;
- // configurable parameters for PID
- unsigned int m_tau_isTauFlag;
- bool m_tau_doElVeto;
- unsigned int m_tau_elVeto;
- bool m_tau_doMuVeto;
- unsigned int m_tau_muVeto;
- // minimum non-overlapping E fraction to retain jet calibration
- // could become a property of METBuilderTool if necessary
- // or we could apply a min pt cut instead
- double m_tau_minWet;
- bool m_tau_doMinWetPtCut;
- // do track OR
- bool m_tau_doTracks;
-
- /// Default constructor:
- METTauTool();
- };
-
-}
-
-// I/O operators
-//////////////////////
-
-///////////////////////////////////////////////////////////////////
-// Inline methods:
-///////////////////////////////////////////////////////////////////
-
-
-#endif //> !METRECONSTRUCTION_METTAUTOOL_H
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METTrackFilterTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METTrackFilterTool.h
index ad2940b7d67cfe67f1d146a1b2b67fc189986d5e..1b7b8c4ec02b5911b95a46e93f9d0336cf9b2b50 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METTrackFilterTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METTrackFilterTool.h
@@ -34,6 +34,7 @@
#include "xAODMuon/Muon.h"
#include "xAODMuon/MuonContainer.h"
+
namespace InDet {
class IInDetTrackSelectionTool;
}
@@ -114,16 +115,21 @@ namespace met{
bool m_trk_doPVsel;
// double m_trk_d0Max;
// double m_trk_z0Max;
- std::string m_pv_inputkey;
- std::string m_el_inputkey;
- std::string m_mu_inputkey;
+ std::string m_pv_input;
+ std::string m_el_input;
+ std::string m_mu_input;
+
+ SG::ReadHandleKey<xAOD::ElectronContainer> m_el_inputkey;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_mu_inputkey;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_pv_inputkey;
+ SG::ReadHandleKey<xAOD::CaloClusterContainer> m_cl_inputkey;
bool m_doVxSep;
bool m_doLepRecovery;
bool m_useIsolationTools;
bool m_trk_doEoverPsel;
- std::string m_cl_inputkey;
+ std::string m_cl_input;
double m_cenTrackPtThr;
double m_forTrackPtThr;
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METTruthAssociator.h b/Reconstruction/MET/METReconstruction/METReconstruction/METTruthAssociator.h
index a6d1019fd8f560ba6f64c5e16472c24702be227b..7e355eeaaaf1706f87bd4e757c76f5ebc0dab08d 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METTruthAssociator.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METTruthAssociator.h
@@ -17,6 +17,11 @@
// METReconstruction includes
#include "METReconstruction/METAssociator.h"
+#include "xAODTruth/TruthEventContainer.h"
+
+//Includes for DataHandles
+#include "StoreGate/DataHandle.h"
+
namespace met{
class METTruthAssociator final
: public METAssociator
@@ -86,13 +91,21 @@ namespace met{
private:
- std::string m_recoJetKey;
- std::string m_recoElKey;
- std::string m_recoMuKey;
- std::string m_recoGamKey;
- std::string m_recoTauKey;
- std::string m_truthEventKey;
-
+ std::string m_recoJet;
+ std::string m_recoEl;
+ std::string m_recoMu;
+ std::string m_recoGam;
+ std::string m_recoTau;
+
+ SG::ReadHandleKey<xAOD::ElectronContainer> m_recoElKey;
+ SG::ReadHandleKey<xAOD::PhotonContainer> m_recoGamKey;
+ SG::ReadHandleKey<xAOD::TauJetContainer> m_recoTauKey;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_recoMuKey;
+ SG::ReadHandleKey<xAOD::JetContainer> m_recoJetKey;
+
+ std::string m_truthEvent;
+ SG::ReadHandleKey<xAOD::TruthEventContainer> m_truthEventKey;
+
/// Default constructor:
METTruthAssociator();
diff --git a/Reconstruction/MET/METReconstruction/METReconstruction/METTruthTool.h b/Reconstruction/MET/METReconstruction/METReconstruction/METTruthTool.h
index 70bfffbe6b2c2c3b111d547b1cf6429aa6a93d54..cdf3055fc33b46e9257038450a51c27efb3072a3 100644
--- a/Reconstruction/MET/METReconstruction/METReconstruction/METTruthTool.h
+++ b/Reconstruction/MET/METReconstruction/METReconstruction/METTruthTool.h
@@ -23,6 +23,8 @@
// METReconstruction includes
#include "METReconstruction/METBuilderTool.h"
+#include "xAODTruth/TruthEventContainer.h"
+
// Truth EDM
#include "xAODTruth/TruthParticleFwd.h"
@@ -83,6 +85,7 @@ namespace met{
double m_det_maxEta;
double m_truthmu_minPt;
double m_truthmu_maxEta;
+ SG::ReadHandleKey<xAOD::TruthEventContainer> m_truthEventKey;
// TEMPORARILY recopy some helper from TruthHelper and GeneratorUtils packages
// *** via JetSimTools ***
diff --git a/Reconstruction/MET/METReconstruction/Root/METAssociationTool.cxx b/Reconstruction/MET/METReconstruction/Root/METAssociationTool.cxx
index b97055ad6684d4370859d9a544ba6cd687bd621f..04700fb551884ef160386ffedc84438586383ff7 100644
--- a/Reconstruction/MET/METReconstruction/Root/METAssociationTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METAssociationTool.cxx
@@ -67,6 +67,12 @@ namespace met {
ATH_MSG_INFO("Tool configured to build MET with names:");
ATH_MSG_INFO(" Core container ==> " << m_corename);
ATH_MSG_INFO(" Association map ==> " << m_mapname);
+ ATH_CHECK( m_corenameKey.assign(m_corename) );
+ ATH_CHECK( m_corenameKey.initialize() );
+ ATH_CHECK( m_mapnameKey.assign(m_mapname) );
+ ATH_CHECK( m_mapnameKey.initialize() );
+
+
}
// retrieve associators and generate clocks
@@ -86,70 +92,26 @@ namespace met {
}
m_clock.Reset();
+
return StatusCode::SUCCESS;
}
StatusCode METAssociationTool::execute() const
{
+
+ //this section has had a very big re-write, after discussions with TJK...
ATH_MSG_DEBUG ("In execute: " << name() << "...");
- bool mapExists = evtStore()->contains<xAOD::MissingETAssociationMap>(m_mapname);
- bool coreExists = evtStore()->contains<xAOD::MissingETContainer>(m_corename);
- if(!m_overwrite && mapExists) {
- ATH_MSG_WARNING("Association map \"" << m_mapname << "\" is already present and AllowOverwrite=False, exiting.");
- return StatusCode::SUCCESS;
- }
- if(!m_overwrite && coreExists) {
- ATH_MSG_WARNING("MET_Core container \"" << m_corename << "\" is already present and AllowOverwrite=False, exiting.");
- return StatusCode::SUCCESS;
- }
- if(mapExists!=coreExists) {
- ATH_MSG_WARNING("Overwriting only " << (mapExists?"map":"core container") << " may result in meaningless results.");
- return StatusCode::SUCCESS;
- }
//Create map and core containers
- xAOD::MissingETAuxAssociationMap* metAuxMap = new xAOD::MissingETAuxAssociationMap();
- xAOD::MissingETAssociationMap* metMap = new xAOD::MissingETAssociationMap();
- metMap->setStore(metAuxMap);
- MissingETAuxContainer* metAuxCont = new MissingETAuxContainer();
- MissingETContainer* metCont = new MissingETContainer();
- metCont->setStore(metAuxCont);
-
- //Record or overwrite association map
- if(!mapExists && evtStore()->record(metAuxMap, m_mapname+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxAssociationMap: " << m_mapname+"Aux.");
- return StatusCode::SUCCESS;
- }
- if(mapExists && evtStore()->overwrite(metAuxMap, m_mapname+"Aux.",true,false).isFailure() ) {
- ATH_MSG_WARNING("Unable to overwrite MissingETAuxAssociationMap: " << m_mapname+"Aux.");
- return StatusCode::SUCCESS;
- }
- if(!mapExists && evtStore()->record(metMap, m_mapname).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAssociationMap: " << m_mapname);
- return StatusCode::SUCCESS;
- }
- if(mapExists && evtStore()->overwrite(metMap, m_mapname,true,false).isFailure() ) {
- ATH_MSG_WARNING("Unable to overwrite MissingETAssociationMap: " << m_mapname);
- return StatusCode::SUCCESS;
- }
- //Record or overwrite core container
- if(!coreExists && evtStore()->record(metCont, m_corename).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETContainer: " << m_corename);
- return StatusCode::SUCCESS;
- }
- if(coreExists && evtStore()->overwrite(metCont, m_corename,true,false).isFailure() ) {
- ATH_MSG_WARNING("Unable to overwrite MissingETContainer: " << m_corename);
- return StatusCode::SUCCESS;
- }
- if(!coreExists && evtStore()->record(metAuxCont, m_corename+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxContainer: " << m_corename+"Aux.");
- return StatusCode::SUCCESS;
- }
- if(coreExists && evtStore()->overwrite(metAuxCont, m_corename+"Aux.",true,false).isFailure() ) {
- ATH_MSG_WARNING("Unable to overwrite MissingETAuxContainer: " << m_corename+"Aux.");
- return StatusCode::SUCCESS;
- }
+ auto metHandle= SG::makeHandle (m_corenameKey);
+ ATH_CHECK( metHandle.record (std::make_unique<xAOD::MissingETContainer>(), std::make_unique<xAOD::MissingETAuxContainer>()) );
+ xAOD::MissingETContainer* metCont=metHandle.ptr();
+
+ auto metMapHandle= SG::makeHandle (m_mapnameKey);
+ ATH_CHECK( metMapHandle.record (std::make_unique<xAOD::MissingETAssociationMap>(), std::make_unique<xAOD::MissingETAuxAssociationMap>()) );
+ xAOD::MissingETAssociationMap* metMap=metMapHandle.ptr();
+
if( buildMET(metCont, metMap).isFailure() ) {
ATH_MSG_DEBUG("Failed in MissingET reconstruction");
@@ -157,8 +119,8 @@ namespace met {
}
// Lock the containers in SG
- ATH_CHECK( evtStore()->setConst(metMap) );
- ATH_CHECK( evtStore()->setConst(metCont) );
+ //ATH_CHECK( evtStore()->setConst(metMap) );
+ //ATH_CHECK( evtStore()->setConst(metCont) );
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METAssociator.cxx
index 9564f03fd149bdfbaae0097453032cc7f011236e..dec4f790b715a159861a60bebbe5fd03fd7aacec 100644
--- a/Reconstruction/MET/METReconstruction/Root/METAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METAssociator.cxx
@@ -51,7 +51,11 @@ namespace met {
AsgTool(name),
m_trkseltool(""),
m_trkIsolationTool(""),
- m_caloIsolationTool("")
+ m_caloIsolationTool(""),
+ m_pvcollKey(""),
+ m_clcollKey(""),
+ m_trkcollKey(""),
+ m_pfcollKey("")
{
ATH_MSG_INFO("METAssoc constructor");
declareProperty( "InputCollection", m_input_data_key );
@@ -112,7 +116,29 @@ namespace met {
} else {
ATH_MSG_INFO("Configured to use PFlow collection \"" << m_pfcoll << "\".");
}
-
+ //initialise read handle keys
+ if(m_useTracks){
+ ATH_CHECK( m_pvcollKey.assign(m_pvcoll));
+ ATH_CHECK( m_pvcollKey.initialize());
+ ATH_CHECK( m_trkcollKey.assign(m_trkcoll));
+ ATH_CHECK( m_trkcollKey.initialize());
+ }
+ if(m_pflow){
+ ATH_CHECK( m_pfcollKey.assign(m_pfcoll));
+ ATH_CHECK( m_pfcollKey.initialize());
+ }
+ if(!m_skipconst || m_forcoll.empty()){
+ ATH_CHECK( m_clcollKey.assign(m_clcoll));
+ ATH_CHECK( m_clcollKey.initialize());
+ }
+ else{
+ std::string hybridname = "Etmiss";
+ hybridname += m_clcoll;
+ hybridname += m_foreta;
+ hybridname += m_forcoll;
+ ATH_CHECK( m_hybridContKey.assign(hybridname));
+ ATH_CHECK( m_hybridContKey.initialize());
+ }
return StatusCode::SUCCESS;
}
@@ -140,31 +166,61 @@ namespace met {
{
ATH_MSG_DEBUG ("In execute: " << name() << "...");
if (!m_skipconst || m_forcoll.empty()) {
- if( evtStore()->retrieve(constits.tcCont, m_clcoll).isFailure() ) {
+
+ SG::ReadHandle<IParticleContainer> topoclusterCont(m_clcollKey);
+ if (!topoclusterCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve topocluster container " << m_clcoll << " for overlap removal");
return StatusCode::FAILURE;
}
+ constits.tcCont=topoclusterCont.cptr();
ATH_MSG_DEBUG("Successfully retrieved topocluster collection");
} else {
std::string hybridname = "Etmiss";
hybridname += m_clcoll;
hybridname += m_foreta;
hybridname += m_forcoll;
- if( evtStore()->contains<IParticleContainer>(hybridname) ) {
- ATH_CHECK(evtStore()->retrieve(constits.tcCont,hybridname));
+
+ SG::ReadHandle<IParticleContainer> hybridCont(m_hybridContKey);
+ if( hybridCont.isValid()) {
+ constits.tcCont=hybridCont.cptr();
} else {
+ // Trying to do this using write handles (need to get some input here)
+ /*std::unique_ptr<ConstDataVector<IParticleContainer>> hybridCont = std::make_unique<ConstDataVector<IParticleContainer>>();
+ SG::WriteHandle<ConstDataVector<IParticleContainer>> hybridContHandle(hybridname);
+
+ StatusCode sc = hybridContHandle.record(std::make_unique<ConstDataVector<IParticleContainer>>(*hybridCont));
+
+ if (sc.isFailure()) {
+ ATH_MSG_WARNING("Unable to record container");
+ return StatusCode::SUCCESS;
+
+ }*/
+
+ /*SG::ReadHandle<IParticleContainer> centCont(m_clcoll);
+ if (!centCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve central container " << m_clcoll << " for overlap removal");
+ return StatusCode::FAILURE;
+ }
+
+ SG::ReadHandle<IParticleContainer> forCont(m_forcoll);
+ if (!forCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve forward container " << m_forcoll << " for overlap removal");
+ return StatusCode::FAILURE;
+ }*/
ConstDataVector<IParticleContainer> *hybridCont = new ConstDataVector<IParticleContainer>(SG::VIEW_ELEMENTS);
- const IParticleContainer *centCont = 0;
- const IParticleContainer *forCont = 0;
+ const IParticleContainer* centCont=0;
if( evtStore()->retrieve(centCont, m_clcoll).isFailure() ) {
ATH_MSG_WARNING("Unable to retrieve central container " << m_clcoll << " for overlap removal");
return StatusCode::FAILURE;
}
+
+ const IParticleContainer* forCont=0;
if( evtStore()->retrieve(forCont, m_forcoll).isFailure() ) {
ATH_MSG_WARNING("Unable to retrieve forward container " << m_forcoll << " for overlap removal");
return StatusCode::FAILURE;
}
+
for(const auto& clus : *centCont) if (fabs(clus->eta())<m_foreta) hybridCont->push_back(clus);
for(const auto& clus : *forCont) if (fabs(clus->eta())>=m_foreta) hybridCont->push_back(clus);
ATH_CHECK( evtStore()->record(hybridCont,hybridname));
@@ -176,12 +232,13 @@ namespace met {
//if you want to skip tracks, set the track collection empty manually
ATH_MSG_DEBUG("Skipping tracks");
}else{
- const VertexContainer *vxCont = 0;
- if( evtStore()->retrieve(vxCont, m_pvcoll).isFailure() ) {
+ SG::ReadHandle<VertexContainer> vxCont(m_pvcollKey);
+ if (!vxCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve primary vertex container " << m_pvcoll);
//this is actually really bad. If it's empty that's okay
- return StatusCode::FAILURE;
+ return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
ATH_MSG_DEBUG("Container holds " << vxCont->size() << " vertices");
@@ -198,12 +255,22 @@ namespace met {
constits.trkCont=0;
ATH_MSG_DEBUG("Retrieving Track collection " << m_trkcoll);
- ATH_CHECK( evtStore()->retrieve(constits.trkCont, m_trkcoll) );
+ SG::ReadHandle<TrackParticleContainer> trCont(m_trkcollKey);
+ if (!trCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve track particle container");
+ return StatusCode::FAILURE;
+ }
+ constits.trkCont=trCont.cptr();
if(m_pflow) {
ATH_MSG_DEBUG("Retrieving PFlow collection " << m_pfcoll);
constits.pfoCont = 0;
- ATH_CHECK( evtStore()->retrieve(constits.pfoCont, m_pfcoll ) );
+ SG::ReadHandle<PFOContainer> pfCont(m_pfcollKey);
+ if (!pfCont.isValid()) {
+ ATH_MSG_WARNING("Unable to PFlow object container");
+ return StatusCode::FAILURE;
+ }
+ constits.pfoCont=pfCont.cptr();
}//pflow
}//retrieve track/pfo containers
diff --git a/Reconstruction/MET/METReconstruction/Root/METCaloRegionsTool.cxx b/Reconstruction/MET/METReconstruction/Root/METCaloRegionsTool.cxx
index 1e53d33fdcfeb3b36f74cf4b0648713c843c0fb3..c9428cb7af766ebf9daa29c34e4e589b41d366d9 100644
--- a/Reconstruction/MET/METReconstruction/Root/METCaloRegionsTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METCaloRegionsTool.cxx
@@ -152,27 +152,28 @@ namespace met {
// Either Cells or Clusters
if(m_calo_useCells) {
// Retrieve the cell container
- const CaloCellContainer* caloCellCont = 0;
+ SG::ReadHandle<CaloCellContainer> caloCellCont(m_input_data_key);
+
#if defined(XAOD_STANDALONE) || defined(XAOD_ANALYSIS)
#else
- sc = evtStore()->retrieve(caloCellCont, m_input_data_key);
- if( sc.isFailure() ) {
+ if (!caloCellCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input cell cluster container");
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
+
}
#endif
// Fill MET
- sc = fillCellMet(metCont,caloCellCont);
+ sc = fillCellMet(metCont,caloCellCont.cptr());
} else {
// Retrieve the calo container
- const CaloClusterContainer* caloClusCont = 0;
- sc = evtStore()->retrieve(caloClusCont, m_input_data_key);
- if( sc.isFailure() ) {
+ SG::ReadHandle<CaloClusterContainer> caloClusCont(m_input_data_key);
+ if (!caloClusCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input calo cluster container");
- return StatusCode::SUCCESS;
+ return StatusCode::SUCCESS;
+
}
// Fill MET
- sc=fillClusterMet(metCont,caloClusCont);
+ sc=fillClusterMet(metCont,caloClusCont.cptr());
} // end if use clusters if/else
// Debug information
diff --git a/Reconstruction/MET/METReconstruction/Root/METEgammaTool.cxx b/Reconstruction/MET/METReconstruction/Root/METEgammaTool.cxx
deleted file mode 100644
index d9734dae6783723485f164fef4d716f9ed8539d9..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METEgammaTool.cxx
+++ /dev/null
@@ -1,245 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METEgammaTool.cxx
-// Implementation file for class METEgammaTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// STL includes
-#include <algorithm>
-
-// METReconstruction includes
-#include "METReconstruction/METEgammaTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Egamma EDM
-#include "xAODEgamma/EgammaContainer.h"
-
-// Tracking EDM
-#include "xAODTracking/TrackParticle.h"
-
-// DeltaR calculation
-#include "FourMomUtils/xAODP4Helpers.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Egamma;
- using xAOD::EgammaContainer;
- //
- using xAOD::CaloCluster;
- using xAOD::CaloClusterContainer;
- //
- using xAOD::TrackParticle;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- static bool greaterPt(const xAOD::IParticle* part1, const xAOD::IParticle* part2) {
- return part1->pt()>part2->pt();
- }
-
- // Constructors
- ////////////////
- METEgammaTool::METEgammaTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name)
- {
-
- declareProperty( "PIDSel", m_eg_pid = "" ); // Selection string to be determined
- declareProperty( "AuthorSel", m_eg_author = xAOD::EgammaParameters::AuthorALL ); // default to accept Electron, Photon or Ambiguous
- declareProperty( "MinPt", m_eg_minPt = 10e3 ); // use GeV const?
- declareProperty( "MaxEta", m_eg_maxEta = 2.47 );
- declareProperty( "RejectCrack", m_eg_rejectCrack = false );
- declareProperty( "CrackEtaLow", m_eg_crkEtaLo = 1.37 ); // range covered by the Tile Gap scintillator
- declareProperty( "CrackEtaHigh", m_eg_crkEtaHi = 1.56 );
- declareProperty( "ClusOQ", m_eg_clusOQ = 0x0 );
- declareProperty( "TestClusOQ", m_eg_testClusOQ = false ); // could e.g. veto BADCLUSELECTRON
-
- declareProperty( "TopoClusKey", m_tcCont_key = "CaloCalTopoClusters" );
- declareProperty( "TCMatchDeltaR", m_tcMatch_dR = 0.1 );
- declareProperty( "TCMatchMaxRat", m_tcMatch_maxRat = 1.5 );
- declareProperty( "TCMatchTolerance", m_tcMatch_tolerance = 0.2 );
- declareProperty( "TCMatchMethod", m_tcMatch_method = 0 );
-
- declareProperty( "DoTracks", m_eg_doTracks = true );
- }
-
- // Destructor
- ///////////////
- METEgammaTool::~METEgammaTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METEgammaTool::initialize()
- {
- ATH_CHECK( METBuilderTool::initialize() );
- ATH_MSG_INFO ("Initializing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
-
- StatusCode METEgammaTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METEgammaTool::accept(const xAOD::IParticle* object) const
- {
-
- if(object->type() != xAOD::Type::Electron && object->type() != xAOD::Type::Photon) {
- ATH_MSG_WARNING("METEgammaTool::accept given an object of type " << object->type());
- return false;
- }
- const Egamma* eg = static_cast<const Egamma*>(object);
-
- ATH_MSG_VERBOSE("Test egamma quality."
- << " pT = " << eg->pt()
- << " eta = " << eg->eta()
- << " phi = " << eg->phi());
-
- bool testPID = 0;
- eg->passSelection(testPID,m_eg_pid);
- ATH_MSG_VERBOSE("Egamma PID " << m_eg_pid << " tests " << (testPID ? " GOOD" : "BAD") );
- if( !testPID ) return false;
-
- /////////////////////////////////////////////////////////////////
- // FIXME
- // Test that egamma author satisfies one of the permitted algorithms
- // Maybe doesn't need to be configurable
- // For now default to author 1, i.e. standard egamma alg
- ATH_MSG_VERBOSE("Egamma author = " << eg->author() << " test " << (eg->author()&m_eg_author));
- if( !(eg->author()&m_eg_author) ) return false;
- /////////////////////////////////////////////////////////////////
-
- if( eg->pt()<m_eg_minPt ) return false;
- if( fabs(eg->eta())>m_eg_maxEta ) return false;
-
- /////////////////////////////////////////////////////////////////
- // FIXME
- // We could potentially avoid calibrating crack egammas
- if( m_eg_rejectCrack ) {
- if( fabs(eg->eta())>m_eg_crkEtaLo &&
- fabs(eg->eta())<m_eg_crkEtaHi ) return false;
- }
- /////////////////////////////////////////////////////////////////
-
- /////////////////////////////////////////////////////////////////
- // FIXME
- // We could veto egammas with poor cluster quality
- if( m_eg_testClusOQ ) {
- if( !eg->isGoodOQ(m_eg_clusOQ) ) return false;
- }
- /////////////////////////////////////////////////////////////////
-
- ATH_MSG_VERBOSE("Accepted this egamma");
-
- return true;
- }
-
- void METEgammaTool::matchTopoClusters(const xAOD::Egamma* eg, std::vector<const xAOD::IParticle*>& tclist,
- const xAOD::CaloClusterContainer* tcCont) const
- {
- // safe to assume a single SW cluster?
- // will do so for now...
- const CaloCluster* swclus = eg->caloCluster();
- double eg_cl_e = swclus->e();
-
- // the matching strategy depends on how the cluster container is sorted
- // easier if it's sorted in descending pt order
- // we'll worry about optimisation later
- vector<const xAOD::CaloCluster*> nearbyTC;
- nearbyTC.reserve(10);
- for(CaloClusterContainer::const_iterator iClus=tcCont->begin();
- iClus!=tcCont->end(); ++iClus) {
- // this can probably be done more elegantly
- if(xAOD::P4Helpers::isInDeltaR(*swclus,**iClus,0.1,m_useRapidity) && (*iClus)->e()>0) {
- // could consider also requirements on the EM fraction or depth
- nearbyTC.push_back(*iClus);
- } // match TC in a cone around SW cluster
- }
- ATH_MSG_VERBOSE("Found " << nearbyTC.size() << " nearby topoclusters");
-
- bool goodmatch = false;
- bool doSum = true;
- double sumE_tc = 0.;
- const CaloCluster* bestbadmatch = 0;
- std::sort(nearbyTC.begin(),nearbyTC.end(),greaterPt);
- for(vector<const xAOD::CaloCluster*>::const_iterator iClus=nearbyTC.begin();
- iClus!=nearbyTC.end(); ++iClus) {
- double tcl_e = (*iClus)->e();
- // skip cluster if it's above our bad match threshold
- if(tcl_e>m_tcMatch_maxRat*eg_cl_e) {
- ATH_MSG_VERBOSE("Reject topocluster in sum. Ratio vs eg cluster: " << (tcl_e/eg_cl_e));
- if( !bestbadmatch || (fabs(tcl_e/eg_cl_e-1.) < fabs(bestbadmatch->e()/eg_cl_e-1.)) ) bestbadmatch = *iClus;
- continue;
- }
-
- switch(m_tcMatch_method) {
- case 0:
- // sum clusters until the next cluster to be added will make the energy match worse
- doSum = ( fabs(sumE_tc+tcl_e - eg_cl_e) < fabs(sumE_tc - eg_cl_e) );
- ATH_MSG_VERBOSE("E match with new cluster: " << fabs(sumE_tc+tcl_e - eg_cl_e) / eg_cl_e);
- break;
- case 1:
- // sum clusters until we either find one very good cluster match
- // or reach a specified cutoff
- doSum = (!goodmatch && (sumE_tc+tcl_e) < m_tcMatch_maxRat*eg_cl_e );
- break;
- }
-
- if(doSum) {
- tclist.push_back(*iClus);
- sumE_tc += tcl_e;
- if(tclist.size()==1) goodmatch = fabs(tcl_e/eg_cl_e-1)<m_tcMatch_tolerance;
- ATH_MSG_VERBOSE("Accept topocluster with pt " << (*iClus)->pt() << ", e " << (*iClus)->e() << " in sum.");
- ATH_MSG_VERBOSE("Energy ratio of TC to eg: " << tcl_e / eg_cl_e);
- ATH_MSG_VERBOSE("Do we have a good match? " << (goodmatch ? "YES" : "NO"));
- } // if we will retain the topocluster
- } // loop over nearby clusters
- if(sumE_tc<1e-9 && bestbadmatch) {
- tclist.push_back(bestbadmatch);
- sumE_tc += bestbadmatch->e();
- }
- ATH_MSG_VERBOSE("Egamma links " << eg->nCaloClusters() << " clusters");
- ATH_MSG_VERBOSE("Identified " << tclist.size() << " matched topoclusters");
- ATH_MSG_VERBOSE("Egamma energy: " << eg->e());
- ATH_MSG_VERBOSE("Egamma cluster energy: " << swclus->e());
- ATH_MSG_VERBOSE("Sum of nearby topocluster energies: " << sumE_tc);
- ATH_MSG_VERBOSE("Energy ratio of TC sum to eg: " << sumE_tc / swclus->e());
- }
-
- // In case any common treatment is needed for egammas in addition to the electron/photon specialised versions
- void METEgammaTool::matchExtraTracks(const xAOD::Egamma* /*eg*/, std::vector<const xAOD::IParticle*>& trklist) const
- {
- ATH_MSG_VERBOSE("Egamma has " << trklist.size() << " linked tracks");
- }
-
-}
diff --git a/Reconstruction/MET/METReconstruction/Root/METElectronAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METElectronAssociator.cxx
index ab2fc1f4658fa38442247231607ee19bd2f0b406..5c035bb93bfa6872e53b216748696b67542d91a9 100644
--- a/Reconstruction/MET/METReconstruction/Root/METElectronAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METElectronAssociator.cxx
@@ -28,7 +28,8 @@ namespace met {
METElectronAssociator::METElectronAssociator(const std::string& name) :
AsgTool(name),
METAssociator(name),
- METEgammaAssociator(name)
+ METEgammaAssociator(name),
+ m_elContKey("")
{}
// Destructor
@@ -42,6 +43,9 @@ namespace met {
{
ATH_CHECK( METEgammaAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ ATH_CHECK( m_elContKey.assign(m_input_data_key));
+ ATH_CHECK( m_elContKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -69,14 +73,14 @@ namespace met {
{
ATH_MSG_VERBOSE ("In execute: " << name() << "...");
- const ElectronContainer* elCont(0);
- if( evtStore()->retrieve(elCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::ElectronContainer> elCont(m_elContKey);
+ if (!elCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input electron container " << m_input_data_key);
return StatusCode::FAILURE;
}
ATH_MSG_DEBUG("Successfully retrieved electron collection");
- if (fillAssocMap(metMap,elCont).isFailure()) {
+ if (fillAssocMap(metMap,elCont.cptr()).isFailure()) {
ATH_MSG_WARNING("Unable to fill map with electron container " << m_input_data_key);
return StatusCode::FAILURE;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METElectronTool.cxx b/Reconstruction/MET/METReconstruction/Root/METElectronTool.cxx
deleted file mode 100644
index b8ee5b3ecaaa49c48d43141583316521134b4964..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METElectronTool.cxx
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-
-///////////////////////// -*- C++ -*- /////////////////////////////
-// METElectronTool.cxx
-// Implementation file for class METElectronTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// STL includes
-#include <algorithm>
-
-// METReconstruction includes
-#include "METReconstruction/METElectronTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Egamma EDM
-#include "xAODEgamma/ElectronContainer.h"
-#include "xAODEgamma/ElectronxAODHelpers.h"
-
-// Tracking EDM
-#include "xAODTracking/TrackParticle.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Electron;
- using xAOD::ElectronContainer;
- //
- using xAOD::CaloCluster;
- using xAOD::CaloClusterContainer;
- //
- using xAOD::TrackParticle;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METElectronTool::METElectronTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name),
- METEgammaTool(name)
- {
- }
-
- // Destructor
- ///////////////
- METElectronTool::~METElectronTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METElectronTool::initialize()
- {
- ATH_CHECK( METEgammaTool::initialize() );
- ATH_MSG_INFO ("Initializing " << name() << "...");
-
- // Should put some info about the configuration here
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METElectronTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METElectronTool::resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const
- {
- if(object->type() != xAOD::Type::Electron) {
- ATH_MSG_WARNING("METElectronTool::resolveOverlap given an object of type " << object->type());
- return false;
- }
- const Electron* el = dynamic_cast<const Electron*>(object);
-
- ATH_MSG_DEBUG("Identifying signals overlapping this electron");
-
- const CaloClusterContainer* tcCont(0);
- if( evtStore()->retrieve(tcCont, m_tcCont_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve topocluster container for overlap removal");
- return true;
- }
- ATH_MSG_DEBUG("Successfully retrieved topocluster collection");
-
- // retrieve topoclusters associated to the electron
- vector<const IParticle*> tcList;
- tcList.reserve(el->nCaloClusters());
- matchTopoClusters(el, tcList, tcCont);
- // test the clusters for matches to other objects
- bool clustersUsed = metMap->checkUsage(tcList,MissingETBase::UsageHandler::OnlyCluster);
- if(clustersUsed) { // true implies some cluster has been used
- for(vector<const IParticle*>::const_iterator iClus = tcList.begin();
- iClus!=tcList.end(); ++iClus) {
- acceptedSignals.push_back(*iClus);
- } // loop over electron-matched topoclusters
- objWeight = MissingETBase::Types::weight_t(0.,0.,0.);
- } else {
- acceptedSignals = tcList;
- objWeight = MissingETBase::Types::weight_t(1.,1.,1.);
- }
-
- if(m_eg_doTracks) {
- // retrieve tracks associated to the electron
- vector<const xAOD::IParticle*> trkList;
- trkList.reserve(el->nTrackParticles());
- matchTracks(el, trkList);
- // test the tracks for matches to other objects
- ATH_MSG_VERBOSE("Check track usage");
- metMap->checkUsage(trkList,MissingETBase::UsageHandler::OnlyTrack);
- ATH_MSG_VERBOSE("Checked track usage");
- for(vector<const IParticle*>::const_iterator iTrk = trkList.begin();
- iTrk!=trkList.end(); ++iTrk) {
- acceptedSignals.push_back(*iTrk);
- } // loop over electron-matched tracks
- ATH_MSG_VERBOSE("End track loop");
- }
-
- return !clustersUsed; // return true if the electron shares no clusters with another object
- }
-
- void METElectronTool::matchTracks(const xAOD::Electron* el, std::vector<const xAOD::IParticle*>& trklist) const
- {
- for(size_t iTrk=0; iTrk<el->nTrackParticles(); ++iTrk) {
- const TrackParticle* eltrk = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(el->trackParticle(iTrk));
- if(eltrk) {
- trklist.push_back(eltrk);
- } else {
- ATH_MSG_WARNING("Null pointer given for electron ID track!");
- }
- }
- METEgammaTool::matchExtraTracks(el,trklist);
- ATH_MSG_VERBOSE("Electron has " << trklist.size() << " linked tracks");
- }
-
- StatusCode METElectronTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- const ElectronContainer* elCont = 0;
- if( evtStore()->retrieve(elCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input electron container");
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved electron collection");
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::contributedHardTerm());
-
- MissingETBase::Types::bitmask_t source = MissingETBase::Source::electron();
- metTerm->setSource(source);
-
- ///////////////////////////////////////////////////////////////////
- // FIXME
- // may need to ensure that the electron container is properly
- // sorted for the overlap removal procedure.
- // descending pt order should suffice
- vector<const IParticle*> signalList;
- for(ElectronContainer::const_iterator iEl=elCont->begin();
- iEl!=elCont->end(); ++iEl) {
- if ( this->accept(*iEl) ) {
- signalList.clear();
- signalList.reserve((*iEl)->nCaloClusters()+(*iEl)->nTrackParticles());
- MissingETBase::Types::weight_t objWeight;
-
- if ( this->resolveOverlap(*iEl,metMap,signalList,objWeight) ) {
- ATH_MSG_VERBOSE(signalList.size() << " tracks/clusters in signal list");
- ATH_MSG_VERBOSE("Non-overlapped electron, add this to MET");
- this->addToMET(*iEl,signalList,metTerm,metMap,objWeight);
- } // add if not overlapping anything
- } // if passing selection
- } // loop on el container
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-
-}
diff --git a/Reconstruction/MET/METReconstruction/Root/METJetAssocTool.cxx b/Reconstruction/MET/METReconstruction/Root/METJetAssocTool.cxx
index 5bb2c4cdc8a55ac658db6505dbb421b9a5329fd3..57c968da5e00c54990fbdfcaa9204595deabd2db 100644
--- a/Reconstruction/MET/METReconstruction/Root/METJetAssocTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METJetAssocTool.cxx
@@ -40,7 +40,8 @@ namespace met {
////////////////
METJetAssocTool::METJetAssocTool(const std::string& name) :
AsgTool(name),
- METAssociator(name)
+ METAssociator(name),
+ m_jetContKey("")
{
declareProperty( "MatchRadius", m_matchRadius = 0.4 );
}
@@ -56,6 +57,11 @@ namespace met {
{
ATH_CHECK( METAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ //Initialise ReadHandles
+ ATH_CHECK( m_jetContKey.assign(m_input_data_key));
+ ATH_CHECK( m_jetContKey.initialize());
+
+
return StatusCode::SUCCESS;
}
@@ -84,11 +90,12 @@ namespace met {
ATH_MSG_VERBOSE ("In execute: " << name() << "...");
// Retrieve the jet container
- const JetContainer* jetCont = 0;
- if( evtStore()->retrieve(jetCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::JetContainer> jetCont(m_jetContKey);
+ if (!jetCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input jet container " << m_input_data_key);
return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved jet collection");
ConstitHolder constits;
diff --git a/Reconstruction/MET/METReconstruction/Root/METJetFilterTool.cxx b/Reconstruction/MET/METReconstruction/Root/METJetFilterTool.cxx
deleted file mode 100644
index fe5b4be0f0b9b9398eba1385ecdc3110eecbf534..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METJetFilterTool.cxx
+++ /dev/null
@@ -1,172 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METJetFilterTool.cxx
-// Implementation file for class METJetFilterTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METJetFilterTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Jet EDM
-#include "xAODJet/JetTypes.h"
-#include "xAODJet/JetAttributes.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Jet;
- using xAOD::JetAttribute;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METJetFilterTool::METJetFilterTool(const std::string& name) :
- AsgTool(name),
- METRefinerTool(name)
- {
- declareProperty( "DoJVFCut", m_jet_doJVFCut = false );
- declareProperty( "MinAbsJVF", m_jet_minAbsJVF = 0.25 );
- declareProperty( "MaxPtJVF", m_jet_maxPtJVF = 50e3 );
- declareProperty( "MaxEtaJVF", m_jet_maxEtaJVF = 2.4 );
- }
-
- // Destructor
- ///////////////
- METJetFilterTool::~METJetFilterTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METJetFilterTool::initialize()
- {
- ATH_CHECK( METRefinerTool::initialize() );
- ATH_MSG_INFO ("Initializing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METJetFilterTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METJetFilterTool::isHSJet(const xAOD::Jet* jet) const
- {
-
- // switch to more generic HS jet selector when available
- if( m_jet_doJVFCut ) {
- if( jet->pt() < m_jet_maxPtJVF &&
- fabs(jet->eta()) < m_jet_maxEtaJVF ) {
- vector<float> jvf;
- jet->getAttribute<vector<float> >(JetAttribute::JVF,jvf);
- if(!jet->getAttribute<vector<float> >(JetAttribute::JVF,jvf)) {
- ATH_MSG_WARNING("Jet JVF unavailable!");
- return false;
- }
- ATH_MSG_VERBOSE("Jet JVF = " << jvf[0]);
- if( fabs(jvf[0]) < m_jet_minAbsJVF ) return false;
- }
- }
-
- return true;
- }
-
- StatusCode METJetFilterTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
-
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::Tags::correctedTerm(MissingETBase::Status::Nominal,
- MissingETBase::Status::PileupJetVertex));
-
- // Extract the component corresponding to the Jet SoftTerms
- MissingETBase::Types::bitmask_t src_refJet = MissingETBase::Source::jet();
- MissingETComponentMap::const_iterator citer = MissingETComposition::find(metMap,src_refJet);
- if(citer==metMap->end()) {
- ATH_MSG_WARNING("Could not find uncorrected Jet component in MET Map!");
- return StatusCode::SUCCESS;
- }
-
- metTerm->setSource(src_refJet);
-
- vector<const IParticle*> jetList = (*citer)->objects();
- vector<const IParticle*> dummyList; // jet constituents are already in the map
-
- // Loop over the jets and select only good ones
- for( const auto& obj : jetList ) {
- MissingETBase::Types::weight_t jetWeight = (*citer)->weight(obj);
- if(obj->type() != xAOD::Type::Jet) {
- ATH_MSG_WARNING("Retrieved an object of type " << obj->type() << " while expecting xAOD::Jet");
- continue;
- }
- const Jet* jet = static_cast<const Jet*>(obj);
- ATH_MSG_VERBOSE("Filter jet with pt " << jet->pt());
- // Could/should use common implementation of addToMET here -- derive builder and refiner from a common base tool?
- bool passFilters = true;
- if(!isHSJet(jet)) passFilters = false;
- if(passFilters) {
- ATH_MSG_VERBOSE("Add to MET.");
- metTerm->add(jet->px()*jetWeight.wpx(),
- jet->py()*jetWeight.wpy(),
- jet->pt()*jetWeight.wet());
- MissingETComposition::insert(metMap,metTerm,jet,dummyList,jetWeight);
- }
- }
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-}
-
diff --git a/Reconstruction/MET/METReconstruction/Root/METJetTool.cxx b/Reconstruction/MET/METReconstruction/Root/METJetTool.cxx
deleted file mode 100644
index 378e3a656cdcf430fc8098575a93422fc837e4b3..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METJetTool.cxx
+++ /dev/null
@@ -1,285 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METJetTool.cxx
-// Implementation file for class METJetTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo, AS Mete
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METJetTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Jet EDM
-#include "xAODJet/JetTypes.h"
-#include "xAODJet/JetContainer.h"
-#include "xAODJet/JetAttributes.h"
-
-// Calo EDM
-#include "xAODCaloEvent/CaloCluster.h"
-
-// Calo helpers
-#include "xAODCaloEvent/CaloClusterChangeSignalState.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Jet;
- using xAOD::JetContainer;
- using xAOD::JetAttribute;
- using xAOD::JetConstituentVector;
- //
- using xAOD::CaloCluster;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METJetTool::METJetTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name)
- {
- // don't select on pt now, we will calibrate later.
- declareProperty( "MinPt", m_jet_minPt = 0 );
- declareProperty( "MaxEta", m_jet_maxEta = 5 );
- declareProperty( "DoQualCut", m_jet_doQualCut = false );
- declareProperty( "JetBadQual", m_jet_badQual = "isBadLoose" ); // don't like string comparisons, but the jet guys do
- declareProperty( "MinWet", m_jet_minWet = 0.5 );
- declareProperty( "DoMinWetPtCut", m_jet_doMinWetPtCut = false );
- declareProperty( "DoTracks", m_jet_doTracks = true );
- }
-
- // Destructor
- ///////////////
- METJetTool::~METJetTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METJetTool::initialize()
- {
- ATH_CHECK( METBuilderTool::initialize() );
- ATH_MSG_VERBOSE ("Initializing " << name() << "...");
-
- // Provide parser of input data string here?
- // Or take a list of inputs?
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METJetTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
-
- bool METJetTool::accept(const xAOD::IParticle* object) const {
- const Jet* jet = dynamic_cast<const Jet*>(object);
-
- if(!jet) {
- ATH_MSG_WARNING("Jet accept given an object of type " << object->type());
- return false;
- }
-
- if( jet->pt() < m_jet_minPt ) return false;
- if( fabs(jet->eta()) > m_jet_maxEta) return false;
-
- // analyses should probably still veto the event...
- if( m_jet_doQualCut ) {
- bool isBad = false;
- jet->getAttribute<bool>(m_jet_badQual,isBad);
- if( isBad ) return false;
- }
-
- return true;
- }
-
- bool METJetTool::resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const
- {
-
- if(object->type() != xAOD::Type::Jet) {
- ATH_MSG_WARNING("Jet resolveOverlap given an object of type " << object->type());
- return false;
- }
- const Jet* jet = static_cast<const Jet*>(object);
- //m_signalstate = jet->getConstituentsSignalState();
-
- ATH_MSG_VERBOSE("Retrieving jet constituents.");
- // first get the topoclusters
- // is it better to immediately put the constituents into acceptedSignals?
- JetConstituentVector constit = jet->getConstituents();
- ATH_MSG_VERBOSE("Current jet has " << constit.size() << " constituents.");
- // test for used topoclusters, and retrieve unused ones (ok until/unless we use PFlow jets)
- // only use clusters for computing the overlap removal relative to other objects
- double sumE_allclus = 0.;
- vector<const IParticle*> constit_vec;
- constit_vec.reserve(jet->numConstituents());
- CaloClusterChangeSignalStateList stateHelperList;
- for(JetConstituentVector::const_iterator iClus = constit.begin();
- iClus!=constit.end(); ++iClus) {
- sumE_allclus += (*iClus)->e();
- const CaloCluster* pClus = dynamic_cast<const CaloCluster*>( (*iClus)->rawConstituent() );
- if(pClus) {
- stateHelperList.add(pClus, CaloCluster::State(m_signalstate));
- ATH_MSG_VERBOSE("Constit E = " << pClus->e());
- constit_vec.push_back(pClus);
- } else {
- ATH_MSG_WARNING("Cluster resolveOverlap given an object of type " << (*iClus)->type());
- }
- } // loop over jet constituents
- ATH_MSG_VERBOSE( "Jet E = " << jet->e() << ", cluster energy sum = " << sumE_allclus );
- ATH_MSG_VERBOSE( "Check signal states" );
- ATH_MSG_VERBOSE( "Jet pt (default) = " << jet->jetP4(xAOD::JetAssignedScaleMomentum).Pt()
- << " jet pt (uncalconstit_scale) = " << jet->jetP4(xAOD::JetEMScaleMomentum).Pt()
- << " jet pt (jetfinding_scale) = " << jet->jetP4(xAOD::JetConstitScaleMomentum).Pt() );
- bool clustersUsed = metMap->checkUsage(constit_vec,MissingETBase::UsageHandler::OnlyCluster);
- if(clustersUsed) { // true implies some cluster has been used
- double sumE_unique = 0.; // sumE or sumet?
- for(vector<const IParticle*>::const_iterator iClus = constit_vec.begin();
- iClus!=constit_vec.end(); ++iClus) {
- sumE_unique += (*iClus)->e();
- acceptedSignals.push_back(*iClus);
- ATH_MSG_VERBOSE("Unique constit E = " << (*iClus)->e());
- } // loop over jet unique constituents
- double scalef = sumE_unique / sumE_allclus;
- // weight as an entire object with the unused E fraction
- // decision about what to do with the weight later
- if(scalef>1.) ATH_MSG_WARNING( "Computed a scale factor " << scalef << " larger than 1!" );
- ATH_MSG_VERBOSE( "Jet unique cluster energy sum = " << sumE_unique );
- objWeight = MissingETBase::Types::weight_t(scalef,scalef,scalef);
- } else {
-
- ATH_MSG_VERBOSE( "Jet has no overlaps." );
- // weight as an entire object with the unused E fraction
- // decision about what to do with the weight later
- acceptedSignals = constit_vec;
- objWeight = MissingETBase::Types::weight_t(1.,1.,1.);
- }
-
- if(m_jet_doTracks) {
- // now find associated tracks
- vector<const IParticle*> jettracks = jet->getAssociatedObjects<IParticle>(JetAttribute::GhostTrack);
- ATH_MSG_VERBOSE( "Jet contains " << jettracks.size() << " ghost-associated tracks." );
- // test for used tracks, and retrieve unused ones
- metMap->checkUsage(jettracks,MissingETBase::UsageHandler::OnlyTrack);
- ATH_MSG_VERBOSE( "Of these, " << jettracks.size() << " are unique." );
- for(vector<const IParticle*>::const_iterator iTrk = jettracks.begin();
- iTrk!=jettracks.end(); ++iTrk) {
- acceptedSignals.push_back(*iTrk);
- } // loop over jet tracks
- }
-
- return !clustersUsed; // return true if the jet shares no clusters with another object
- }
-
- StatusCode METJetTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- const JetContainer* jetCont = 0;
- if( evtStore()->retrieve(jetCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input jet container");
- return StatusCode::SUCCESS;
- }
-
- MissingETBase::Types::bitmask_t source = MissingETBase::Source::jet();
- metTerm->setSource(source);
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::contributedHardTerm());
-
- ATH_MSG_DEBUG("Retrieved jet collection: " << m_input_data_key);
-
- vector<const IParticle*> signalList;
- for(JetContainer::const_iterator iJet=jetCont->begin();
- iJet!=jetCont->end(); ++iJet) {
- if ( this->accept(*iJet) ) {
- ATH_MSG_VERBOSE("Accepted jet with "
- << "pT = " << (*iJet)->pt()
- << " eta = " << (*iJet)->eta()
- << " phi = " << (*iJet)->phi());
- signalList.clear();
- signalList.reserve(2*(*iJet)->numConstituents());
- MissingETBase::Types::weight_t objWeight;
- if ( this->resolveOverlap(*iJet,metMap,signalList,objWeight) ) {
- // add automatically if not overlapping anything
- this->addToMET(*iJet,signalList,metTerm,metMap,objWeight);
- } else {
- if( m_jet_doMinWetPtCut ) {
- if( (*iJet)->pt()*objWeight.wet() > m_jet_minPt ) {
- ATH_MSG_VERBOSE("Jet unique energy is above threshold -- add to MET.");
- this->addToMET(*iJet,signalList,metTerm,metMap,objWeight);
- ATH_MSG_VERBOSE("Jet px = " << (*iJet)->px()
- << ", weighted px = " << (*iJet)->px()*objWeight.wpx()
- << ", MET px = " << metTerm->mpx() );
- ATH_MSG_VERBOSE("Jet pt = " << (*iJet)->pt()
- << ", weighted pt = " << (*iJet)->pt()*objWeight.wet()
- << ", MET pt = " << metTerm->met() );
- }
- } else {
- if( objWeight.wet() > m_jet_minWet ) {
- ATH_MSG_VERBOSE("Jet weighted energy is above threshold -- add to MET");
- this->addToMET(*iJet,signalList,metTerm,metMap,objWeight);
- ATH_MSG_VERBOSE("Jet px = " << (*iJet)->px()
- << ", weighted px = " << (*iJet)->px()*objWeight.wpx()
- << ", MET px = " << metTerm->mpx() );
- }
- } // end if minWet
- }
- } // if passing selection
- } // loop on jet container
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-}
diff --git a/Reconstruction/MET/METReconstruction/Root/METMuonAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METMuonAssociator.cxx
index c9fef8b5dec7b21ba0cad5609deff71fa68630cf..9bff9302e2a1755e756359dfe4308350dae65890 100644
--- a/Reconstruction/MET/METReconstruction/Root/METMuonAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METMuonAssociator.cxx
@@ -31,7 +31,9 @@ namespace met {
////////////////
METMuonAssociator::METMuonAssociator(const std::string& name) :
AsgTool(name),
- METAssociator(name)
+ METAssociator(name),
+ m_muContKey("")
+
{
declareProperty("DoClusterMatch", m_doMuonClusterMatch=true);
}
@@ -47,6 +49,9 @@ namespace met {
{
ATH_CHECK( METAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ ATH_CHECK( m_muContKey.assign(m_input_data_key));
+ ATH_CHECK( m_muContKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -72,13 +77,14 @@ namespace met {
{
ATH_MSG_VERBOSE ("In execute: " << name() << "...");
- const MuonContainer* muonCont(0);
- if( evtStore()->retrieve(muonCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::MuonContainer> muonCont(m_muContKey);
+ if (!muonCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input muon container " << m_input_data_key);
return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved muon collection");
- if (fillAssocMap(metMap,muonCont).isFailure()) {
+ if (fillAssocMap(metMap,muonCont.cptr()).isFailure()) {
ATH_MSG_WARNING("Unable to fill map with muon container " << m_input_data_key);
return StatusCode::FAILURE;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METMuonElossTool.cxx b/Reconstruction/MET/METReconstruction/Root/METMuonElossTool.cxx
deleted file mode 100644
index 05c73fa57077e9b466f522d2c71e3680e14b1e1e..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METMuonElossTool.cxx
+++ /dev/null
@@ -1,167 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METMuonElossTool.cxx
-// Implementation file for class METMuonElossTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METMuonElossTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Muon EDM
-#include "xAODMuon/Muon.h"
-
-// Calo EDM
-#include "xAODCaloEvent/CaloCluster.h"
-
-// DeltaR calculation
-#include "FourMomUtils/xAODP4Helpers.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Muon;
- //
- using xAOD::CaloCluster;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METMuonElossTool::METMuonElossTool(const std::string& name) :
- AsgTool(name),
- METRefinerTool(name)
- {
- }
-
- // Destructor
- ///////////////
- METMuonElossTool::~METMuonElossTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METMuonElossTool::initialize()
- {
- ATH_CHECK( METRefinerTool::initialize() );
- ATH_MSG_INFO ("Initializing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METMuonElossTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- StatusCode METMuonElossTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
-
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::Tags::correctedTerm(MissingETBase::Status::Nominal,
- MissingETBase::Status::PileupTrack));
-
- // Extract the component corresponding to the Cluster SoftTerms
- MissingETBase::Types::bitmask_t src_ST_clus = MissingETBase::Source::softEvent() | MissingETBase::Source::cluster();
- MissingETComponentMap::const_iterator citer = MissingETComposition::find(metMap,src_ST_clus);
- if(citer==metMap->end()) {
- ATH_MSG_WARNING("Could not find soft cluster component in MET Map!");
- return StatusCode::SUCCESS;
- }
- vector<const IParticle*> clusterList = (*citer)->objects();
-
- // Extract the component corresponding to the Muons term
- citer = MissingETComposition::find(metMap,MissingETBase::Source::muon());
- if(citer==metMap->end()) {
- ATH_MSG_WARNING("Could not find Muons component in MET Map!");
- return StatusCode::SUCCESS;
- }
- vector<const IParticle*> muonList = (*citer)->objects();
-
- metTerm->setSource(MissingETBase::Source::muon());
-
- // Loop over the tracks and select only good ones
- MissingETBase::Types::weight_t unitWeight(1.,1.,1.);
- for( const auto& obj1 : muonList ) {
- if(obj1->type() != xAOD::Type::Muon) {
- ATH_MSG_WARNING("MuonEloss given an object of type " << obj1->type());
- continue;
- }
- const Muon* muon = static_cast<const Muon*>(obj1);
- double clusterSum = 0.;
- for( const auto& obj2 : clusterList ) {
- // search for clusters in the vicinity of the muon
- // (really, we should use the track extrapolation)
- // to place a cap on the correction.
- if(obj2->type()==xAOD::Type::CaloCluster) {
- const CaloCluster* cl = static_cast<const CaloCluster*>(obj2);
- if(xAOD::P4Helpers::isInDeltaR(*cl,*muon,0.1,m_useRapidity)) {
- clusterSum += cl->e();
- }
- }
- else { ATH_MSG_WARNING("MuonEloss given an object of type " << obj2->type()); }
- }
- ATH_MSG_DEBUG("Muon with pt " << muon->pt() << " passes through clusters with total E = " << clusterSum);
- }
-
- // not sure what to add here
- // for( vector<const IParticle*>::const_iterator iPar=filteredTrackList.begin();
- // iPar!=filteredTrackList.end(); ++iPar ) {
- // MissingETComposition::insert(metMap,metTerm,muon,filteredTrackList,unitWeight);
- // }
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-}
-
diff --git a/Reconstruction/MET/METReconstruction/Root/METMuonTool.cxx b/Reconstruction/MET/METReconstruction/Root/METMuonTool.cxx
deleted file mode 100644
index 6cd74bef0911bb2326bff79ffd31644c877744ed..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METMuonTool.cxx
+++ /dev/null
@@ -1,209 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METMuonTool.cxx
-// Implementation file for class METMuonTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METMuonTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Muon EDM
-#include "xAODMuon/MuonContainer.h"
-#include "xAODMuon/MuonSegment.h"
-#include "xAODMuon/MuonSegmentContainer.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Muon;
- using xAOD::MuonContainer;
- using xAOD::MuonSegmentContainer;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METMuonTool::METMuonTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name)
- {
- declareProperty( "MinP", m_mu_minP = 4e3 );
- declareProperty( "MinPt", m_mu_minPt = 2.5e3 );
- declareProperty( "MaxEta", m_mu_maxEta = 2.5 );
- declareProperty( "QualCut", m_mu_qualcut = 2 ); // 0:Tight, 1:Medium, 2:Loose
- declareProperty( "MinNpixel", m_mu_nPixHits = 3 );
- declareProperty( "MinNsilicon", m_mu_nSiHits = 5 );
- declareProperty( "DoStandAlone", m_mu_doStandAlone = true );
- declareProperty( "MinEtaStandAlone", m_mu_minEtaSA = 2.5 );
- declareProperty( "MinNsegments", m_mu_nSegments = 0 );
- declareProperty( "MinNprecision", m_mu_nPrecisionHits = 3 );
- declareProperty( "DoTracks", m_mu_doTracks = true );
- }
-
- // Destructor
- ///////////////
- METMuonTool::~METMuonTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METMuonTool::initialize()
- {
- ATH_CHECK( METBuilderTool::initialize() );
- ATH_MSG_VERBOSE ("Initializing " << name() << "...");
-
- // Provide parser of input data string here?
- // Or take a list of inputs?
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METMuonTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METMuonTool::accept(const xAOD::IParticle* object) const
- {
-
- if(object->type() != xAOD::Type::Muon) {
- ATH_MSG_WARNING("METMuonTool::accept given an object of type " << object->type());
- return false;
- }
- const Muon* mu = static_cast<const Muon*>(object);
-
- ATH_MSG_VERBOSE( "Test muon with pt " << mu->pt() << " eta " << mu->eta() );
-
- // if(mu->quality()>m_mu_qualcut) return false;
- if(mu->pt()<m_mu_minPt || mu->pt()/cosh(mu->eta())<m_mu_minP) return false;
- if(mu->muonType()==Muon::MuonStandAlone) {
- if(!m_mu_doStandAlone) return false;
- else {
- // only take forward SA -- need a max eta cut?
- if(fabs(mu->eta())<m_mu_minEtaSA) return false;
- // cuts on number of muon segments and precision hits
- int nSeg=mu->muonSegmentLinks().size();
- if(nSeg<m_mu_nSegments) return false;
- uint8_t nPrecision=0;
- if(!mu->primaryTrackParticleLink().isValid()) return false;
- mu->primaryTrackParticle()->summaryValue(nPrecision,xAOD::numberOfPrecisionLayers);
- if(nPrecision<m_mu_nPrecisionHits) return false;
- } // only if we use SA muons
- } // selection for StandAlone muons
- else if(mu->muonType()==Muon::Combined || mu->muonType()==Muon::SegmentTagged) {
- if(fabs(mu->eta())>m_mu_maxEta) return false;
-
- // could add some error checking to make sure we successfully read the details
- uint8_t nPixHits(0), nSctHits(0);
- if(!mu->primaryTrackParticleLink().isValid()) return false;
- mu->primaryTrackParticle()->summaryValue(nPixHits,xAOD::numberOfPixelHits);
- mu->primaryTrackParticle()->summaryValue(nSctHits,xAOD::numberOfSCTHits);
-
- if(nPixHits<m_mu_nPixHits) return false;
- if(nPixHits+nSctHits<m_mu_nSiHits) return false;
- } // selection for SegmentTagged and Combined muons
- else {return false;} // don't accept forward muons or calo tagged
-
- return true;
- }
-
- bool METMuonTool::resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& /*objWeight*/) const
- {
-
- if(object->type() != xAOD::Type::Muon) {
- ATH_MSG_WARNING("METMuonTool::resolveOverlap given an object of type " << object->type());
- return false;
- }
- const Muon* mu = static_cast<const Muon*>(object);
-
- if(m_mu_doTracks) {
- // retrieve tracks associated to the electron
- ATH_MSG_VERBOSE("Extract muon track.");
- if(mu->inDetTrackParticleLink().isValid())
- acceptedSignals.push_back(*mu->inDetTrackParticleLink());
- } // loop over muon-matched tracks
- metMap->checkUsage(acceptedSignals,MissingETBase::UsageHandler::OnlyTrack);
-
- return true;
- }
-
- StatusCode METMuonTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- const MuonContainer* muCont = 0;
- if( evtStore()->retrieve(muCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input muon container");
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved muon collection");
-
- MissingETBase::Types::bitmask_t source = MissingETBase::Source::muon();
- metTerm->setSource(source);
-
- vector<const IParticle*> signalList;
- signalList.reserve(muCont->size());
- for(MuonContainer::const_iterator iMu=muCont->begin();
- iMu!=muCont->end(); ++iMu) {
- if ( this->accept(*iMu) ) {
- signalList.clear();
- MissingETBase::Types::weight_t objWeight;
- this->resolveOverlap(*iMu,metMap,signalList,objWeight);
- ATH_MSG_VERBOSE("Add this muon to MET.");
- this->addToMET(*iMu,signalList,metTerm,metMap,objWeight);
- } // if passing selection
- } // loop on mu container
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-
-}
diff --git a/Reconstruction/MET/METReconstruction/Root/METPhotonAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METPhotonAssociator.cxx
index 11a49cfcd42730b7b0643742c5ce9f1e5377f27a..38d80226057ae6e0da80f80039adeb9d8e149bcd 100644
--- a/Reconstruction/MET/METReconstruction/Root/METPhotonAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METPhotonAssociator.cxx
@@ -28,7 +28,8 @@ namespace met {
METPhotonAssociator::METPhotonAssociator(const std::string& name) :
AsgTool(name),
METAssociator(name),
- METEgammaAssociator(name)
+ METEgammaAssociator(name),
+ m_phContKey("")
{}
// Destructor
@@ -42,6 +43,9 @@ namespace met {
{
ATH_CHECK( METEgammaAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ ATH_CHECK( m_phContKey.assign(m_input_data_key));
+ ATH_CHECK( m_phContKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -69,15 +73,15 @@ namespace met {
{
ATH_MSG_VERBOSE ("In execute: " << name() << "...");
- const xAOD::PhotonContainer* phCont(0);
- if( evtStore()->retrieve(phCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::PhotonContainer> phCont(m_phContKey);
+ if (!phCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input photon container " << m_input_data_key);
return StatusCode::FAILURE;
}
ATH_MSG_DEBUG("Successfully retrieved photon collection");
- if (fillAssocMap(metMap,phCont).isFailure()) {
+ if (fillAssocMap(metMap,phCont.cptr()).isFailure()) {
ATH_MSG_WARNING("Unable to fill map with photon container " << m_input_data_key);
return StatusCode::FAILURE;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METPhotonTool.cxx b/Reconstruction/MET/METReconstruction/Root/METPhotonTool.cxx
deleted file mode 100644
index 31b18af5cb819b6a4f0470a2cfc691a9277ad380..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METPhotonTool.cxx
+++ /dev/null
@@ -1,226 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METPhotonTool.cxx
-// Implementation file for class METPhotonTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METPhotonTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Egamma EDM
-#include "xAODEgamma/PhotonContainer.h"
-#include "xAODEgamma/ElectronxAODHelpers.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Photon;
- using xAOD::PhotonContainer;
- //
- using xAOD::CaloCluster;
- using xAOD::CaloClusterContainer;
- //
- using xAOD::Vertex;
- using xAOD::TrackParticle;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METPhotonTool::METPhotonTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name),
- METEgammaTool(name)
- {
- }
-
- // Destructor
- ///////////////
- METPhotonTool::~METPhotonTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METPhotonTool::initialize()
- {
- ATH_CHECK( METEgammaTool::initialize() );
- ATH_MSG_VERBOSE ("Initializing " << name() << "...");
-
- // Provide parser of input data string here?
- // Or take a list of inputs?
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METPhotonTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METPhotonTool::resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const
- {
-
- if(object->type() != xAOD::Type::Photon) {
- ATH_MSG_WARNING("METPhotonTool::resolveOverlap given an object of type " << object->type());
- return false;
- }
- const Photon* ph = static_cast<const Photon*>(object);
-
- ATH_MSG_DEBUG("Identifying signals overlapping this photon");
-
- const CaloClusterContainer* tcCont(0);
- if( evtStore()->retrieve(tcCont, m_tcCont_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve topocluster container for overlap removal");
- return true;
- }
- ATH_MSG_DEBUG("Successfully retrieved topocluster collection");
-
- // retrieve topoclusters associated to the photon
- vector<const IParticle*> tcList;
- tcList.reserve(ph->nCaloClusters());
- matchTopoClusters(ph, tcList, tcCont);
- // test the clusters for matches to other objects
- bool clustersUsed = metMap->checkUsage(tcList,MissingETBase::UsageHandler::OnlyCluster);
- if(clustersUsed) { // true implies some cluster has been used
- for(vector<const IParticle*>::const_iterator iClus = tcList.begin();
- iClus!=tcList.end(); ++iClus) {
- acceptedSignals.push_back(*iClus);
- } // loop over photon-matched topoclusters
- objWeight = MissingETBase::Types::weight_t(0.,0.,0.);
- } else {
- acceptedSignals = tcList;
- objWeight = MissingETBase::Types::weight_t(1.,1.,1.);
- }
-
- if(m_eg_doTracks) {
- // retrieve tracks associated to the photon
- vector<const IParticle*> trkList;
- trkList.reserve(2*ph->nVertices());
- matchTracks(ph, trkList);
- // test the tracks for matches to other objects
- metMap->checkUsage(trkList,MissingETBase::UsageHandler::OnlyTrack);
- for(vector<const IParticle*>::const_iterator iTrk = trkList.begin();
- iTrk!=trkList.end(); ++iTrk) {
- acceptedSignals.push_back(*iTrk);
- } // loop over photon-matched tracks
- }
-
- return !clustersUsed; // return true if the photon shares no clusters with another object
- }
-
- void METPhotonTool::matchTracks(const xAOD::Photon* ph, std::vector<const xAOD::IParticle*>& trklist) const
- {
- for(size_t iVtx=0; iVtx<ph->nVertices(); ++iVtx) {
- const Vertex* phvx = ph->vertex(iVtx);
- if(phvx) {
- for(size_t iTrk=0; iTrk<phvx->nTrackParticles(); ++iTrk) {
- const TrackParticle* phtrk = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(phvx->trackParticle(iTrk));
- if(phtrk) {
- trklist.push_back(phtrk);
- } else {
- ATH_MSG_WARNING("Null pointer given for photon ID track!");
- }
- }
- } else {
- ATH_MSG_WARNING("Null pointer given for photon vertex!");
- }
- }
- METEgammaTool::matchExtraTracks(ph,trklist);
- ATH_MSG_VERBOSE("Photon has " << trklist.size() << " linked tracks");
- }
-
- StatusCode METPhotonTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const {
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- const PhotonContainer* phCont = 0;
- if( evtStore()->retrieve(phCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input photon container");
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved photon collection");
-
- MissingETBase::Types::bitmask_t source = MissingETBase::Source::photon();
- metTerm->setSource(source);
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::contributedHardTerm());
-
- ///////////////////////////////////////////////////////////////////
- // FIXME
- // may need to ensure that the photon container is properly
- // sorted for the overlap removal procedure.
- // descending pt order should suffice
- vector<const IParticle*> signalList;
- for(PhotonContainer::const_iterator iPh=phCont->begin();
- iPh!=phCont->end(); ++iPh) {
- if ( this->accept(*iPh) ) {
- signalList.clear();
- signalList.reserve((*iPh)->nCaloClusters()+2*(*iPh)->nVertices());
- MissingETBase::Types::weight_t objWeight;
-
- if ( this->resolveOverlap(*iPh,metMap,signalList,objWeight) ) {
- ATH_MSG_VERBOSE(signalList.size() << " tracks/clusters in signal list");
- ATH_MSG_VERBOSE("Non-overlapped photon, add this to MET");
- this->addToMET(*iPh,signalList,metTerm,metMap,objWeight);
- } // add if not overlapping anything
- } // if passing selection
- } // loop on ph container
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-}
-
diff --git a/Reconstruction/MET/METReconstruction/Root/METRecoTool.cxx b/Reconstruction/MET/METReconstruction/Root/METRecoTool.cxx
index 5c89104840314160d52dd38956d5661e98eed7f0..cece244e823593f5753ce7912ac8ad1d57e75606 100644
--- a/Reconstruction/MET/METReconstruction/Root/METRecoTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METRecoTool.cxx
@@ -59,22 +59,24 @@ namespace met {
declareProperty( "TimingDetail", m_timedetail = 0 );
}
-
// Athena algtool's Hooks
////////////////////////////
StatusCode METRecoTool::initialize()
{
ATH_MSG_INFO ("Initializing " << name() << "...");
- if( m_contname.size()==0 ) {
+ if( m_contname.key().size()==0 ) {
ATH_MSG_FATAL("Output MissingETContainer name must be provided.");
return StatusCode::FAILURE;
}
- if( m_mapname.size()==0 ) {
+ if( m_mapname.key().size()==0 ) {
ATH_MSG_FATAL("Output MissingETComponentMap name must be provided.");
return StatusCode::FAILURE;
}
+ ATH_CHECK( m_contname.initialize() );
+ ATH_CHECK( m_mapname.initialize() );
+
ATH_MSG_INFO ("Reconstructing MET container: " << m_contname
<< " with composition map: " << m_mapname );
@@ -125,43 +127,20 @@ namespace met {
{
ATH_MSG_DEBUG ("In execute: " << name() << "...");
- if( evtStore()->contains<MissingETContainer>(m_contname) ) {
- if(m_warnOfDupes)
- { ATH_MSG_WARNING("MET container " << m_contname << " already in StoreGate"); }
- return StatusCode::SUCCESS;
- }
-
- if( evtStore()->contains<MissingETComponentMap>(m_mapname) ) {
- if(m_warnOfDupes)
- { ATH_MSG_WARNING("MET map " << m_mapname << " already in StoreGate"); }
- return StatusCode::SUCCESS;
- }
-
// Create a MissingETContainer with its aux store
- MissingETContainer* metCont = new MissingETContainer();
- if( evtStore()->record(metCont, m_contname).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETContainer: " << m_contname);
- return StatusCode::SUCCESS;
- }
- MissingETAuxContainer* metAuxCont = new MissingETAuxContainer();
- if( evtStore()->record(metAuxCont, m_contname+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxContainer: " << m_contname+"Aux.");
- return StatusCode::SUCCESS;
- }
- metCont->setStore(metAuxCont);
+ auto metHandle= SG::makeHandle (m_contname);
+ //note that the method below automatically creates the MET container and its corresponding aux store (which will be named "m_contname+Aux.")
+ ATH_CHECK( metHandle.record (std::make_unique<xAOD::MissingETContainer>(), std::make_unique<xAOD::MissingETAuxContainer>()) );
+ xAOD::MissingETContainer* metCont=metHandle.ptr();
+
// Create a MissingETComponentMap with its aux store
- MissingETComponentMap* metMap = new MissingETComponentMap();
- if( evtStore()->record(metMap, m_mapname).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETContainer: " << m_mapname);
- return StatusCode::SUCCESS;
- }
- MissingETAuxComponentMap* metAuxMap = new MissingETAuxComponentMap();
- if( evtStore()->record(metAuxMap, m_mapname+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxContainer: " << m_mapname+"Aux.");
- return StatusCode::SUCCESS;
- }
- metMap->setStore(metAuxMap);
+
+ auto metMapHandle= SG::makeHandle (m_mapname);
+ //note that the method below automatically creates the MET container and its corresponding aux store (which will be named "m_contname+Aux.")
+ ATH_CHECK( metMapHandle.record (std::make_unique<xAOD::MissingETComponentMap>(), std::make_unique<xAOD::MissingETAuxComponentMap>()) );
+ xAOD::MissingETComponentMap* metMap=metMapHandle.ptr();
+
if( buildMET(metCont, metMap).isFailure() ) {
ATH_MSG_WARNING("Failed in MissingET reconstruction");
diff --git a/Reconstruction/MET/METReconstruction/Root/METRegionsTool.cxx b/Reconstruction/MET/METReconstruction/Root/METRegionsTool.cxx
index 22c12f602b6a01b0732cb9145229fe4b679ba28b..ca136a9121af6446d34feae6724ca2d7004e554a 100644
--- a/Reconstruction/MET/METReconstruction/Root/METRegionsTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METRegionsTool.cxx
@@ -136,19 +136,21 @@ namespace met {
ATH_MSG_DEBUG ("In execute: " << name() << "...");
// First retrieve the BaseMET
- const MissingETContainer* base_met_container = 0;
- if( evtStore()->retrieve( base_met_container, m_base_met_containerKey ).isFailure() ) {
+ SG::ReadHandle<xAOD::MissingETContainer> base_met_container(m_base_met_containerKey);
+ if (!base_met_container.isValid()) {
ATH_MSG_WARNING("Could not retrieve base MET container!");
return StatusCode::SUCCESS;
}
+
// First retrieve the BaseMET
- const MissingETComponentMap* base_met_map = 0;
- if( evtStore()->retrieve( base_met_map, m_base_met_mapKey ).isFailure() ) {
+ SG::ReadHandle<xAOD::MissingETComponentMap> base_met_map(m_base_met_mapKey);
+ if (!base_met_map.isValid()) {
ATH_MSG_WARNING("Could not retrieve base MET map!");
return StatusCode::SUCCESS;
}
+
// Add to the Container
MissingETContainer* metCont = static_cast<MissingETContainer*>( metTerm_central->container() );
if(!metCont) {
@@ -158,7 +160,7 @@ namespace met {
// Get the components of the base MET
MissingETContainer::const_iterator iterBaseCont = base_met_container->find( m_base_met_inputKey );
- MissingETComponentMap::const_iterator iterBaseConstit = MissingETComposition::find( base_met_map, (*iterBaseCont) );
+ MissingETComponentMap::const_iterator iterBaseConstit = MissingETComposition::find( base_met_map.cptr(), (*iterBaseCont) );
if( iterBaseCont == base_met_container->end() ) {
ATH_MSG_WARNING("Could not find base MET object " << m_base_met_inputKey << " in MET container!");
diff --git a/Reconstruction/MET/METReconstruction/Root/METSoftAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METSoftAssociator.cxx
index 3b9438330747239a3accd188550bbcfeb52b8c13..267abb13907553d2d9ead69e96a3502d1db4c112 100644
--- a/Reconstruction/MET/METReconstruction/Root/METSoftAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METSoftAssociator.cxx
@@ -26,11 +26,13 @@ namespace met {
////////////////
METSoftAssociator::METSoftAssociator(const std::string& name) :
AsgTool(name),
- METAssociator(name)
+ METAssociator(name),
+ m_lcmodclus_key(""),
+ m_emmodclus_key("")
{
declareProperty("DecorateSoftConst", m_decorateSoftTermConst=false);
- declareProperty("LCModClusterKey", m_lcmodclus_key = "LCOriginTopoClusters");
- declareProperty("EMModClusterKey", m_emmodclus_key = "EMOriginTopoClusters");
+ declareProperty("LCModClusterKey", m_lcmodclus = "LCOriginTopoClusters");
+ declareProperty("EMModClusterKey", m_emmodclus = "EMOriginTopoClusters");
}
// Destructor
@@ -44,6 +46,10 @@ namespace met {
{
ATH_CHECK( METAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ ATH_CHECK( m_lcmodclus_key.assign(m_lcmodclus));
+ ATH_CHECK( m_lcmodclus_key.initialize());
+ ATH_CHECK( m_emmodclus_key.assign(m_emmodclus));
+ ATH_CHECK( m_emmodclus_key.initialize());
return StatusCode::SUCCESS;
}
@@ -132,19 +138,17 @@ namespace met {
dec_softConst(*metCoreCl) = std::vector<ElementLink<IParticleContainer> >();
dec_softConst(*metCoreCl).reserve(uniqueClusters->size());
}
- const CaloClusterContainer *lctc(0), *emtc(0);
- if(m_useModifiedClus) {
- ATH_CHECK( evtStore()->retrieve(lctc,m_lcmodclus_key) );
- ATH_CHECK( evtStore()->retrieve(emtc,m_emmodclus_key) );
- }
+ SG::ReadHandle<xAOD::CaloClusterContainer> lctc(m_lcmodclus_key);
+ SG::ReadHandle<xAOD::CaloClusterContainer> emtc(m_emmodclus_key);
+
for(const auto& cl : *uniqueClusters) {
if (cl->e()>FLT_MIN) {
if(m_useModifiedClus) {
- if(lctc && emtc) {
+ if(lctc.isValid() && emtc.isValid()) {
size_t cl_idx(cl->index());
// clusters at LC scale
*metCoreCl += (*lctc)[cl_idx];
- if(m_decorateSoftTermConst) dec_softConst(*metCoreCl).push_back(ElementLink<IParticleContainer>(*static_cast<const IParticleContainer*>(lctc),cl->index()));
+ if(m_decorateSoftTermConst) dec_softConst(*metCoreCl).push_back(ElementLink<IParticleContainer>(*static_cast<const IParticleContainer*>(lctc.cptr()),cl->index()));
// clusters at EM scale
*metCoreEMCl += (*emtc)[cl_idx];
} else {
diff --git a/Reconstruction/MET/METReconstruction/Root/METSoftTermsTool.cxx b/Reconstruction/MET/METReconstruction/Root/METSoftTermsTool.cxx
index 9814fffe9335d291064eebfdb60996cf04797d96..44a68c60a4939d04ac7123feefedd26b61bb50fc 100644
--- a/Reconstruction/MET/METReconstruction/Root/METSoftTermsTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METSoftTermsTool.cxx
@@ -64,10 +64,13 @@ namespace met {
METSoftTermsTool::METSoftTermsTool(const std::string& name) :
AsgTool(name),
METBuilderTool(name),
- m_st_objtype(0)
+ m_st_objtype(0),
+ m_pv_inputkey("PrimaryVertices"),
+ m_caloClusterKey(""),
+ m_trackParticleKey("")
{
declareProperty( "InputComposition", m_inputType = "Clusters" ); // Options : Clusters (default) OR Tracks OR PFOs
- declareProperty( "InputPVKey", m_pv_inputkey = "PrimaryVertices" );
+ //declareProperty( "InputPVKey", m_pv_inputkey = "PrimaryVertices" );
declareProperty( "VetoNegEClus", m_cl_vetoNegE = true );
declareProperty( "OnlyNegEClus", m_cl_onlyNegE = false );
declareProperty( "PFOTool", m_pfotool );
@@ -98,7 +101,18 @@ namespace met {
else {
ATH_MSG_FATAL("Invalid input collection type " << m_inputType << " supplied!");
}
+ // ReadHandleKey(s)
+ ATH_CHECK( m_pv_inputkey.initialize() );
+ if(m_st_objtype==0){
+ ATH_CHECK( m_caloClusterKey.assign(m_input_data_key));
+ ATH_CHECK( m_caloClusterKey.initialize());
+ }
+ else if(m_st_objtype==1){
+ ATH_CHECK( m_trackParticleKey.assign(m_input_data_key));
+ ATH_CHECK( m_trackParticleKey.initialize());
+
+ }
return StatusCode::SUCCESS;
}
@@ -238,18 +252,15 @@ namespace met {
// First retrieve the necessary container
// Currently rely on only one: either CaloClusterContainer or TrackParticleContainer
- const CaloClusterContainer* caloClusCont = 0;
- const TrackParticleContainer* trackParCont = 0;
const PFOContainer* pfoCont = 0;
vector<const IParticle*> signalList;
CaloClusterChangeSignalStateList stateHelperList;
if( m_st_objtype == 0 ) {
-
// Retrieve the calo container
- if( evtStore()->retrieve(caloClusCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input calo cluster container");
- return StatusCode::SUCCESS;
+ SG::ReadHandle<xAOD::CaloClusterContainer> caloClusCont(m_caloClusterKey);
+ if (!caloClusCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input calo cluster container");
}
signalList.reserve(caloClusCont->size());
//stateHelperList.reserve(caloClusCont->size());
@@ -285,9 +296,9 @@ namespace met {
else if( m_st_objtype == 1 ) {
// Retrieve the track container
- if ( evtStore()->retrieve(trackParCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::TrackParticleContainer> trackParCont(m_trackParticleKey);
+ if (!trackParCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input track particle container");
- return StatusCode::SUCCESS;
}
signalList.reserve(trackParCont->size());
@@ -321,9 +332,8 @@ namespace met {
ATH_MSG_WARNING("Unable to retrieve input pfo container");
return StatusCode::SUCCESS;
}
-
- const xAOD::VertexContainer* pv_cont(0);
- if( evtStore()->retrieve( pv_cont, m_pv_inputkey).isFailure() ) {
+ SG::ReadHandle<xAOD::VertexContainer> pv_cont(m_pv_inputkey);
+ if (!pv_cont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input primary vertex container");
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METTauAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METTauAssociator.cxx
index 0b3dae421101e9700243f7720095c73a5e2f7f6c..965de5ffb86217630f35cddc62fea94f2ac6cf38 100644
--- a/Reconstruction/MET/METReconstruction/Root/METTauAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METTauAssociator.cxx
@@ -38,7 +38,8 @@ namespace met {
////////////////
METTauAssociator::METTauAssociator(const std::string& name) :
AsgTool(name),
- METAssociator(name)
+ METAssociator(name),
+ m_tauContKey("")
{}
// Destructor
@@ -52,6 +53,9 @@ namespace met {
{
ATH_CHECK( METAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ ATH_CHECK( m_tauContKey.assign(m_input_data_key));
+ ATH_CHECK( m_tauContKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -79,14 +83,14 @@ namespace met {
{
ATH_MSG_VERBOSE ("In execute: " << name() << "...");
- const TauJetContainer* tauCont(0);
- if( evtStore()->retrieve(tauCont, m_input_data_key).isFailure() ) {
+ SG::ReadHandle<xAOD::TauJetContainer> tauCont(m_tauContKey);
+ if (!tauCont.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input tau container " << m_input_data_key);
return StatusCode::FAILURE;
}
ATH_MSG_DEBUG("Successfully retrieved tau collection");
- if (fillAssocMap(metMap,tauCont).isFailure()) {
+ if (fillAssocMap(metMap,tauCont.cptr()).isFailure()) {
ATH_MSG_WARNING("Unable to fill map with tau container " << m_input_data_key);
return StatusCode::FAILURE;
}
diff --git a/Reconstruction/MET/METReconstruction/Root/METTauTool.cxx b/Reconstruction/MET/METReconstruction/Root/METTauTool.cxx
deleted file mode 100644
index 52c222abbc8c3bde270ac38ff530d37acc681143..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METReconstruction/Root/METTauTool.cxx
+++ /dev/null
@@ -1,339 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METTauTool.cxx
-// Implementation file for class METTauTool
-//
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-//
-// Author: P Loch, S Resconi, TJ Khoo, AS Mete
-///////////////////////////////////////////////////////////////////
-
-// METReconstruction includes
-#include "METReconstruction/METTauTool.h"
-
-// MET EDM
-#include "xAODMissingET/MissingETComposition.h"
-#include "xAODMissingET/MissingETAuxContainer.h"
-#include "xAODMissingET/MissingETAuxComponentMap.h"
-
-// Tau EDM
-#include "xAODTau/TauJetContainer.h"
-#include "xAODTau/TauTrack.h"
-
-// Calo EDM
-#include "xAODCaloEvent/CaloClusterContainer.h"
-
-// Calo helpers
-#include "xAODCaloEvent/CaloClusterChangeSignalState.h"
-
-// DeltaR calculation
-#include "FourMomUtils/xAODP4Helpers.h"
-
-namespace met {
-
- using std::vector;
- //
- using xAOD::IParticle;
- //
- using xAOD::Jet;
- using xAOD::JetConstituentVector;
- //
- using xAOD::TauJet;
- using xAOD::TauTrack;
- using xAOD::TauJetContainer;
- //
- using xAOD::CaloCluster;
- using xAOD::CaloClusterContainer;
- //
- using xAOD::MissingET;
- using xAOD::MissingETComposition;
- using xAOD::MissingETComponent;
- using xAOD::MissingETComponentMap;
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
-
- // Constructors
- ////////////////
- METTauTool::METTauTool(const std::string& name) :
- AsgTool(name),
- METBuilderTool(name)
- {
- declareProperty( "MinPt", m_tau_minPt = 20e3 ); // use GeV const?
- declareProperty( "MaxEta", m_tau_maxEta = 2.5 );
- declareProperty( "IsTauFlag", m_tau_isTauFlag = xAOD::TauJetParameters::JetBDTSigMedium );
- declareProperty( "DoElVeto", m_tau_doElVeto = true );
- declareProperty( "ElVeto", m_tau_elVeto = xAOD::TauJetParameters::EleBDTMedium );
- declareProperty( "DoMuVeto", m_tau_doMuVeto = true );
- declareProperty( "MuVeto", m_tau_muVeto = xAOD::TauJetParameters::MuonVeto );
- declareProperty( "MinWet", m_tau_minWet = 0.5 );
- declareProperty( "DoMinWetPtCut", m_tau_doMinWetPtCut = false );
- declareProperty( "DoTracks", m_tau_doTracks = true );
- }
-
- // Destructor
- ///////////////
- METTauTool::~METTauTool()
- {}
-
- // Athena algtool's Hooks
- ////////////////////////////
- StatusCode METTauTool::initialize()
- {
- ATH_CHECK( METBuilderTool::initialize() );
- ATH_MSG_VERBOSE ("Initializing " << name() << "...");
-
- // Provide parser of input data string here?
- // Or take a list of inputs?
-
- return StatusCode::SUCCESS;
- }
-
- StatusCode METTauTool::finalize()
- {
- ATH_MSG_INFO ("Finalizing " << name() << "...");
-
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Protected methods:
- ///////////////////////////////////////////////////////////////////
-
- bool METTauTool::accept(const xAOD::IParticle* object) const
- {
- if(object->type() != xAOD::Type::Tau) {
- ATH_MSG_WARNING("METTauTool::accept given an object of type " << object->type());
- return false;
- }
- const TauJet* tau = static_cast<const TauJet*>(object);
-
- ATH_MSG_VERBOSE("Testing tau with pt " << tau->pt() << ", eta " << tau->eta());
- ATH_MSG_VERBOSE("Tau ID discriminants:"
- << " jet " << tau->discriminant(xAOD::TauJetParameters::BDTJetScore)
- << " el " << tau->discriminant(xAOD::TauJetParameters::BDTEleScore));
- //<< " mu " << tau->flag(xAOD::TauJetParameters::MuonFlag)); // ASM 18/4/2016 - not in Tau EDM anymore
-
- if(tau->pt()<m_tau_minPt || fabs(tau->eta())>m_tau_maxEta) return false;
- // need to accommodate more than one of these?
- if(!tau->isTau( xAOD::TauJetParameters::IsTauFlag(m_tau_isTauFlag) )) return false;
- // for now, do jet, el, mu discrimination separately.
- if(m_tau_doElVeto)
- if(tau->isTau( xAOD::TauJetParameters::IsTauFlag(m_tau_elVeto) )) return false;
- if(m_tau_doMuVeto)
- if(tau->isTau( xAOD::TauJetParameters::IsTauFlag(m_tau_muVeto) )) return false;
-
- return true;
- }
-
- bool METTauTool::resolveOverlap(const xAOD::IParticle* object,
- xAOD::MissingETComponentMap* metMap,
- std::vector<const xAOD::IParticle*>& acceptedSignals,
- MissingETBase::Types::weight_t& objWeight) const
- {
- if(object->type() != xAOD::Type::Tau) {
- ATH_MSG_WARNING("METTauTool::resolveOverlap given an object of type " << object->type());
- return false;
- }
- const TauJet* tau = static_cast<const TauJet*>(object);
-
- ATH_MSG_VERBOSE("Retrieving tau constituents.");
- /////////////////////////////////////////// TO-BE REMOVED!!!
- /////////////////////////////////////////// TO-BE REMOVED!!!
- ////// <<<===== OLD TAU EDM : ASM 19/4/2016
- //const Jet* jet = *tau->jetLink();
- //JetConstituentVector constit = jet->getConstituents();
- //ATH_MSG_VERBOSE("Current tau has " << constit.size() << " constituents.");
- // first get the topoclusters
- // for now take them from the linked jet and apply a dR cone of 0.2
- // test for used topoclusters, and retrieve unused ones (ok until/unless we use PFlow taus)
- // only use clusters for computing the overlap removal relative to other objects
- //double sumE_allclus = 0.;
- //std::vector<const IParticle*> constit_vec;
- //CaloClusterChangeSignalStateList stateHelperList;
- //for(JetConstituentVector::const_iterator iClus = constit.begin();
- // iClus!=constit.end(); ++iClus) {
- // // TEMP: use jet seed axis
- // // taus will provide an accessor
- // if(!xAOD::P4Helpers::isInDeltaR(*jet,*(*iClus)->rawConstituent(),0.2,m_useRapidity)) continue;
- // // skip cluster if dR>0.2
- // sumE_allclus += (*iClus)->e();
- // if((*iClus)->rawConstituent()->type() != xAOD::Type::CaloCluster) {
- //ATH_MSG_WARNING("Unexpected jet constituent type " << (*iClus)->rawConstituent()->type() << " received! Skip.");
- //continue;
- // }
- // const CaloCluster* pClus = static_cast<const CaloCluster*>( (*iClus)->rawConstituent() );
- // // create a helper to change the signal state and retain it until the end of the execute
- // // signal state will be reset when it goes out of scope
- // //CaloClusterChangeSignalState stateHelper(pClus, CaloCluster::State(m_signalstate));
- // stateHelperList.add(pClus, CaloCluster::State(m_signalstate));
- // constit_vec.push_back(pClus);
- //} // loop over jet constituents
- ////// <<<===== OLD TAU EDM : ASM 19/4/2016
- /////////////////////////////////////////// TO-BE REMOVED!!!
- /////////////////////////////////////////// TO-BE REMOVED!!!
- const CaloClusterContainer* modClusCont(0);
- if(m_useModClus) {
- ATH_CHECK( evtStore()->retrieve(modClusCont,m_mod_clus_key), false );
- }
- double sumE_allclus = 0.;
- std::vector<const IParticle*> constit_vec;
- CaloClusterChangeSignalStateList stateHelperList;
- for( ElementLink< xAOD::IParticleContainer > cluster_link : tau->clusterLinks() ){
- const xAOD::IParticle* ipart = *cluster_link;
- sumE_allclus += ipart->e();
- if(ipart->type() != xAOD::Type::CaloCluster) {
- ATH_MSG_WARNING("Unexpected jet constituent type " << ipart->type() << " received! Skip.");
- continue;
- }
- // Link set in Reconstruction/tauRecTools/src/TauAxisSetter.cxx
- // Internal defaults are m_clusterCone = 0.2, m_doCellCorrection = false, m_doAxisCorrection = True
- const CaloCluster* pClus = static_cast<const CaloCluster*>( ipart );
- if(m_useModClus && modClusCont) {
- // replace with modified cluster
- pClus = (*modClusCont)[pClus->index()];
- }
- stateHelperList.add(pClus, CaloCluster::State(m_signalstate));
- constit_vec.push_back(pClus);
- }
-
- ATH_MSG_VERBOSE( "Tau E = " << tau->e() << ", cluster energy sum = " << sumE_allclus );
- bool clustersUsed = metMap->checkUsage(constit_vec,MissingETBase::UsageHandler::OnlyCluster);
- if(clustersUsed) { // true implies some cluster has been used
- double sumE_unique = 0.; // sumE or sumet?
- for(vector<const IParticle*>::const_iterator iClus = constit_vec.begin();
- iClus!=constit_vec.end(); ++iClus) {
- sumE_unique += (*iClus)->e();
- acceptedSignals.push_back(*iClus);
- } // loop over tau unique constituents
- double scalef = sumE_unique / sumE_allclus;
- // weight as an entire object with the unused E fraction
- // decision about what to do with the weight later
- if(scalef>1.) ATH_MSG_WARNING( "Computed a scale factor " << scalef << " larger than 1!" );
- ATH_MSG_VERBOSE( "Tau unique cluster energy sum = " << sumE_unique );
- objWeight = MissingETBase::Types::weight_t(scalef,scalef,scalef);
- } else {
-
- ATH_MSG_VERBOSE( "Tau has no overlaps." );
- // weight as an entire object with the unused E fraction
- // decision about what to do with the weight later
- acceptedSignals = constit_vec;
- objWeight = MissingETBase::Types::weight_t(1.,1.,1.);
- }
-
- if(m_tau_doTracks) {
- // now find associated tracks
- // TEMP: get all tau core tracks
- // add other tracks (from seed jet) in 0.2 cone
- vector<const IParticle*> tautracks;
- /////////////////////////////////////////// TO-BE REMOVED!!!
- /////////////////////////////////////////// TO-BE REMOVED!!!
- ////// <<<===== OLD TAU EDM : ASM 18/4/2016
- //for(size_t iTrk=0; iTrk<tau->nTracks(); ++iTrk) {
- // tautracks.push_back(tau->track(iTrk));
- //}
- //for(size_t iTrk=0; iTrk<tau->nOtherTracks(); ++iTrk) {
- // const xAOD::TrackParticle* trk = tau->otherTrack(iTrk);
- // if(xAOD::P4Helpers::isInDeltaR(*jet,*trk,0.2,m_useRapidity)) tautracks.push_back(trk);
- //}
- ////// <<<===== OLD TAU EDM : ASM 18/4/2016
- /////////////////////////////////////////// TO-BE REMOVED!!!
- /////////////////////////////////////////// TO-BE REMOVED!!!
- for( const TauTrack* ttrk : tau->tracks(xAOD::TauJetParameters::coreTrack) ){//all tracks dR < 0.2 regardless of quality
- tautracks.push_back(ttrk->track());
- }
- // test for used tracks, and retrieve unused ones
- metMap->checkUsage(tautracks,MissingETBase::UsageHandler::OnlyTrack);
- for(vector<const IParticle*>::const_iterator iTrk = tautracks.begin();
- iTrk!=tautracks.end(); ++iTrk) {
- acceptedSignals.push_back(*iTrk);
- } // loop over tau tracks
- }
-
- return !clustersUsed; // return true if the tau shares no clusters with another object
- }
-
- StatusCode METTauTool::executeTool(xAOD::MissingET* metTerm, xAOD::MissingETComponentMap* metMap) const
- {
-
- ATH_MSG_DEBUG ("In execute: " << name() << "...");
-
- const TauJetContainer* tauCont = 0;
- if( evtStore()->retrieve(tauCont, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input tau container");
- return StatusCode::SUCCESS;
- }
-
- MissingETBase::Types::bitmask_t source = MissingETBase::Source::tau();
- metTerm->setSource(source);
-
- MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
- if(iter==metMap->end()) {
- ATH_MSG_WARNING("Could not find current METComponent in MET Map!");
- return StatusCode::SUCCESS;
- }
- MissingETComponent* newComp = *iter;
- newComp->setStatusWord(MissingETBase::Status::contributedHardTerm());
-
- ATH_MSG_DEBUG("Retrieved tau collection: " << m_input_data_key);
-
- std::vector<const IParticle*> signalList;
- signalList.reserve(15*tauCont->size());
- for(TauJetContainer::const_iterator iTau=tauCont->begin();
- iTau!=tauCont->end(); ++iTau) {
- if ( this->accept(*iTau) ) {
- ATH_MSG_VERBOSE("Accepted tau with "
- << "pT = " << (*iTau)->pt()
- << " eta = " << (*iTau)->eta()
- << " phi = " << (*iTau)->phi());
- signalList.clear();
- MissingETBase::Types::weight_t objWeight;
- if ( this->resolveOverlap(*iTau,metMap,signalList,objWeight) ) {
- // add if not overlapping anything
- this->addToMET(*iTau,signalList,metTerm,metMap,objWeight);
- } else { // no overlaps
- if( m_tau_doMinWetPtCut ) {
- if( (*iTau)->pt()*objWeight.wet() > m_tau_minPt ) {
- ATH_MSG_VERBOSE("Tau weighted energy is above threshold -- add to MET");
- this->addToMET(*iTau,signalList,metTerm,metMap,objWeight);
- //ATH_MSG_VERBOSE("Tau px = " << (*iTau)->px()
- // << " , weighted px = " << (*iTau)->px()*objWeight.wpx()
- // << " ,MET px = " << metTerm->mpx() );
- } // if passes weighted pt cut
- } else {
- if ( objWeight.wet() > m_tau_minWet ) {
- ATH_MSG_VERBOSE("Tau weighted energy is above threshold -- add to MET");
- this->addToMET(*iTau,signalList,metTerm,metMap,objWeight);
- //ATH_MSG_VERBOSE("Tau px = " << (*iTau)->px()
- // << " , weighted px = " << (*iTau)->px()*objWeight.wpx()
- // << " ,MET px = " << metTerm->mpx() );
- } // if passes weight cut
- } // end if do weighted pt cut
- } // overlapping
- } // if passing selection
- } // loop on tau container
- return StatusCode::SUCCESS;
- }
-
- ///////////////////////////////////////////////////////////////////
- // Const methods:
- ///////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////
- // Non-const methods:
- ///////////////////////////////////////////////////////////////////
-
-}
diff --git a/Reconstruction/MET/METReconstruction/Root/METTrackFilterTool.cxx b/Reconstruction/MET/METReconstruction/Root/METTrackFilterTool.cxx
index 9b7bcbae2c37a3d84265e7e1ae4513b3167f24cf..c9085f030b6549345d4a6ce5711d74d77bcead36 100644
--- a/Reconstruction/MET/METReconstruction/Root/METTrackFilterTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METTrackFilterTool.cxx
@@ -66,11 +66,11 @@ namespace met {
declareProperty( "DoPVSel", m_trk_doPVsel = true );
// declareProperty( "TrackD0Max", m_trk_d0Max = 1.5 );
// declareProperty( "TrackZ0Max", m_trk_z0Max = 1.5 );
- declareProperty( "InputPVKey", m_pv_inputkey = "PrimaryVertices" );
+ declareProperty( "InputPVKey", m_pv_input = "PrimaryVertices" );
declareProperty( "DoEoverPSel", m_trk_doEoverPsel = false );
- declareProperty( "InputClusterKey", m_cl_inputkey = "CaloCalTopoClusters");
- declareProperty( "InputElectronKey", m_el_inputkey = "Electrons" );
- declareProperty( "InputMuonKey", m_mu_inputkey = "Muons" );
+ declareProperty( "InputClusterKey", m_cl_input = "CaloCalTopoClusters");
+ declareProperty( "InputElectronKey", m_el_input = "Electrons" );
+ declareProperty( "InputMuonKey", m_mu_input = "Muons" );
declareProperty( "DoVxSep", m_doVxSep = false );
declareProperty( "TrackSelectorTool", m_trkseltool );
declareProperty( "TrackVxAssocTool", m_trkToVertexTool );
@@ -100,6 +100,17 @@ namespace met {
if(m_doVxSep) ATH_MSG_INFO("Building TrackMET for each vertex");
+ ATH_CHECK( m_cl_inputkey.assign(m_cl_input));
+ ATH_CHECK( m_cl_inputkey.initialize());
+ ATH_CHECK( m_pv_inputkey.assign(m_pv_input));
+ ATH_CHECK( m_pv_inputkey.initialize());
+ if(m_doLepRecovery){
+ ATH_CHECK( m_el_inputkey.assign(m_el_input));
+ ATH_CHECK( m_el_inputkey.initialize());
+ ATH_CHECK( m_mu_inputkey.assign(m_mu_input));
+ ATH_CHECK( m_mu_inputkey.initialize());
+ }
+
return StatusCode::SUCCESS;
}
@@ -223,18 +234,21 @@ namespace met {
if(m_doLepRecovery)
{
- const ElectronContainer* elCont(0);
- const MuonContainer* muCont(0);
- if(evtStore()->retrieve(elCont,m_el_inputkey).isFailure()) {
- ATH_MSG_WARNING("Failed to retrieve electron container");
- } else {
+ SG::ReadHandle<xAOD::ElectronContainer> elCont(m_el_inputkey);
+ if (!elCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve electron container " << m_el_input);
+ return StatusCode::SUCCESS;
+ } else {
selectElectrons(*elCont, selElectrons);
}
- if(evtStore()->retrieve(muCont,m_mu_inputkey).isFailure()) {
- ATH_MSG_WARNING("Failed to retrieve muon container");
- } else {
+ SG::ReadHandle<xAOD::MuonContainer> muCont(m_mu_inputkey);
+ if (!muCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve muon container " << m_mu_input);
+ return StatusCode::SUCCESS;
+ } else {
selectMuons(*muCont, selMuons);
- }
+ }
+
}
MissingETComponentMap::iterator iter = MissingETComposition::find(metMap,metTerm);
@@ -265,13 +279,13 @@ namespace met {
}
const Vertex* pv=0;
- const VertexContainer* vxCont = 0;
+ SG::ReadHandle<xAOD::VertexContainer> vxCont(m_pv_inputkey);
+ if (!vxCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input primary vertex container");
+ }
vector<const Vertex*> vertices;
+
if(m_trk_doPVsel) {
- if( evtStore()->retrieve( vxCont, m_pv_inputkey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input primary vertex container");
- return StatusCode::FAILURE;
- }
if(vxCont->size()>0) {
vertices.reserve(vxCont->size());
for(const auto& vx : *vxCont) {
@@ -341,12 +355,11 @@ namespace met {
for( const auto& trk : softTracks ) {
// Could/should use common implementation of addToMET here -- derive builder and refiner from a common base tool?
bool passFilters = true;
- const CaloClusterContainer* tcCont(0);
- if( evtStore()->retrieve(tcCont, m_cl_inputkey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve topocluster container " << m_cl_inputkey << " for overlap removal");
- return StatusCode::FAILURE;
+ SG::ReadHandle<xAOD::CaloClusterContainer> tcCont(m_cl_inputkey);
+ if (!tcCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve topocluster container " << m_cl_inputkey << " for overlap removal");
}
- if(m_trk_doEoverPsel && !isGoodEoverP(trk,softTracks,tcCont)) passFilters = false;
+ if(m_trk_doEoverPsel && !isGoodEoverP(trk,softTracks,tcCont.cptr())) passFilters = false;
if(m_trk_doPVsel) {
if(!(m_trkseltool->accept( *trk, pv ))) passFilters=false;
} else {
diff --git a/Reconstruction/MET/METReconstruction/Root/METTruthAssociator.cxx b/Reconstruction/MET/METReconstruction/Root/METTruthAssociator.cxx
index edca31a6d90e156fdf86c5a2764086983a7c87b7..f4ba808ec0af7ab839daf2b76439f08a8af38127 100644
--- a/Reconstruction/MET/METReconstruction/Root/METTruthAssociator.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METTruthAssociator.cxx
@@ -15,6 +15,8 @@
// METReconstruction includes
#include "METReconstruction/METTruthAssociator.h"
+#include "StoreGate/DataHandle.h"
+
// xAOD EDM
#include "xAODMissingET/MissingETComposition.h"
#include "xAODJet/JetContainer.h"
@@ -47,13 +49,13 @@ namespace met {
METAssociator(name)
{
- declareProperty("RecoJetKey", m_recoJetKey );
- declareProperty("RecoElKey", m_recoElKey = "Electrons" );
- declareProperty("RecoMuKey", m_recoMuKey = "Muons" );
- declareProperty("RecoGamKey", m_recoGamKey = "Photons" );
- declareProperty("RecoTauKey", m_recoTauKey = "TauJets" );
+ declareProperty("RecoJetKey", m_recoJet );
+ declareProperty("RecoElKey", m_recoEl = "Electrons" );
+ declareProperty("RecoMuKey", m_recoMu = "Muons" );
+ declareProperty("RecoGamKey", m_recoGam = "Photons" );
+ declareProperty("RecoTauKey", m_recoTau = "TauJets" );
- declareProperty("TruthEventKey", m_truthEventKey = "TruthEvents" );
+ declareProperty("TruthEventKey", m_truthEvent = "TruthEvents" );
}
// Destructor
@@ -67,6 +69,20 @@ namespace met {
{
ATH_CHECK( METAssociator::initialize() );
ATH_MSG_VERBOSE ("Initializing " << name() << "...");
+ //initialise ReadHandleKeys
+ ATH_CHECK( m_recoElKey.assign(m_recoEl));
+ ATH_CHECK( m_recoElKey.initialize());
+ ATH_CHECK( m_recoJetKey.assign(m_recoJet));
+ ATH_CHECK( m_recoJetKey.initialize());
+ ATH_CHECK( m_recoMuKey.assign(m_recoMu));
+ ATH_CHECK( m_recoMuKey.initialize());
+ ATH_CHECK( m_recoGamKey.assign(m_recoGam));
+ ATH_CHECK( m_recoGamKey.initialize());
+ ATH_CHECK( m_recoTauKey.assign(m_recoTau));
+ ATH_CHECK( m_recoTauKey.initialize());
+ ATH_CHECK( m_truthEventKey.assign(m_truthEvent));
+ ATH_CHECK( m_truthEventKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -94,47 +110,50 @@ namespace met {
ATH_CHECK( associateJets(metMap) );
- const ElectronContainer* electronCont(0);
- if( evtStore()->retrieve(electronCont, m_recoElKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input electron container " << m_recoElKey);
+ SG::ReadHandle<xAOD::ElectronContainer> electronCont(m_recoElKey);
+ if (!electronCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input electron container " << m_recoEl);
return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved electron collection");
- if(fillAssocMap(metMap,electronCont).isFailure()) {
- ATH_MSG_WARNING("Unable to fill map with electron container " << m_recoElKey);
+ if(fillAssocMap(metMap,electronCont.cptr()).isFailure()) {
+ ATH_MSG_WARNING("Unable to fill map with electron container " << m_recoEl);
return StatusCode::FAILURE;
}
- const PhotonContainer* photonCont(0);
- if( evtStore()->retrieve(photonCont, m_recoGamKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input photon container " << m_recoGamKey);
+ SG::ReadHandle<xAOD::PhotonContainer> photonCont(m_recoGamKey);
+ if (!photonCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input photon container " << m_recoGam);
return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved photon collection");
- if(fillAssocMap(metMap,photonCont).isFailure()) {
- ATH_MSG_WARNING("Unable to fill map with photon container " << m_recoGamKey);
+ if(fillAssocMap(metMap,photonCont.cptr()).isFailure()) {
+ ATH_MSG_WARNING("Unable to fill map with photon container " << m_recoGam);
return StatusCode::FAILURE;
}
- const MuonContainer* muonCont(0);
- if( evtStore()->retrieve(muonCont, m_recoMuKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input muon container " << m_recoMuKey);
+ SG::ReadHandle<xAOD::MuonContainer> muonCont(m_recoMuKey);
+ if (!muonCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input muon container " << m_recoMu);
return StatusCode::FAILURE;
}
+
ATH_MSG_DEBUG("Successfully retrieved muon collection");
- if(fillAssocMap(metMap,muonCont).isFailure()) {
- ATH_MSG_WARNING("Unable to fill map with muon container " << m_recoMuKey);
+ if(fillAssocMap(metMap,muonCont.cptr()).isFailure()) {
+ ATH_MSG_WARNING("Unable to fill map with muon container " << m_recoMu);
return StatusCode::FAILURE;
}
- const TauJetContainer* tauCont(0);
- if( evtStore()->retrieve(tauCont, m_recoTauKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input tau container " << m_recoTauKey);
+ SG::ReadHandle<xAOD::TauJetContainer> tauCont(m_recoTauKey);
+ if (!tauCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input tau container " << m_recoTau);
return StatusCode::FAILURE;
}
ATH_MSG_DEBUG("Successfully retrieved tau collection");
- if(fillAssocMap(metMap,tauCont).isFailure()) {
- ATH_MSG_WARNING("Unable to fill map with tau container " << m_recoTauKey);
+ if(fillAssocMap(metMap,tauCont.cptr()).isFailure()) {
+ ATH_MSG_WARNING("Unable to fill map with tau container " << m_recoTau);
return StatusCode::FAILURE;
}
@@ -152,9 +171,9 @@ namespace met {
StatusCode METTruthAssociator::associateJets(xAOD::MissingETAssociationMap* metMap) const
{
// Retrieve the jet container
- const JetContainer* jetCont = 0;
- if( evtStore()->retrieve(jetCont, m_recoJetKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input jet container " << m_recoJetKey);
+ SG::ReadHandle<xAOD::JetContainer> jetCont(m_recoJetKey);
+ if (!jetCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input jet container " << m_recoJet);
return StatusCode::FAILURE;
}
ATH_MSG_DEBUG("Successfully retrieved jet collection");
@@ -217,9 +236,10 @@ namespace met {
ATH_MSG_VERBOSE("Added core terms.");
- const TruthEventContainer* truthEventCont(0);
- if( evtStore()->retrieve(truthEventCont, m_truthEventKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey);
+ // Retrieve the truth container
+ SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
+ if (!truthEventCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEvent);
return StatusCode::FAILURE;
}
@@ -296,12 +316,14 @@ namespace met {
// if(truth && truth!=eltruth) truthlist.push_back(truth);
// }
- const TruthEventContainer* truthEventCont(0);
- if( evtStore()->retrieve(truthEventCont, m_truthEventKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey);
- return StatusCode::FAILURE;
+ // Retrieve the truth container
+ SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
+ if (!truthEventCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEvent);
+ return StatusCode::SUCCESS;
}
+
// First truth event is the hard scatter
const TruthEvent* hsevent = truthEventCont->front();
ConstDataVector<TruthParticleContainer> truthParticleCont(SG::VIEW_ELEMENTS);
@@ -388,10 +410,11 @@ namespace met {
// }
// }
- const TruthEventContainer* truthEventCont(0);
- if( evtStore()->retrieve(truthEventCont, m_truthEventKey).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEventKey);
- return StatusCode::FAILURE;
+ // Retrieve the truth container
+ SG::ReadHandle<xAOD::TruthEventContainer> truthEventCont(m_truthEventKey);
+ if (!truthEventCont.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input truthEvent container " << m_truthEvent);
+ return StatusCode::SUCCESS;
}
// First truth event is the hard scatter
diff --git a/Reconstruction/MET/METReconstruction/Root/METTruthTool.cxx b/Reconstruction/MET/METReconstruction/Root/METTruthTool.cxx
index 89b8c38570cc0b785cf972dc1e97d79e3d412493..113ee0e63234972d7609c4b3f7fdcaf31e10b06a 100644
--- a/Reconstruction/MET/METReconstruction/Root/METTruthTool.cxx
+++ b/Reconstruction/MET/METReconstruction/Root/METTruthTool.cxx
@@ -15,13 +15,14 @@
// METReconstruction includes
#include "METReconstruction/METTruthTool.h"
+#include "StoreGate/DataHandle.h"
+
// MET EDM
#include "xAODMissingET/MissingETComposition.h"
#include "xAODMissingET/MissingETAuxContainer.h"
#include "xAODMissingET/MissingETAuxComponentMap.h"
// Truth EDM
-#include "xAODTruth/TruthEventContainer.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODTruth/TruthVertex.h"
@@ -55,7 +56,8 @@ namespace met {
METTruthTool::METTruthTool(const std::string& name) :
AsgTool(name),
METBuilderTool(name),
- m_truth_type(0)
+ m_truth_type(0),
+ m_truthEventKey("")
{
// NonInt, Int, IntMuons, IntOut
declareProperty( "InputComposition", m_inputType = "NonInt" ); // Truth type
@@ -88,6 +90,9 @@ namespace met {
ATH_MSG_FATAL("Invalid input type provided");
return StatusCode::FAILURE;
}
+ ATH_CHECK( m_truthEventKey.assign(m_input_data_key));
+ ATH_CHECK( m_truthEventKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -195,13 +200,13 @@ namespace met {
ATH_MSG_DEBUG ("In execute: " << name() << "...");
- const TruthEventContainer* truthEvents = 0;
-
metTerm->setSource(m_truth_type);
// Retrieve the truth container
- if ( evtStore()->retrieve(truthEvents, m_input_data_key).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input truth event container");
+ SG::ReadHandle<xAOD::TruthEventContainer> truthEvents(m_truthEventKey);
+
+ if (!truthEvents.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve input truth event container ");
return StatusCode::SUCCESS;
}
diff --git a/Reconstruction/MET/METReconstruction/share/RunMETReco_Associator_AOD.py b/Reconstruction/MET/METReconstruction/share/RunMETReco_Associator_AOD.py
index d429f5fec49d67cea31d17905710cd98c54ded70..f874c0d8d37b1cfb99b5c4f303758aafac00b495 100644
--- a/Reconstruction/MET/METReconstruction/share/RunMETReco_Associator_AOD.py
+++ b/Reconstruction/MET/METReconstruction/share/RunMETReco_Associator_AOD.py
@@ -6,7 +6,7 @@ from AthenaCommon import CfgMgr
from RecExConfig.RecFlags import rec
from glob import glob
-filelist = glob("/atlas/data1/userdata/khoo/Data16/AOD_r21/data16_13TeV.00302347.express_express.recon.AOD.r9112/*")
+filelist = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/CommonInputs/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"]
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
athenaCommonFlags.FilesInput = filelist
@@ -39,7 +39,7 @@ from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from GaudiSequencer.PyComps import PyEvtFilter
-filterseq = CfgMgr.AthSequencer("AthFilterSeq")
+#filterseq = CfgMgr.AthSequencer("AthFilterSeq")
#the following lines are examples, pick one...
# filterseq += PyEvtFilter("PVSoftTrkTail", evt_list=[
# # 106239409,
@@ -59,7 +59,7 @@ filterseq = CfgMgr.AthSequencer("AthFilterSeq")
# # 7747623,
# # 9713934,
# ])
-topSequence += filterseq
+#topSequence += filterseq
############################################################################
# Set up an extra associator for testing
@@ -67,6 +67,17 @@ from METReconstruction.METRecoFlags import metFlags
from METReconstruction.METAssocConfig import AssocConfig, METAssocConfig
JetType = 'EMJet'
+modConstKey = ""
+modClusColls = {}
+if metFlags.UseTracks():
+ modConstKey="OriginCorr"
+ modClusColls={
+ 'LCOriginCorrClusters':'LCOriginTopoClusters',
+ 'EMOriginCorrClusters':'EMOriginTopoClusters'
+ }
+
+
+
associators = [AssocConfig(JetType),
AssocConfig('Muon'),
AssocConfig('Ele'),
@@ -76,7 +87,8 @@ associators = [AssocConfig(JetType),
cfg_akt4em = METAssocConfig('NewAntiKt4EMTopo',
associators,
doPFlow=False,
- doOriginCorrClus=True
+ modConstKey=modConstKey,
+ modClusColls=modClusColls
)
metFlags.METAssocConfigs()[cfg_akt4em.suffix] = cfg_akt4em
@@ -105,17 +117,17 @@ from METReconstruction.METAssocConfig import getMETAssocAlg
# Get the configuration directly from METRecoFlags
# Can also provide a dict of configurations or list of RecoTools or both
metAlg = getMETAssocAlg('METAssociation')
-filterseq += metAlg
+topSequence += metAlg
from METUtilities.METMakerConfig import getMETMakerAlg
makerAlgEM = getMETMakerAlg("NewAntiKt4EMTopo",jetColl="AntiKt4EMTopoJets")
-# ToolSvc.METMaker_NewAntiKt4EMTopo.OutputLevel=VERBOSE
+ToolSvc.METMaker_NewAntiKt4EMTopo.OutputLevel=VERBOSE
ToolSvc.METMaker_NewAntiKt4EMTopo.DoRemoveElecTrks=False
-filterseq += makerAlgEM
+topSequence += makerAlgEM
makerAlgPF = getMETMakerAlg("NewAntiKt4EMPFlow",jetColl="AntiKt4EMPFlowJets")
-# ToolSvc.METMaker_NewAntiKt4EMPFlow.OutputLevel=VERBOSE
+ToolSvc.METMaker_NewAntiKt4EMPFlow.OutputLevel=VERBOSE
ToolSvc.METMaker_NewAntiKt4EMPFlow.DoRemoveElecTrks=False
-filterseq += makerAlgPF
+topSequence += makerAlgPF
# filterseq += CfgMgr.met__METAssocTestAlg("TestMETAssocEMTopo",
# OutputLevel=VERBOSE,
@@ -146,6 +158,6 @@ if write_xAOD:
xaodStream.AddItem('xAOD::TrackParticleAuxContainer#InDetTrackParticlesAux.')
# xaodStream.AddAcceptAlgs( "PVSoftTrkTail" )
-theApp.EvtMax = 200
+theApp.EvtMax = 10
ServiceMgr.EventSelector.SkipEvents = 0
ServiceMgr.MessageSvc.defaultLimit = 9999
diff --git a/Reconstruction/MET/METReconstruction/src/METAssocTestAlg.cxx b/Reconstruction/MET/METReconstruction/src/METAssocTestAlg.cxx
index 10985cbe75de4f5a26729a54a1ab7314966a0ca6..c33236af6ddec685df7291aae2354a744839989c 100644
--- a/Reconstruction/MET/METReconstruction/src/METAssocTestAlg.cxx
+++ b/Reconstruction/MET/METReconstruction/src/METAssocTestAlg.cxx
@@ -39,9 +39,13 @@ namespace met {
StatusCode METAssocTestAlg::execute()
{
- const MissingETAssociationMap* map(NULL);
- ATH_MSG_DEBUG( "Running METAssocTestAlg on " << "map " << m_mapname << "." );
- ATH_CHECK( evtStore()->retrieve(map, m_mapname) );
+
+
+ SG::ReadHandle<MissingETAssociationMap> map(m_mapname);
+ if (!map.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve met association map");
+ return StatusCode::FAILURE;
+ }
for(const auto& assoc : *map) {
if(assoc->isMisc()) { // misc association gets special treatment
diff --git a/Reconstruction/MET/METReconstruction/src/METReaderAlg.cxx b/Reconstruction/MET/METReconstruction/src/METReaderAlg.cxx
index ffbb179c407375514aa7fd2b4cda5c1d931ea79c..8578113b765cb44ea6632dadba503f478862e142 100644
--- a/Reconstruction/MET/METReconstruction/src/METReaderAlg.cxx
+++ b/Reconstruction/MET/METReconstruction/src/METReaderAlg.cxx
@@ -6,6 +6,7 @@
#include "METReaderAlg.h"
#include "xAODJet/JetContainer.h"
+
#include "xAODMissingET/MissingETContainer.h"
#include "xAODMissingET/MissingETComponentMap.h"
@@ -19,7 +20,17 @@ namespace met {
METReaderAlg::METReaderAlg(const std::string& name,
ISvcLocator* pSvcLocator )
- : ::AthAlgorithm( name, pSvcLocator ) {
+ : ::AthReentrantAlgorithm( name, pSvcLocator ) {
+ declareProperty ("MET_RefFinal", m_met_RefFinal = "MET_RefFinal");
+ declareProperty ("MET_LocHadTopo", m_met_LocHadTopo = "MET_LocHadTopo");
+ declareProperty ("MET_Track", m_met_Track = "MET_Track");
+ declareProperty ("MET_PFlow", m_met_PFlow = "MET_PFlow");
+ declareProperty ("MET_Truth", m_met_Truth = "MET_Truth");
+ declareProperty ("MET_TruthRegions", m_met_TruthReg = "MET_TruthRegions");
+ declareProperty ("METMap_RefFinal", m_metMap_RefFinal = "METMap_RefFinal");
+ declareProperty ("METMap_LocHadTopo", m_metMap_LocHadTopo = "METMap_LocHadTopo");
+
+
}
//**********************************************************************
@@ -30,7 +41,15 @@ namespace met {
StatusCode METReaderAlg::initialize() {
ATH_MSG_INFO("Initializing " << name() << "...");
-
+ ATH_CHECK( m_met_RefFinal.initialize() );
+ ATH_CHECK( m_met_LocHadTopo.initialize() );
+ ATH_CHECK( m_met_Track.initialize() );
+ ATH_CHECK( m_met_PFlow.initialize() );
+ ATH_CHECK( m_met_Truth.initialize() );
+ ATH_CHECK( m_met_TruthReg.initialize() );
+ ATH_CHECK( m_metMap_RefFinal.initialize() );
+ ATH_CHECK( m_metMap_LocHadTopo.initialize() );
+
return StatusCode::SUCCESS;
}
@@ -43,22 +62,24 @@ namespace met {
//**********************************************************************
- StatusCode METReaderAlg::execute() {
+ StatusCode METReaderAlg::execute_r (const EventContext& ctx) const{
ATH_MSG_VERBOSE("Executing " << name() << "...");
// Loop over tools.
ATH_MSG_INFO( "Check MET rebuilding" );
+ SG::ReadHandle<xAOD::MissingETContainer> met_RefFinal (m_met_RefFinal, ctx);
+ SG::ReadHandle<xAOD::MissingETContainer> met_LocHadTopo (m_met_LocHadTopo, ctx);
+ SG::ReadHandle<xAOD::MissingETContainer> met_Track (m_met_Track, ctx);
+ SG::ReadHandle<xAOD::MissingETContainer> met_PFlow (m_met_PFlow, ctx);
+ SG::ReadHandle<xAOD::MissingETContainer> met_Truth (m_met_Truth, ctx);
- const MissingETContainer* met_RefFinal = 0;
- bool doRefFinal( evtStore()->retrieve(met_RefFinal,"MET_RefFinal").isSuccess() );
- const MissingETContainer* met_LocHadTopo = 0;
- bool doLHT( evtStore()->retrieve(met_LocHadTopo,"MET_LocHadTopo").isSuccess() );
- const MissingETContainer* met_Track = 0;
- bool doTrack( evtStore()->retrieve(met_Track,"MET_Track").isSuccess() );
- const MissingETContainer* met_PFlow = 0;
- bool doPFlow( evtStore()->retrieve(met_PFlow,"MET_PFlow").isSuccess() );
- const MissingETContainer* met_Truth = 0;
- bool doTruth( evtStore()->retrieve(met_Truth,"MET_Truth").isSuccess() );
+
+
+ bool doRefFinal( met_RefFinal.isValid() );
+ bool doLHT( met_LocHadTopo.isValid() );
+ bool doTrack( met_Track.isValid() );
+ bool doPFlow( met_PFlow.isValid() );
+ bool doTruth( met_Truth.isValid() );
ATH_MSG_INFO( " MET magnitude:" );
//
@@ -155,17 +176,19 @@ namespace met {
}
if(doTruth) {
- const MissingETContainer* met_TruthReg = 0;
- if( evtStore()->retrieve(met_TruthReg,"MET_TruthRegions").isSuccess() ) {
+ SG::ReadHandle<xAOD::MissingETContainer> met_TruthReg (m_met_TruthReg, ctx);
+
+ if( met_TruthReg.isValid() ) {
ATH_MSG_INFO( " MET_Truth_IntCentral_y = " << (*met_TruthReg)["Int_Central"]->mpy() );
ATH_MSG_INFO( " MET_Truth_IntEndCap_y = " << (*met_TruthReg)["Int_EndCap"]->mpy() );
ATH_MSG_INFO( " MET_Truth_IntForward_y = " << (*met_TruthReg)["Int_Forward"]->mpy() );
}
}
- const MissingETComponentMap* metMap_RefFinal = 0;
- CHECK( evtStore()->retrieve(metMap_RefFinal,"METMap_RefFinal") );
- const MissingETComponentMap* metMap_LocHadTopo = 0;
- CHECK( evtStore()->retrieve(metMap_LocHadTopo,"METMap_LocHadTopo") );
+ SG::ReadHandle<xAOD::MissingETComponentMap> metMap_RefFinal (m_metMap_RefFinal, ctx);
+ SG::ReadHandle<xAOD::MissingETComponentMap> metMap_LocHadTopo (m_metMap_LocHadTopo, ctx);
+
+ ATH_CHECK( metMap_RefFinal.isValid() );
+ ATH_CHECK( metMap_LocHadTopo.isValid() );
ATH_MSG_INFO( "Number of components in MET map: " << metMap_RefFinal->size() );
ATH_MSG_INFO( "Number of components in MET map: " << metMap_LocHadTopo->size() );
diff --git a/Reconstruction/MET/METReconstruction/src/METReaderAlg.h b/Reconstruction/MET/METReconstruction/src/METReaderAlg.h
index 25097c2d13aca71fff13ac6b54b5d7a64dea2a9a..c781f52fbb4063abdc1c548a7ebe2b5d48efa4bc 100644
--- a/Reconstruction/MET/METReconstruction/src/METReaderAlg.h
+++ b/Reconstruction/MET/METReconstruction/src/METReaderAlg.h
@@ -7,10 +7,14 @@
#ifndef METReaderAlg_H
#define METReaderAlg_H
-#include "AthenaBaseComps/AthAlgorithm.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "StoreGate/DataHandle.h"
+#include "xAODMissingET/MissingETContainer.h"
+#include "xAODMissingET/MissingETComponentMap.h"
+
namespace met {
- class METReaderAlg : public AthAlgorithm {
+ class METReaderAlg : public AthReentrantAlgorithm {
public:
@@ -22,13 +26,23 @@ namespace met {
/// Athena algorithm's Hooks
StatusCode initialize();
- StatusCode execute();
+ StatusCode execute_r (const EventContext& ctx) const override;
StatusCode finalize();
private:
/// Default constructor:
METReaderAlg();
+
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_RefFinal;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_LocHadTopo;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_Track;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_PFlow;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_Truth;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_met_TruthReg;
+ SG::ReadHandleKey<xAOD::MissingETComponentMap> m_metMap_RefFinal;
+ SG::ReadHandleKey<xAOD::MissingETComponentMap> m_metMap_LocHadTopo;
+
};
diff --git a/Reconstruction/MET/METReconstruction/src/components/METReconstruction_entries.cxx b/Reconstruction/MET/METReconstruction/src/components/METReconstruction_entries.cxx
index d2119fc5750e21288124f767a62e07c2b4783723..78444a63de21014095ee8ffffb8b14595a26928c 100644
--- a/Reconstruction/MET/METReconstruction/src/components/METReconstruction_entries.cxx
+++ b/Reconstruction/MET/METReconstruction/src/components/METReconstruction_entries.cxx
@@ -2,11 +2,6 @@
#include "METReconstruction/METRecoTool.h"
#include "METReconstruction/METAssociationTool.h"
// Builders
-#include "METReconstruction/METElectronTool.h"
-#include "METReconstruction/METPhotonTool.h"
-#include "METReconstruction/METJetTool.h"
-#include "METReconstruction/METTauTool.h"
-#include "METReconstruction/METMuonTool.h"
#include "METReconstruction/METSoftTermsTool.h"
#include "METReconstruction/METElectronAssociator.h"
#include "METReconstruction/METPhotonAssociator.h"
@@ -20,9 +15,7 @@
// CaloRegions
#include "METReconstruction/METCaloRegionsTool.h"
// Refiners
-#include "METReconstruction/METJetFilterTool.h"
#include "METReconstruction/METTrackFilterTool.h"
-#include "METReconstruction/METMuonElossTool.h"
#include "METReconstruction/METRegionsTool.h"
// Algs
#include "METRecoAlg.h"
@@ -33,11 +26,6 @@ using namespace met;
DECLARE_COMPONENT( METRecoTool )
DECLARE_COMPONENT( METAssociationTool )
-DECLARE_COMPONENT( METElectronTool )
-DECLARE_COMPONENT( METPhotonTool )
-DECLARE_COMPONENT( METJetTool )
-DECLARE_COMPONENT( METTauTool )
-DECLARE_COMPONENT( METMuonTool )
DECLARE_COMPONENT( METSoftTermsTool )
DECLARE_COMPONENT( METElectronAssociator )
DECLARE_COMPONENT( METPhotonAssociator )
@@ -50,12 +38,9 @@ DECLARE_COMPONENT( METTruthTool )
DECLARE_COMPONENT( METTruthAssociator )
DECLARE_COMPONENT( METCaloRegionsTool )
//
-DECLARE_COMPONENT( METJetFilterTool )
-DECLARE_COMPONENT( METTrackFilterTool )
-DECLARE_COMPONENT( METMuonElossTool )
-DECLARE_COMPONENT( METRegionsTool )
+DECLARE_COMPONENT(METTrackFilterTool)
+DECLARE_COMPONENT(METRegionsTool)
//
DECLARE_COMPONENT( METRecoAlg )
DECLARE_COMPONENT( METReaderAlg )
DECLARE_COMPONENT( METAssocTestAlg )
-
diff --git a/Reconstruction/MET/METUtilities/METUtilities/METHelpers.h b/Reconstruction/MET/METUtilities/METUtilities/METHelpers.h
deleted file mode 100644
index 2014223d3e31a673b768bc2d45ac0d7caf494af3..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METUtilities/METUtilities/METHelpers.h
+++ /dev/null
@@ -1,24 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METHelpers.h
-// Header file for METHelpers functions
-// Author: T.J.Khoo<khoo@cern.ch>
-///////////////////////////////////////////////////////////////////
-#ifndef METUTILITIES_MET_METHELPERS_H
-#define METUTILITIES_MET_METHELPERS_H 1
-
-#include "xAODMuon/MuonContainer.h"
-#include "xAODJet/JetContainer.h"
-
-namespace met {
-
- void addGhostMuonsToJets(const xAOD::MuonContainer& muons, xAOD::JetContainer& jets);
- // void addGhostElecsToJets(const xAOD::ElectronContainer& elecs, xAOD::JetContainer& jets);
-
-}
-
-#endif
diff --git a/Reconstruction/MET/METUtilities/METUtilities/METMaker.h b/Reconstruction/MET/METUtilities/METUtilities/METMaker.h
index 1362351f20a0d9f093ff6e04c2a5a09783b57a01..d6f5e151e098b2cee4b8d4b8188641a5fdb71514 100644
--- a/Reconstruction/MET/METUtilities/METUtilities/METMaker.h
+++ b/Reconstruction/MET/METUtilities/METUtilities/METMaker.h
@@ -17,6 +17,7 @@
// FrameWork includes
#include "AsgTools/ToolHandle.h"
#include "AsgTools/AsgTool.h"
+#include "StoreGate/DataHandle.h"
// METInterface includes
#include "METInterface/IMETMaker.h"
@@ -146,6 +147,8 @@ namespace met {
bool acceptTrack(const xAOD::TrackParticle* trk, const xAOD::Vertex* vx) const;
const xAOD::Vertex* getPV() const;
+
+ SG::ReadHandleKey<xAOD::VertexContainer> m_PVkey;
// std::string m_pvcoll;
bool m_jetCorrectPhi;
diff --git a/Reconstruction/MET/METUtilities/METUtilities/METRebuilder.h b/Reconstruction/MET/METUtilities/METUtilities/METRebuilder.h
index 1ca108cea9ef1e80253aaf80de01cc4919eacb45..30594d2c3e8a0fecba493124c1c45ae71341507f 100644
--- a/Reconstruction/MET/METUtilities/METUtilities/METRebuilder.h
+++ b/Reconstruction/MET/METUtilities/METUtilities/METRebuilder.h
@@ -17,6 +17,8 @@
// FrameWork includes
#include "AsgTools/AsgTool.h"
#include "AsgTools/ToolHandle.h"
+#include "StoreGate/DataHandle.h"
+
// METInterface includes
#include "METInterface/IMETRebuilder.h"
@@ -24,7 +26,20 @@
// Tracking Tool
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+// MET EDM
+#include "xAODMissingET/MissingETContainer.h"
+#include "xAODMissingET/MissingETComposition.h"
+#include "xAODMissingET/MissingETAuxContainer.h"
+#include "xAODMissingET/MissingETComponentMap.h"
+
// EDM includes
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODTau/TauJetContainer.h"
+#include "xAODTau/TauxAODHelpers.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODJet/JetAttributes.h"
+
#include "xAODJet/JetContainer.h"
#include "xAODTracking/VertexFwd.h"
#include "xAODTracking/TrackParticleFwd.h"
@@ -147,6 +162,19 @@ namespace met {
/// Default constructor:
METRebuilder();
+ // ReadHandleKey(s)
+ SG::ReadHandleKey<xAOD::MissingETComponentMap> m_METMapKey;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_METContainerKey;
+ SG::ReadHandleKey<xAOD::MissingETAuxContainer> m_METAuxContainerKey;
+ SG::ReadHandleKey<xAOD::ElectronContainer> m_ElectronContainerKey;
+ SG::ReadHandleKey<xAOD::PhotonContainer> m_PhotonContainerKey;
+ SG::ReadHandleKey<xAOD::TauJetContainer> m_TauJetContainerKey;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_MuonContainerKey;
+ SG::ReadHandleKey<xAOD::JetContainer> m_JetContainerKey;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_PVKey;
+ // WriteHandleKey(s)
+ SG::WriteHandleKey<xAOD::MissingETContainer> m_OutMETKey;
+
std::string m_eleColl;
std::string m_gammaColl;
std::string m_tauColl;
@@ -164,6 +192,10 @@ namespace met {
std::string m_inputMap;
std::string m_outMETCont;
std::string m_outMETTerm;
+
+
+
+
bool m_warnOfDupes;
bool m_doEle;
diff --git a/Reconstruction/MET/METUtilities/METUtilities/METSystematicsTool.h b/Reconstruction/MET/METUtilities/METUtilities/METSystematicsTool.h
index 28534fb71eff8d83bcd9eebf4ff04bb039b285af..bd2aee6d6295138a5bf3bd7b42b8cfacdc3ce666 100644
--- a/Reconstruction/MET/METUtilities/METUtilities/METSystematicsTool.h
+++ b/Reconstruction/MET/METUtilities/METUtilities/METSystematicsTool.h
@@ -17,6 +17,7 @@ class TH1D;
#include "METInterface/IMETSystematicsTool.h"
#include "AsgTools/AsgTool.h"
+#include "StoreGate/DataHandle.h"
#include "PATInterfaces/SystematicsTool.h"
@@ -167,6 +168,13 @@ namespace met {
int getNPV() const;
xAOD::EventInfo const * getDefaultEventInfo() const;
+
+ //Read/write handles
+ SG::ReadHandleKey<xAOD::VertexContainer> m_VertexContKey;
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_TruthContKey;
+ SG::ReadHandleKey<xAOD::EventInfo> m_EventInfoKey;
+
+
StatusCode addMETAffectingSystematics();
StatusCode extractHistoPath(std::string & histfile, std::string & systpath, std::string & configdir, std::string & suffix, SystType const & type);
diff --git a/Reconstruction/MET/METUtilities/Root/CutsMETMaker.cxx b/Reconstruction/MET/METUtilities/Root/CutsMETMaker.cxx
index 045b2125abe6cc488171d8194e573fbe3ec95290..1fb2058f571a6a07c7bc9acd2cf413f6f46a6c7c 100644
--- a/Reconstruction/MET/METUtilities/Root/CutsMETMaker.cxx
+++ b/Reconstruction/MET/METUtilities/Root/CutsMETMaker.cxx
@@ -9,6 +9,7 @@ Authors: Teng Jian Khoo <teng.jian.khoo@cern.ch>
These selections are available as a courtesy for users to easily validate they are correctly using the METMaker code.
These are the cuts used in the METRebuilder, so you can easily compare and make sure you are doing the same thing with the METMaker
These selections are NOT optimized, especially the muon term, and as such should be optimized within physics groups
+SW note no changes required for MT mode
*/
#include "METUtilities/CutsMETMaker.h"
diff --git a/Reconstruction/MET/METUtilities/Root/METHelpers.cxx b/Reconstruction/MET/METUtilities/Root/METHelpers.cxx
deleted file mode 100644
index 1bb53d63177866e2ed39171c0992ede05c3a93a6..0000000000000000000000000000000000000000
--- a/Reconstruction/MET/METUtilities/Root/METHelpers.cxx
+++ /dev/null
@@ -1,105 +0,0 @@
-///////////////////////// -*- C++ -*- /////////////////////////////
-
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// METMaker.cxx
-// Implementation file for class METMaker
-// Author: T.J.Khoo<khoo@cern.ch>
-///////////////////////////////////////////////////////////////////
-
-// METUtilities includes
-#include "METUtilities/METMaker.h"
-
-// Muon EDM
-#include "xAODMuon/MuonContainer.h"
-
-// Electron EDM
-#include "xAODEgamma/ElectronContainer.h"
-#include "xAODEgamma/EgammaxAODHelpers.h"
-
-// Jet EDM
-#include "xAODJet/JetContainer.h"
-
-#include "FourMomUtils/xAODP4Helpers.h"
-
-#include <iostream>
-
-namespace met {
-
- void addGhostMuonsToJets(const xAOD::MuonContainer& muons, xAOD::JetContainer& jets)
- {
- std::vector<const xAOD::TrackParticle*> jet_tracks;
- for (const auto& jet: jets) {
- // Fill this with muons to be associated
- std::vector<const xAOD::Muon*> muons_in_jet;
- // Get the tracks associated to the jet
- jet_tracks.clear();
- if ( jet->getAssociatedObjects("GhostTrack", jet_tracks) ) {
-
- for(const auto& muon : muons) {
- const xAOD::TrackParticle* idtrack = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
- if(idtrack) {
- // check if this is ghost associated to a jet
- //make sure the jet is close first
- if(xAOD::P4Helpers::deltaR2(*jet,*muon)>0.36) continue;
- // std::cout << "METHelpers::addGhostMuonsToJets -- Muon/jet deltaR^2 = " << xAOD::P4Helpers::deltaR2(*jet,*muon) << std::endl;
-
- for(unsigned jtrk=0; jtrk<jet_tracks.size(); ++jtrk) {
- if(jet_tracks.at(jtrk)==idtrack) {
- //check if the track pointers match
- // std::cout << "METHelpers::addGhostMuonsToJets -- Muon/jet tracks match!" << std::endl;
- muons_in_jet.push_back(muon);
- break;
- }
- } // loop over jet tracks
-
- } // if muon has ID track
- } // loop over muons
-
- } // jet has associated tracks
- // std::cout << "METHelpers::addGhostMuonsToJets -- Jet has = " << muons_in_jet.size() << " ghost muons" << std::endl;
- jet->setAssociatedObjects( "GhostMuon", muons_in_jet) ;
- } // loop over jets
-
- } // end addGhostMuonsToJets(...)
-
- // void addGhostElecsToJets(const xAOD::ElectronContainer& elecs, xAOD::JetContainer& jets)
- // {
- // std::vector<const xAOD::TrackParticle*> jet_tracks;
- // for (const auto& jet: jets) {
- // // Fill this with muons to be associated
- // std::vector<const xAOD::Electron*> elecs_in_jet;
- // // Get the tracks associated to the jet
- // jet_tracks.clear();
- // if ( jet->getAssociatedObjects("GhostTrack", jet_tracks) ) {
-
- // for(const auto& elec : elecs) {
- // bool eleMatch=false;
- // for(size_t iTrk=0; iTrk<elec->nTrackParticles(); ++iTrk) {
- // const xAOD::TrackParticle* idtrack = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(elec->trackParticle(iTrk));
- // if(idtrack) {
- // // check if this is ghost associated to a jet
- // //make sure the jet is close first
- // if(xAOD::P4Helpers::deltaR2(*jet,*elec)>0.3) continue;
- // for(unsigned jtrk=0; jtrk<jet_tracks.size(); ++jtrk) {
- // if(jet_tracks.at(jtrk)==idtrack) {
- // //check if the track pointers match
- // elecs_in_jet.push_back(elec);
- // eleMatch=true;
- // break;
- // }
- // } // loop over jet tracks
- // } // if elec has ID track
- // if(eleMatch) break;
- // }
- // } // loop over elecs
- // } // jet has associated tracks
- // //std::cout << "METHelpers::addGhostElecsToJets -- Jet has = " << elecs_in_jet.size() << " ghost electrons" << std::endl;
- // jet->setAssociatedObjects( "GhostElec", elecs_in_jet) ;
- // } // loop over jets
-
- // } // end addGhostElecsToJets(...)
-
-}
diff --git a/Reconstruction/MET/METUtilities/Root/METMaker.cxx b/Reconstruction/MET/METUtilities/Root/METMaker.cxx
index 53ab6a27a7bbc1f4f03b2524bfa42f0e71279491..623db4a6531cfbedaa66b6b0220f010369428c58 100644
--- a/Reconstruction/MET/METUtilities/Root/METMaker.cxx
+++ b/Reconstruction/MET/METUtilities/Root/METMaker.cxx
@@ -84,6 +84,7 @@ namespace met {
////////////////
METMaker::METMaker(const std::string& name) :
AsgTool(name),
+ m_PVkey("PrimaryVertices"),
m_extraJetRejection(false),
m_trkseltool("")
{
@@ -158,6 +159,10 @@ namespace met {
return StatusCode::FAILURE;
}
+ // ReadHandleKey(s)
+
+ ATH_CHECK( m_PVkey.initialize() );
+
return StatusCode::SUCCESS;
}
@@ -1092,22 +1097,41 @@ namespace met {
}
const xAOD::Vertex* METMaker::getPV() const {
- const xAOD::VertexContainer *vxCont = 0;
+
const xAOD::Vertex *pv = 0;
- if( evtStore()->retrieve(vxCont,"PrimaryVertices").isFailure() ) {
+
+ SG::ReadHandle<xAOD::VertexContainer> h_PV(m_PVkey);
+
+ if (!h_PV.isValid()) {
+
ATH_MSG_WARNING("Unable to retrieve primary vertex container PrimaryVertices");
- } else if(vxCont->empty()) {
+
+ } else if(h_PV->empty()) {
+
ATH_MSG_WARNING("Event has no primary vertices!");
+
} else {
+
ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
- for(const auto& vx : *vxCont) {
- if(vx->vertexType()==xAOD::VxType::PriVtx)
- {pv = vx; break;}
+
+ for(const auto& vx : *h_PV) {
+
+ if(vx->vertexType()==xAOD::VxType::PriVtx) {
+
+ pv = vx; break;
+
+ }
+
}
+
}
+
return pv;
+
}
+
+
///////////////////////////////////////////////////////////////////
// Const methods:
///////////////////////////////////////////////////////////////////
diff --git a/Reconstruction/MET/METUtilities/Root/METRebuilder.cxx b/Reconstruction/MET/METUtilities/Root/METRebuilder.cxx
index 58044ae6e3770f54ef34213e8dbe7007124f4743..cb2d94d432dd37b65f2ff728a37cc224349e0016 100644
--- a/Reconstruction/MET/METUtilities/Root/METRebuilder.cxx
+++ b/Reconstruction/MET/METUtilities/Root/METRebuilder.cxx
@@ -59,6 +59,13 @@ namespace met {
////////////////
METRebuilder::METRebuilder(const std::string& name) :
AsgTool(name),
+ m_METMapKey(""),
+ m_ElectronContainerKey(""),
+ m_PhotonContainerKey(""),
+ m_TauJetContainerKey(""),
+ m_MuonContainerKey(""),
+ m_JetContainerKey(""),
+ m_PVKey(""),
m_doEle(false),
m_doGamma(false),
m_doTau(false),
@@ -219,6 +226,25 @@ namespace met {
ATH_CHECK( m_trkseltool.retrieve() );
}
+ // ReadHandleKey(s)
+ ATH_CHECK( m_METMapKey.assign(m_inputMap) );
+ ATH_CHECK( m_METMapKey.initialize() );
+ ATH_CHECK( m_ElectronContainerKey.assign(m_eleColl) );
+ ATH_CHECK( m_ElectronContainerKey.initialize() );
+ ATH_CHECK( m_PhotonContainerKey.assign(m_gammaColl) );
+ ATH_CHECK( m_PhotonContainerKey.initialize() );
+ ATH_CHECK( m_TauJetContainerKey.assign(m_tauColl) );
+ ATH_CHECK( m_TauJetContainerKey.initialize() );
+ ATH_CHECK( m_MuonContainerKey.assign(m_muonColl) );
+ ATH_CHECK( m_MuonContainerKey.initialize() );
+ ATH_CHECK( m_JetContainerKey.assign(m_jetColl) );
+ ATH_CHECK( m_JetContainerKey.initialize() );
+ ATH_CHECK( m_PVKey.assign(m_vtxColl) );
+ ATH_CHECK( m_PVKey.initialize() );
+ // WriteHandleKey(s)
+ ATH_CHECK( m_OutMETKey.assign(m_outMETCont) );
+ ATH_CHECK( m_OutMETKey.initialize() );
+
return StatusCode::SUCCESS;
}
@@ -233,67 +259,61 @@ namespace met {
{
ATH_MSG_DEBUG ( name() << " in execute...");
- const MissingETComponentMap* metMap = 0;
- if( evtStore()->retrieve(metMap, m_inputMap).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve MissingETComponentMap: " << m_inputMap);
+ SG::ReadHandle<xAOD::MissingETComponentMap> METMap(m_METMapKey);
+ if (!METMap.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve MissingETComponentMap: " << METMap.key());
return StatusCode::SUCCESS;
}
- if( evtStore()->contains<MissingETContainer>(m_outMETCont) ) {
- if(m_warnOfDupes)
- { ATH_MSG_WARNING("MET container " << m_outMETCont << " already in StoreGate"); }
+ SG::ReadHandle<xAOD::MissingETContainer> MET(m_METContainerKey);
+ if (!MET.isPresent()) {
+ if(m_warnOfDupes){
+ ATH_MSG_WARNING("MET container " << MET.key() << " already in StoreGate"); }
return StatusCode::SUCCESS;
}
// Create a MissingETContainer with its aux store
- MissingETContainer* outCont = new MissingETContainer();
- if( evtStore()->record(outCont, m_outMETCont).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETContainer: " << m_outMETCont);
- return StatusCode::SUCCESS;
- }
- MissingETAuxContainer* metAuxCont = new MissingETAuxContainer();
- if( evtStore()->record(metAuxCont, m_outMETCont+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxContainer: " << m_outMETCont+"Aux.");
- return StatusCode::SUCCESS;
- }
- outCont->setStore(metAuxCont);
+ SG::WriteHandle<xAOD::MissingETContainer> OutMET(m_OutMETKey);
+ std::unique_ptr<MissingETContainer> outCont = std::make_unique<xAOD::MissingETContainer>();
+ std::unique_ptr<MissingETAuxContainer> metAuxCont = std::make_unique<xAOD::MissingETAuxContainer>();
+ ATH_CHECK( OutMET.record(std::move(outCont),std::move(metAuxCont) ) );
if(m_doEle) {
if(m_rebuildEle) {
- const xAOD::ElectronContainer* elec = 0;
- if( evtStore()->retrieve(elec, m_eleColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve ElectronContainer: " << m_eleColl);
+ SG::ReadHandle<xAOD::ElectronContainer> Electrons(m_ElectronContainerKey);
+ if (!Electrons.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve ElectronContainer: " << Electrons.key());
return StatusCode::SUCCESS;
}
- ATH_CHECK( rebuildMET(m_eleTerm, outCont, elec, metMap, m_doTracks) );
+ ATH_CHECK( rebuildMET(m_eleTerm, outCont.get(), Electrons.get(), METMap.get(), m_doTracks) );
} else {
- ATH_CHECK( copyMET(m_eleTerm,outCont,metMap) );
+ ATH_CHECK( copyMET(m_eleTerm,outCont.get(),METMap.get()) );
}
}
if(m_doGamma) {
if(m_rebuildGamma) {
- const xAOD::PhotonContainer* gamma = 0;
- if( evtStore()->retrieve(gamma, m_gammaColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve GammaContainer: " << m_gammaColl);
+ SG::ReadHandle<xAOD::PhotonContainer> Gamma(m_PhotonContainerKey);
+ if (!Gamma.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve GammaContainer: " << Gamma.key());
return StatusCode::FAILURE;
}
- ATH_CHECK( rebuildMET(m_gammaTerm, outCont, gamma, metMap, m_doTracks) );
+ ATH_CHECK( rebuildMET(m_gammaTerm, outCont.get(), Gamma.get(), METMap.get(), m_doTracks) );
} else {
- ATH_CHECK( copyMET(m_gammaTerm,outCont,metMap) );
+ ATH_CHECK( copyMET(m_gammaTerm,outCont.get(),METMap.get()) );
}
}
if(m_doTau) {
if(m_rebuildTau) {
- const xAOD::TauJetContainer* taujet = 0;
- if( evtStore()->retrieve(taujet, m_tauColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve TauJetContainer: " << m_tauColl);
+ SG::ReadHandle<xAOD::TauJetContainer> TauJets(m_TauJetContainerKey);
+ if (!TauJets.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve TauJetContainer: " << TauJets.key());
return StatusCode::FAILURE;
}
- ATH_CHECK( rebuildMET(m_tauTerm, outCont, taujet, metMap, m_doTracks) );
+ ATH_CHECK( rebuildMET(m_tauTerm, outCont.get(), TauJets.get(), METMap.get(), m_doTracks) );
} else {
- ATH_CHECK( copyMET(m_tauTerm,outCont,metMap) );
+ ATH_CHECK( copyMET(m_tauTerm,outCont.get(),METMap.get()) );
}
}
@@ -302,28 +322,27 @@ namespace met {
if(m_rebuildMuon) {
// May need implementation of Eloss correction
// Place in separate tool (?)
- const xAOD::MuonContainer* muon = 0;
- if( evtStore()->retrieve(muon, m_muonColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve MuonContainer: " << m_muonColl);
+ SG::ReadHandle<xAOD::MuonContainer> Muons(m_MuonContainerKey);
+ if (!Muons.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve MuonContainer: " << Muons.key());
return StatusCode::FAILURE;
}
- ATH_CHECK( rebuildMET(m_muonTerm, outCont, muon, metMap, m_doTracks) );
+ ATH_CHECK( rebuildMET(m_muonTerm, outCont.get(), Muons.get(), METMap.get(), m_doTracks) );
} else {
- ATH_CHECK( copyMET(m_muonTerm,outCont,metMap) );
+ ATH_CHECK( copyMET(m_muonTerm,outCont.get(),METMap.get()) );
}
}
// Implementation of the jet/soft term rebuilding
// Place in separate tool (?)
- const xAOD::JetContainer* jet = 0;
- if( evtStore()->retrieve(jet, m_jetColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve JetContainer: " << m_jetColl);
+ SG::ReadHandle<xAOD::JetContainer> Jets(m_JetContainerKey);
+ if (!Jets.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve JetContainer: " << Jets.key());
return StatusCode::FAILURE;
}
- ATH_CHECK( rebuildJetMET(m_jetTerm, m_softTerm, outCont, jet, metMap, m_doTracks) );
-
- ATH_CHECK( buildMETSum(m_outMETTerm, outCont) );
+ ATH_CHECK( rebuildJetMET(m_jetTerm, m_softTerm, outCont.get(), Jets.get(), METMap.get(), m_doTracks) );
+ ATH_CHECK( buildMETSum(m_outMETTerm, outCont.get()) );
return StatusCode::SUCCESS;
}
@@ -500,16 +519,24 @@ namespace met {
if(component->size()==0) return StatusCode::SUCCESS;
- const VertexContainer* vtxCont = 0;
+ // const VertexContainer* vtxCont = 0;
+ SG::ReadHandle<xAOD::VertexContainer> PV(m_PVKey);
+
const Vertex* pv = 0;
+
+
if(doJvfCut || (m_trk_doPVsel && doTracks)) {
- if( evtStore()->retrieve( vtxCont, m_vtxColl).isFailure() ) {
+ if (!PV.isValid()) {
ATH_MSG_WARNING("Unable to retrieve input primary vertex container");
+
return StatusCode::FAILURE;
}
- for(const auto& vx : *vtxCont) {
+
+ for(const auto& vx : *PV) {
if(vx->vertexType()==VxType::PriVtx)
+
{pv = vx; break;}
+
}
if(!pv) {
ATH_MSG_WARNING("Event has no primary vertex");
@@ -519,6 +546,7 @@ namespace met {
}
}
+
stvf = 0.;
float trksumpt_allsoft(0.);
if(m_doSTVF) {
diff --git a/Reconstruction/MET/METUtilities/Root/METSystematicsTool.cxx b/Reconstruction/MET/METUtilities/Root/METSystematicsTool.cxx
index a145556a8ca4b990ffa5a63481f367b8cb2801fa..3926f43c7483424c8c995474449d4dbebf379751 100644
--- a/Reconstruction/MET/METUtilities/Root/METSystematicsTool.cxx
+++ b/Reconstruction/MET/METUtilities/Root/METSystematicsTool.cxx
@@ -39,20 +39,22 @@ namespace met {
m_h_calosyst_scale(nullptr),
m_h_calosyst_reso (nullptr),
m_rand(0),
- m_units(-1)
+ m_units(-1),
+ m_VertexContKey(""),
+ m_TruthContKey(""),
+ m_EventInfoKey("")
{
ATH_MSG_DEBUG (__PRETTY_FUNCTION__ );
-
+ declareProperty( "VertexContainer", m_vertexCont = "PrimaryVertices" );
+ declareProperty( "EventInfo", m_eventInfo = "EventInfo" );
+ declareProperty( "TruthContainer", m_truthCont = "MET_Truth" );
+ declareProperty( "TruthObj", m_truthObj = "NonInt" );
declareProperty( "ConfigPrefix", m_configPrefix = "METUtilities/data16_13TeV/rec_Dec16v1");
declareProperty( "ConfigSoftTrkFile", m_configSoftTrkFile = "TrackSoftTerms.config" );
// declareProperty( "ConfigSoftTrkFile", m_configSoftTrkFile = "TrackSoftTerms_afii.config" );//for ATLFAST
declareProperty( "ConfigJetTrkFile", m_configJetTrkFile = "" );
declareProperty( "ConfigSoftCaloFile",m_configSoftCaloFile= "" );
// declareProperty( "ConfigSoftCaloFile",m_configSoftCaloFile= "METRefFinal_Obsolete2012_V2.config" );
- declareProperty( "TruthContainer", m_truthCont = "MET_Truth" );
- declareProperty( "TruthObj", m_truthObj = "NonInt" );
- declareProperty( "VertexContainer", m_vertexCont = "PrimaryVertices" );
- declareProperty( "EventInfo", m_eventInfo = "EventInfo" );
declareProperty( "UseDevArea", m_useDevArea = false );
applySystematicVariation(CP::SystematicSet()).ignore();
@@ -103,6 +105,14 @@ namespace met {
StatusCode METSystematicsTool::initialize()
{
ATH_MSG_VERBOSE (__PRETTY_FUNCTION__ );
+ // ReadHandleKey(s)
+ ATH_CHECK( m_VertexContKey.assign(m_vertexCont) );
+ ATH_CHECK( m_VertexContKey.initialize() );
+ ATH_CHECK( m_TruthContKey.assign(m_truthCont) );
+ ATH_CHECK( m_TruthContKey.initialize() );
+ ATH_CHECK( m_EventInfoKey.assign(m_eventInfo) );
+ ATH_CHECK( m_EventInfoKey.initialize() );
+
const char lastchar = m_configPrefix.back();
if(std::strncmp(&lastchar,"/",1)!=0) {
@@ -702,9 +712,9 @@ namespace met {
ATH_MSG_VERBOSE(__PRETTY_FUNCTION__ );
//get truth container
- xAOD::MissingETContainer const * truthCont = nullptr;
- if(evtStore()->retrieve(truthCont, m_truthCont).isFailure()){
- ATH_MSG_ERROR( m_truthCont << " container empty or does not exist, calcPtHard returning zero.");
+ SG::ReadHandle<xAOD::MissingETContainer> truthCont(m_TruthContKey);
+ if (!truthCont.isValid()) {
+ ATH_MSG_ERROR(m_truthCont<<" container empty or doesn't exist, calcPtHard returning zero.");
return missingEt();
}
@@ -864,20 +874,19 @@ namespace met {
//stolen from JetUncertainties
xAOD::EventInfo const * METSystematicsTool::getDefaultEventInfo() const
{ ATH_MSG_VERBOSE (__PRETTY_FUNCTION__ );
- xAOD::EventInfo const * eInfoConst = nullptr;
- if (evtStore()->retrieve(eInfoConst ,m_eventInfo).isFailure()){
+ SG::ReadHandle<xAOD::EventInfo> eInfoConst(m_EventInfoKey);
+ if (!eInfoConst.isValid()) {
ATH_MSG_ERROR("Failed to retrieve default EventInfo object");
}
-
- return eInfoConst;
+ return &*eInfoConst;
}
int METSystematicsTool::getNPV() const{
ATH_MSG_VERBOSE (__PRETTY_FUNCTION__ );
- const xAOD::VertexContainer* vertices = nullptr;
+ SG::ReadHandle<xAOD::VertexContainer> vertices(m_VertexContKey);
- if (evtStore()->retrieve(vertices,m_vertexCont).isFailure()){
+ if (!vertices.isValid()) {
ATH_MSG_ERROR("Failed to retrieve default NPV value from PrimaryVertices");
return 0;
}
diff --git a/Reconstruction/MET/METUtilities/share/MakeMET.py b/Reconstruction/MET/METUtilities/share/MakeMET.py
index 0d1b59c6a9d8de4171d1a6c29468c008d0b24bf2..8b68965f233e8b2a574378cb32298a1501e3543f 100644
--- a/Reconstruction/MET/METUtilities/share/MakeMET.py
+++ b/Reconstruction/MET/METUtilities/share/MakeMET.py
@@ -1,15 +1,34 @@
+include( "PerfMonGPerfTools/DisablePerfMon_jobOFragment.py" ) #disable performance monitoring when running in MT mode for now
+
import AthenaPoolCnvSvc.ReadAthenaPool
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon import CfgMgr
+from AthenaCommon.ConcurrencyFlags import jobproperties as jp
+nThreads = jp.ConcurrencyFlags.NumThreads()
+nProc = jp.ConcurrencyFlags.NumProcs()
+
+
+from AthenaCommon.AlgSequence import AlgSequence
+topSequence = AlgSequence()
+
+if nThreads>=1:
+ from AthenaCommon.AlgScheduler import AlgScheduler
+ AlgScheduler.OutputLevel( INFO )
+ AlgScheduler.ShowControlFlow( True )
+ AlgScheduler.ShowDataDependencies( True )
+ AlgScheduler.setDataLoaderAlg( 'SGInputLoader' )
+ from SGComps.SGCompsConf import SGInputLoader
+ topSequence+=SGInputLoader(OutputLevel=DEBUG, ShowEventDump=False)
+
from glob import glob
filelist = ["DAOD_JETM2.test.TruthAssoc.pool.root"]
#filelist = ["/afs/cern.ch/work/r/rsmith/public/METUtilities_testfiles/valid1.110401.PowhegPythia_P2012_ttbar_nonallhad.recon.AOD.e3099_s1982_s1964_r6006_tid04628718_00/AOD.04628718._000158.pool.root.1"]
ServiceMgr.EventSelector.InputCollections = filelist
from METUtilities.METMakerConfig import getMETMakerAlg
-metAlg = getMETMakerAlg('AntiKt4EMTopo',20e3)
+metAlg = getMETMakerAlg('AntiKt4EMTopo','Default')
metAlg.METName = 'MET_Reco_AntiKt4EMTopo'
metAlg_truth = getMETMakerAlg('Truth_AntiKt4EMTopo',20e3)
@@ -17,12 +36,10 @@ metAlg_truth.METSoftClName = 'SoftTruthAll'
metAlg_truth.METSoftTrkName = 'SoftTruthCharged'
metAlg_truth.METName = 'MET_Truth_AntiKt4EMTopo'
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence = AlgSequence()
topSequence += metAlg
topSequence += metAlg_truth
-write_xAOD = True
+write_xAOD = False
if write_xAOD:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
xaodStream = MSMgr.NewPoolRootStream( "StreamXAOD", "xAOD.METMaker.pool.root" )
@@ -55,3 +72,17 @@ ServiceMgr.EventSelector.SkipEvents = 0
printint = max(theApp.EvtMax/250,1) if theApp.EvtMax>0 else 1000
svcMgr += CfgMgr.AthenaEventLoopMgr(EventPrintoutInterval=printint)
+
+# set algCardinality = 1 to disable cloning for algs with thread unsafe features
+"""
+algCardinality = nThreads
+if (algCardinality > 1):
+ for alg in topSequence:
+ name = alg.name()
+ print " -> looking at ",name
+ if (name==metAlg.name()):
+ alg.Cardinality = 1
+ print " -> suppressing cloning for ", name
+ else:
+ alg.Cardinality = algCardinality
+"""
\ No newline at end of file
diff --git a/Reconstruction/MET/METUtilities/src/METMakerAlg.cxx b/Reconstruction/MET/METUtilities/src/METMakerAlg.cxx
index 41df6e13b06010e0a6b9c2b5b26fc2ef41023eb7..2f482bdd75f21ed2fe1cfaa8f76411e1c05c6005 100644
--- a/Reconstruction/MET/METUtilities/src/METMakerAlg.cxx
+++ b/Reconstruction/MET/METUtilities/src/METMakerAlg.cxx
@@ -7,17 +7,10 @@
#include "METMakerAlg.h"
#include "METInterface/IMETMaker.h"
-#include "xAODMissingET/MissingETContainer.h"
#include "xAODMissingET/MissingETAuxContainer.h"
#include "xAODMissingET/MissingETComposition.h"
#include "xAODMissingET/MissingETAssociationMap.h"
-#include "xAODJet/JetContainer.h"
-#include "xAODEgamma/ElectronContainer.h"
-#include "xAODEgamma/PhotonContainer.h"
-#include "xAODMuon/MuonContainer.h"
-#include "xAODTau/TauJetContainer.h"
-
#include "MuonSelectorTools/IMuonSelectionTool.h"
#include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
#include "EgammaAnalysisInterfaces/IAsgPhotonIsEMSelector.h"
@@ -37,15 +30,23 @@ namespace met {
METMakerAlg::METMakerAlg(const std::string& name,
ISvcLocator* pSvcLocator )
: ::AthAlgorithm( name, pSvcLocator ),
+ m_ElectronContainerKey(""),
+ m_PhotonContainerKey(""),
+ m_TauJetContainerKey(""),
+ m_MuonContainerKey(""),
+ m_JetContainerKey(""),
+ m_CoreMetKey(""),
+ m_metKey(""),
+ m_metMap("METAssoc"),
m_muonSelTool(""),
m_elecSelLHTool(""),
m_photonSelIsEMTool(""),
m_tauSelTool("")
{
declareProperty( "Maker", m_metmaker );
- declareProperty( "METMapName", m_mapname = "METAssoc" );
declareProperty( "METCoreName", m_corename = "MET_Core" );
- declareProperty( "METName", m_outname = "MET_Reference" );
+ declareProperty("METName", m_metKey = std::string("MET_Reference"),"MET container");
+ declareProperty("METMapName", m_metMap );
declareProperty( "METSoftClName", m_softclname = "SoftClus" );
declareProperty( "METSoftTrkName", m_softtrkname = "PVSoftTrk" );
@@ -100,6 +101,19 @@ namespace met {
ATH_MSG_ERROR("Failed to retrieve tool: " << m_tauSelTool->name());
return StatusCode::FAILURE;
};
+ ATH_CHECK( m_ElectronContainerKey.assign(m_eleColl) );
+ ATH_CHECK( m_ElectronContainerKey.initialize() );
+ ATH_CHECK( m_PhotonContainerKey.assign(m_gammaColl) );
+ ATH_CHECK( m_PhotonContainerKey.initialize() );
+ ATH_CHECK( m_TauJetContainerKey.assign(m_tauColl) );
+ ATH_CHECK( m_TauJetContainerKey.initialize() );
+ ATH_CHECK( m_MuonContainerKey.assign(m_muonColl) );
+ ATH_CHECK( m_MuonContainerKey.initialize() );
+ ATH_CHECK( m_JetContainerKey.assign(m_jetColl) );
+ ATH_CHECK( m_JetContainerKey.initialize() );
+ ATH_CHECK( m_CoreMetKey.assign(m_corename) );
+ ATH_CHECK( m_CoreMetKey.initialize() );
+ ATH_CHECK( m_metKey.initialize() );
return StatusCode::SUCCESS;
}
@@ -117,80 +131,59 @@ namespace met {
ATH_MSG_VERBOSE("Executing " << name() << "...");
// Create a MissingETContainer with its aux store
- MissingETContainer* newMet = new MissingETContainer();
- if( evtStore()->record(newMet, m_outname).isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETContainer: " << m_outname);
- return StatusCode::SUCCESS;
- }
- MissingETAuxContainer* metAuxCont = new MissingETAuxContainer();
- if( evtStore()->record(metAuxCont, m_outname+"Aux.").isFailure() ) {
- ATH_MSG_WARNING("Unable to record MissingETAuxContainer: " << m_outname+"Aux.");
- return StatusCode::SUCCESS;
- }
- newMet->setStore(metAuxCont);
+ auto ctx = getContext();
+ auto metHandle= SG::makeHandle (m_metKey,ctx);
+ ATH_CHECK( metHandle.record (std::make_unique<xAOD::MissingETContainer>(), std::make_unique<xAOD::MissingETAuxContainer>()) );
+ xAOD::MissingETContainer* newMet=metHandle.ptr();
- const MissingETAssociationMap* metMap = 0;
- if( evtStore()->retrieve(metMap, m_mapname).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_mapname);
- return StatusCode::SUCCESS;
- }
+ ATH_CHECK( m_metMap.isValid() );
+
+ MissingETAssociationMap* metMap = new MissingETAssociationMap((*m_metMap));
metMap->resetObjSelectionFlags();
// Retrieve containers ***********************************************
/// MET
- const MissingETContainer* coreMet(0);
- if( evtStore()->retrieve(coreMet, m_corename).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve MissingETContainer: " << m_corename);
- return StatusCode::SUCCESS;
+ SG::ReadHandle<xAOD::MissingETContainer> coreMet(m_CoreMetKey);
+ if (!coreMet.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve MissingETContainer: " << m_CoreMetKey.key());
+ return StatusCode::FAILURE;
}
+
/// Jets
- const JetContainer* jetCont(0);
- if( evtStore()->retrieve(jetCont, m_jetColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input jet container: " << m_jetColl);
- return StatusCode::SUCCESS;
+ SG::ReadHandle<xAOD::JetContainer> Jets(m_JetContainerKey);
+ if (!Jets.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve JetContainer: " << Jets.key());
+ return StatusCode::FAILURE;
}
- ATH_MSG_DEBUG("Successfully retrieved jet collection");
/// Electrons
- const ElectronContainer* elCont(0);
- if(!m_eleColl.empty()) {
- if( evtStore()->retrieve(elCont, m_eleColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input electron container: " << m_eleColl);
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved electron collection");
+ SG::ReadHandle<xAOD::ElectronContainer> Electrons(m_ElectronContainerKey);
+ if (!Electrons.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve ElectronContainer: " << Electrons.key());
+ return StatusCode::SUCCESS;
}
/// Photons
- const PhotonContainer* phCont(0);
- if(!m_gammaColl.empty()) {
- if( evtStore()->retrieve(phCont, m_gammaColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input photon container: " << m_gammaColl);
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved photon collection");
+ SG::ReadHandle<xAOD::PhotonContainer> Gamma(m_PhotonContainerKey);
+ if (!Gamma.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve GammaContainer: " << Gamma.key());
+ return StatusCode::FAILURE;
}
/// Taus
- const TauJetContainer* tauCont(0);
- if(!m_tauColl.empty()) {
- if( evtStore()->retrieve(tauCont, m_tauColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input tau container: " << m_tauColl);
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved tau collection");
+ SG::ReadHandle<xAOD::TauJetContainer> TauJets(m_TauJetContainerKey);
+ if (!TauJets.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve TauJetContainer: " << TauJets.key());
+ return StatusCode::FAILURE;
}
/// Muons
- const MuonContainer* muonCont(0);
- if(!m_muonColl.empty()) {
- if( evtStore()->retrieve(muonCont, m_muonColl).isFailure() ) {
- ATH_MSG_WARNING("Unable to retrieve input muon container: " << m_muonColl);
- return StatusCode::SUCCESS;
- }
- ATH_MSG_DEBUG("Successfully retrieved muon collection");
+ SG::ReadHandle<xAOD::MuonContainer> Muons(m_MuonContainerKey);
+ if (!Muons.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve MuonContainer: " << Muons.key());
+ return StatusCode::FAILURE;
}
// Select and flag objects for final MET building ***************************
@@ -200,9 +193,10 @@ namespace met {
// Electrons
if(!m_eleColl.empty()) {
ConstDataVector<ElectronContainer> metElectrons(SG::VIEW_ELEMENTS);
- for(const auto& el : *elCont) {
+ for(const auto& el : *Electrons) {
if(accept(el)) {
metElectrons.push_back(el);
+
}
}
if( m_metmaker->rebuildMET("RefEle", xAOD::Type::Electron, newMet,
@@ -217,7 +211,7 @@ namespace met {
// Photons
if(!m_gammaColl.empty()) {
ConstDataVector<PhotonContainer> metPhotons(SG::VIEW_ELEMENTS);
- for(const auto& ph : *phCont) {
+ for(const auto& ph : *Gamma) {
if(accept(ph)) {
metPhotons.push_back(ph);
}
@@ -234,7 +228,7 @@ namespace met {
// Taus
if(!m_tauColl.empty()) {
ConstDataVector<TauJetContainer> metTaus(SG::VIEW_ELEMENTS);
- for(const auto& tau : *tauCont) {
+ for(const auto& tau : *TauJets) {
if(accept(tau)) {
metTaus.push_back(tau);
}
@@ -251,7 +245,7 @@ namespace met {
// Muons
if(!m_muonColl.empty()) {
ConstDataVector<MuonContainer> metMuons(SG::VIEW_ELEMENTS);
- for(const auto& mu : *muonCont) {
+ for(const auto& mu : *Muons) {
if(accept(mu)) {
metMuons.push_back(mu);
}
@@ -268,10 +262,10 @@ namespace met {
}
if( m_metmaker->rebuildJetMET("RefJet", m_softclname, m_softtrkname, newMet,
- jetCont, coreMet, metMap, false ).isFailure() ) {
+ Jets.cptr(), coreMet.cptr(), metMap, false ).isFailure() ) {
ATH_MSG_WARNING("Failed to build jet and soft terms.");
}
- ATH_MSG_DEBUG("Of " << jetCont->size() << " jets, "
+ ATH_MSG_DEBUG("Of " << Jets.cptr()->size() << " jets, "
<< acc_constitObjLinks(*(*newMet)["RefJet"]).size() << " are non-overlapping, "
<< acc_constitObjLinks(*(*newMet)[m_softtrkname]).size() << " are soft");
@@ -310,6 +304,9 @@ namespace met {
}
bool METMakerAlg::accept(const xAOD::TauJet* tau)
- { return m_tauSelTool->accept( *tau ); }
+ {
+ // std::cout<<"Just checking this works -> tau pt is "<<tau->pt()<<std::endl;
+
+ return m_tauSelTool->accept( *tau ); }
}
diff --git a/Reconstruction/MET/METUtilities/src/METMakerAlg.h b/Reconstruction/MET/METUtilities/src/METMakerAlg.h
index a7d4d7bf202d1893c820133e0e96b4d1a55618ec..c1c357afc3b1418114acc15b5dc28d17160fa909 100644
--- a/Reconstruction/MET/METUtilities/src/METMakerAlg.h
+++ b/Reconstruction/MET/METUtilities/src/METMakerAlg.h
@@ -11,12 +11,23 @@
#include "AthenaBaseComps/AthAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/DataHandle.h"
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/Photon.h"
#include "xAODMuon/Muon.h"
#include "xAODTau/TauJet.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODEgamma/ElectronContainer.h"
+#include "xAODEgamma/PhotonContainer.h"
+#include "xAODTau/TauJetContainer.h"
+
+#include "xAODMissingET/MissingETContainer.h"
+#include "xAODMissingET/MissingETAssociationMap.h"
+
+
class IMETMaker;
class IAsgElectronLikelihoodTool;
class IAsgPhotonIsEMSelector;
@@ -53,19 +64,30 @@ namespace met {
bool accept(const xAOD::TauJet* tau);
bool accept(const xAOD::Muon* muon);
- std::string m_mapname;
std::string m_corename;
- std::string m_outname;
std::string m_softclname;
std::string m_softtrkname;
- std::string m_jetColl;
+ //In release 21 need to replace the names of the containers by the appropriate data handles
+ SG::ReadHandleKey<xAOD::ElectronContainer> m_ElectronContainerKey;
+ SG::ReadHandleKey<xAOD::PhotonContainer> m_PhotonContainerKey;
+ SG::ReadHandleKey<xAOD::TauJetContainer> m_TauJetContainerKey;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_MuonContainerKey;
+ SG::ReadHandleKey<xAOD::JetContainer> m_JetContainerKey;
+
+ SG::ReadHandleKey<xAOD::MissingETContainer> m_CoreMetKey;
+
std::string m_eleColl;
std::string m_gammaColl;
std::string m_tauColl;
+ std::string m_jetColl;
std::string m_muonColl;
+ SG::WriteHandleKey<xAOD::MissingETContainer> m_metKey;
+ SG::ReadHandle<xAOD::MissingETAssociationMap> m_metMap;
+
+
bool m_doTruthLep;
/// Athena configured tools