ATLAS Offline Software
Loading...
Searching...
No Matches
DerivationFramework::Reco_mumu Class Reference

#include <Reco_mumu.h>

Inheritance diagram for DerivationFramework::Reco_mumu:
Collaboration diagram for DerivationFramework::Reco_mumu:

Public Member Functions

 Reco_mumu (const std::string &t, const std::string &n, const IInterface *p)
StatusCode initialize () override
StatusCode addBranches (const EventContext &ctx) const override

Private Attributes

ToolHandle< Trk::V0Toolsm_v0Tools {this, "V0Tools", "Trk::V0Tools"}
 tools
ToolHandle< Analysis::ICandidateSearchm_jpsiFinder {this,"JpsiFinder", "Analysis::JpsiFinder"}
ToolHandle< Analysis::PrimaryVertexRefitterm_pvRefitter {this, "PVRefitter", "Analysis::PrimaryVertexRefitter"}
SG::ReadHandleKey< xAOD::EventInfom_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
Gaudi::Property< bool > m_refitPV {this, "RefitPV", false}
Gaudi::Property< int > m_PV_max {this, "MaxPVrefit", 1}
Gaudi::Property< int > m_DoVertexType {this, "DoVertexType", 1}
Gaudi::Property< unsigned int > m_PV_minNTracks {this, "MinNTracksInPV", 0}
Gaudi::Property< bool > m_do3d {this, "Do3d" , false}
Gaudi::Property< bool > m_checkCollections {this, "CheckCollections", false}
SG::ReadHandleKeyArray< xAOD::VertexContainerm_CollectionsToCheck {this, "CheckVertexContainers", {}}
SG::ReadHandleKey< xAOD::VertexContainerm_pvContainerKey {this,"PVContainerName", "PrimaryVertices"}
SG::WriteHandleKey< xAOD::VertexContainerm_refContainerKey {this, "RefPVContainerName","RefittedPrimaryVertices" }
SG::WriteHandleKey< xAOD::VertexContainerm_outContainerKey {this, "OutputVtxContainerName", "OniaCandidates"}

Detailed Description

Definition at line 27 of file Reco_mumu.h.

Constructor & Destructor Documentation

◆ Reco_mumu()

DerivationFramework::Reco_mumu::Reco_mumu ( const std::string & t,
const std::string & n,
const IInterface * p )

Definition at line 22 of file Reco_mumu.cxx.

24 :
25 base_class(t,n,p) {
26 }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::Reco_mumu::addBranches ( const EventContext & ctx) const
override

Definition at line 58 of file Reco_mumu.cxx.

59 {
60 bool callJpsiFinder = true;
62 for( SG::ReadHandle<xAOD::VertexContainer> vertContainer : m_CollectionsToCheck.makeHandles(ctx)){
63 if (!vertContainer.isValid()){
64 ATH_MSG_FATAL("Failed to retrieve "<<vertContainer.key());
65 return StatusCode::FAILURE;
66 }
67 if(vertContainer->size() == 0) {
68 callJpsiFinder = false;
69 ATH_MSG_DEBUG("Container VertexContainer (" << vertContainer.key() << ") is empty");
70 break;//No point checking other containers
71 }
72 }
73 }
74
75 // Jpsi container and its auxilliary store
76 std::unique_ptr<xAOD::VertexContainer> vtxContainer = std::make_unique<xAOD::VertexContainer>();
77 std::unique_ptr<xAOD::VertexAuxContainer> vtxAuxContainer = std::make_unique<xAOD::VertexAuxContainer>();
78 vtxContainer->setStore(vtxAuxContainer.get());
79
80 std::unique_ptr<xAOD::VertexContainer> refPvContainer =std::make_unique<xAOD::VertexContainer>();
81 std::unique_ptr<xAOD::VertexAuxContainer> refPvAuxContainer = std::make_unique<xAOD::VertexAuxContainer>();
82 refPvContainer->setStore(refPvAuxContainer.get());
83
84
85 if(callJpsiFinder) {
86 //----------------------------------------------------
87 // call Jpsi finder
88 //----------------------------------------------------
89 ATH_CHECK(m_jpsiFinder->performSearch(ctx, *vtxContainer));
90
91 //----------------------------------------------------
92 // retrieve primary vertices
93 //----------------------------------------------------
94 SG::ReadHandle<xAOD::VertexContainer> pvContainer{m_pvContainerKey,ctx};
95 if (!pvContainer.isValid()){
96 ATH_MSG_FATAL("Failed to retrieve "<<m_pvContainerKey.fullKey());
97 return StatusCode::FAILURE;
98 }
99 //----------------------------------------------------
100 // Try to retrieve refitted primary vertices
101 //----------------------------------------------------
102
103 // Give the helper class the ptr to v0tools and beamSpotsSvc to use
104 SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key, ctx);
105 if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_eventInfo_key.key() );
106
107 // Give the helper class the ptr to v0tools and beamSpotsSvc to use
108 BPhysPVTools helper(&(*m_v0Tools), evt.cptr());
109 helper.SetMinNTracksInPV(m_PV_minNTracks);
110 helper.SetSave3d(m_do3d);
111
112 if(m_refitPV && vtxContainer->size()){
113 ATH_CHECK(helper.FillCandwithRefittedVertices(vtxContainer.get(), pvContainer.cptr(), refPvContainer.get(), &(*m_pvRefitter) , m_PV_max, m_DoVertexType));
114 }else if (!m_refitPV && vtxContainer->size()){
115 ATH_CHECK(helper.FillCandExistingVertices(vtxContainer.get(), pvContainer.cptr(), m_DoVertexType));
116 }
117 }
118 //----------------------------------------------------
119 // save in the StoreGate
120 //----------------------------------------------------
121 SG::WriteHandle<xAOD::VertexContainer> out_handle{m_outContainerKey, ctx};
122 ATH_CHECK(out_handle.record(std::move(vtxContainer), std::move(vtxAuxContainer)));
123 if(m_refitPV) {
124 SG::WriteHandle<xAOD::VertexContainer> refitHandle{m_refContainerKey,ctx};
125 ATH_CHECK(refitHandle.record(std::move(refPvContainer), std::move(refPvAuxContainer)));
126 }
127
128 return StatusCode::SUCCESS;
129 }
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_ERROR(x)
#define ATH_MSG_FATAL(x)
#define ATH_MSG_DEBUG(x)
SG::ReadHandleKey< xAOD::VertexContainer > m_pvContainerKey
Definition Reco_mumu.h:54
Gaudi::Property< bool > m_checkCollections
Definition Reco_mumu.h:51
ToolHandle< Analysis::ICandidateSearch > m_jpsiFinder
Definition Reco_mumu.h:39
Gaudi::Property< int > m_PV_max
Definition Reco_mumu.h:47
Gaudi::Property< bool > m_do3d
Definition Reco_mumu.h:50
SG::WriteHandleKey< xAOD::VertexContainer > m_outContainerKey
Definition Reco_mumu.h:57
Gaudi::Property< unsigned int > m_PV_minNTracks
Definition Reco_mumu.h:49
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
Definition Reco_mumu.h:40
SG::ReadHandleKeyArray< xAOD::VertexContainer > m_CollectionsToCheck
Definition Reco_mumu.h:53
Gaudi::Property< bool > m_refitPV
Definition Reco_mumu.h:46
SG::WriteHandleKey< xAOD::VertexContainer > m_refContainerKey
Definition Reco_mumu.h:56
ToolHandle< Trk::V0Tools > m_v0Tools
tools
Definition Reco_mumu.h:38
Gaudi::Property< int > m_DoVertexType
Definition Reco_mumu.h:48
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition Reco_mumu.h:41
virtual bool isValid() override final
Can the handle be successfully dereferenced?
const_pointer_type cptr()
Dereference the pointer.
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.

◆ initialize()

StatusCode DerivationFramework::Reco_mumu::initialize ( )
override

Definition at line 30 of file Reco_mumu.cxx.

31 {
32
33 ATH_MSG_DEBUG("in initialize()");
34
35 // retrieve V0 tools
36 CHECK( m_v0Tools.retrieve() );
37
38 // get the JpsiFinder tool
39 CHECK( m_jpsiFinder.retrieve() );
40
41 // get the PrimaryVertexRefitter tool
42 CHECK( m_pvRefitter.retrieve() );
43
44 // Get the beam spot service
45 CHECK( m_eventInfo_key.initialize() );
46
47 ATH_CHECK(m_CollectionsToCheck.initialize());
48 ATH_CHECK(m_pvContainerKey.initialize());
49 ATH_CHECK(m_outContainerKey.initialize());
51 return StatusCode::SUCCESS;
52 }
#define CHECK(...)
Evaluate an expression and check for errors.

Member Data Documentation

◆ m_checkCollections

Gaudi::Property<bool> DerivationFramework::Reco_mumu::m_checkCollections {this, "CheckCollections", false}
private

Definition at line 51 of file Reco_mumu.h.

51{this, "CheckCollections", false};

◆ m_CollectionsToCheck

SG::ReadHandleKeyArray<xAOD::VertexContainer> DerivationFramework::Reco_mumu::m_CollectionsToCheck {this, "CheckVertexContainers", {}}
private

Definition at line 53 of file Reco_mumu.h.

53{this, "CheckVertexContainers", {}};

◆ m_do3d

Gaudi::Property<bool> DerivationFramework::Reco_mumu::m_do3d {this, "Do3d" , false}
private

Definition at line 50 of file Reco_mumu.h.

50{this, "Do3d" , false};

◆ m_DoVertexType

Gaudi::Property<int> DerivationFramework::Reco_mumu::m_DoVertexType {this, "DoVertexType", 1}
private

Definition at line 48 of file Reco_mumu.h.

48{this, "DoVertexType", 1};

◆ m_eventInfo_key

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::Reco_mumu::m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
private

Definition at line 41 of file Reco_mumu.h.

41{this, "EventInfo", "EventInfo", "Input event information"};

◆ m_jpsiFinder

ToolHandle<Analysis::ICandidateSearch> DerivationFramework::Reco_mumu::m_jpsiFinder {this,"JpsiFinder", "Analysis::JpsiFinder"}
private

Definition at line 39 of file Reco_mumu.h.

39{this,"JpsiFinder", "Analysis::JpsiFinder"};

◆ m_outContainerKey

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_mumu::m_outContainerKey {this, "OutputVtxContainerName", "OniaCandidates"}
private

Definition at line 57 of file Reco_mumu.h.

57{this, "OutputVtxContainerName", "OniaCandidates"};

◆ m_PV_max

Gaudi::Property<int> DerivationFramework::Reco_mumu::m_PV_max {this, "MaxPVrefit", 1}
private

Definition at line 47 of file Reco_mumu.h.

47{this, "MaxPVrefit", 1};

◆ m_PV_minNTracks

Gaudi::Property<unsigned int> DerivationFramework::Reco_mumu::m_PV_minNTracks {this, "MinNTracksInPV", 0}
private

Definition at line 49 of file Reco_mumu.h.

49{this, "MinNTracksInPV", 0};

◆ m_pvContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_mumu::m_pvContainerKey {this,"PVContainerName", "PrimaryVertices"}
private

Definition at line 54 of file Reco_mumu.h.

54{this,"PVContainerName", "PrimaryVertices"};

◆ m_pvRefitter

ToolHandle<Analysis::PrimaryVertexRefitter> DerivationFramework::Reco_mumu::m_pvRefitter {this, "PVRefitter", "Analysis::PrimaryVertexRefitter"}
private

Definition at line 40 of file Reco_mumu.h.

40{this, "PVRefitter", "Analysis::PrimaryVertexRefitter"};

◆ m_refContainerKey

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_mumu::m_refContainerKey {this, "RefPVContainerName","RefittedPrimaryVertices" }
private

Definition at line 56 of file Reco_mumu.h.

56{this, "RefPVContainerName","RefittedPrimaryVertices" };

◆ m_refitPV

Gaudi::Property<bool> DerivationFramework::Reco_mumu::m_refitPV {this, "RefitPV", false}
private

Definition at line 46 of file Reco_mumu.h.

46{this, "RefitPV", false};

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::Reco_mumu::m_v0Tools {this, "V0Tools", "Trk::V0Tools"}
private

tools

Definition at line 38 of file Reco_mumu.h.

38{this, "V0Tools", "Trk::V0Tools"};

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