ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
DerivationFramework::BPhysBGammaFinder Class Reference

#include <BPhysBGammaFinder.h>

Inheritance diagram for DerivationFramework::BPhysBGammaFinder:
Collaboration diagram for DerivationFramework::BPhysBGammaFinder:

Public Member Functions

 BPhysBGammaFinder (const std::string &t, const std::string &n, const IInterface *p)
StatusCode initialize () override
StatusCode finalize () override
virtual StatusCode addBranches (const EventContext &ctx) const override
TVector3 trackMomentum (const xAOD::Vertex *vxCandidate, int trkIndex) const

Private Attributes

std::vector< std::string > m_BVertexCollectionsToCheck
std::vector< std::string > m_passFlagsToCheck
ToolHandle< Trk::V0Tools > m_v0Tools
ToolHandle< Trk::IVertexFitter > m_vertexFitter
ToolHandle< InDet::VertexPointEstimator > m_vertexEstimator
std::string m_inputTrackParticleContainerName
std::string m_inputLowPtTrackContainerName
std::string m_conversionContainerName
float m_maxDistBetweenTracks
float m_maxDeltaCotTheta
bool m_requireDeltaQ
bool m_use_low_pT
float m_maxDeltaQ
float m_Chi2Cut
float m_maxGammaMass

Detailed Description

Definition at line 43 of file BPhysBGammaFinder.h.

Constructor & Destructor Documentation

◆ BPhysBGammaFinder()

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

Definition at line 20 of file BPhysBGammaFinder.cxx.

21 : base_class(t,n,p),
22 m_v0Tools("Trk::V0Tools"),
23 m_vertexFitter("Trk::TrkVKalVrtFitter"),
24 m_vertexEstimator("InDet::VertexPointEstimator"),
25 m_inputTrackParticleContainerName("InDetTrackParticles"),
26 m_inputLowPtTrackContainerName("LowPtRoITrackParticles"),
27 m_conversionContainerName("BPhysConversionCandidates"),
28 m_maxDistBetweenTracks(10.0),
29 m_maxDeltaCotTheta(0.3),
30 m_requireDeltaQ(true),
31 m_use_low_pT(false),
32 m_maxDeltaQ(1000.0),
33 m_Chi2Cut(20.0),
34 m_maxGammaMass(100.0) {
35
36
37 // Declare user-defined properties
38 declareProperty("BVertexContainers", m_BVertexCollectionsToCheck);
39 declareProperty("PassFlagsToCheck", m_passFlagsToCheck);
40 declareProperty("V0Tools", m_v0Tools);
41 declareProperty("VertexFitterTool", m_vertexFitter);
42 declareProperty("VertexEstimator", m_vertexEstimator);
43 declareProperty("InputTrackParticleContainerName", m_inputTrackParticleContainerName);
44 declareProperty("InputLowPtTrackContainerName", m_inputLowPtTrackContainerName);
45 declareProperty("ConversionContainerName", m_conversionContainerName);
46 declareProperty("MaxDistBetweenTracks", m_maxDistBetweenTracks = 10.0); // Maximum allowed distance of minimum approach
47 declareProperty("MaxDeltaCotTheta", m_maxDeltaCotTheta = 0.3); // Maximum allowed dCotTheta between tracks
48 declareProperty("RequireDeltaQ", m_requireDeltaQ = true); // Only save a conversions if it's a chi_c,b candidate (must then pass "MaxDeltaM" requirement), if "False" all conversions in the event will be saved
49 declareProperty("Use_low_pT", m_use_low_pT = false); // Only save a conversions if it's a chi_c,b candidate (must then pass "MaxDeltaM" requirement), if "False" all conversions in the event will be saved
50 declareProperty("MaxDeltaQ", m_maxDeltaQ = 700.0); // Maximum mass difference between di-muon+conversion and di-muon
51 declareProperty("Chi2Cut", m_Chi2Cut = 20.0);
52 declareProperty("MaxGammaMass", m_maxGammaMass = 100.0);
53}
DerivationFramework::BPhysBGammaFinder::m_vertexFitter
ToolHandle< Trk::IVertexFitter > m_vertexFitter
Definition BPhysBGammaFinder.h:61
DerivationFramework::BPhysBGammaFinder::m_passFlagsToCheck
std::vector< std::string > m_passFlagsToCheck
Definition BPhysBGammaFinder.h:58
DerivationFramework::BPhysBGammaFinder::m_BVertexCollectionsToCheck
std::vector< std::string > m_BVertexCollectionsToCheck
Definition BPhysBGammaFinder.h:57
DerivationFramework::BPhysBGammaFinder::m_vertexEstimator
ToolHandle< InDet::VertexPointEstimator > m_vertexEstimator
Definition BPhysBGammaFinder.h:62

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::BPhysBGammaFinder::addBranches ( const EventContext & ctx) const
overridevirtual

Definition at line 72 of file BPhysBGammaFinder.cxx.

72 {
73
74 std::vector<const xAOD::Vertex*> BVertices;
75 BVertices.clear();
76 std::vector<const xAOD::TrackParticle*> BVertexTracks;
77
78
79 // Output conversion container
80 std::unique_ptr<xAOD::VertexContainer> conversionContainer(new xAOD::VertexContainer());
81 std::unique_ptr<xAOD::VertexAuxContainer> conversionAuxContainer(new xAOD::VertexAuxContainer());
82 conversionContainer->setStore(conversionAuxContainer.get());
83
84 // Retrieve track particles from StoreGate
85 const xAOD::TrackParticleContainer* inputTrackParticles{};
86 ATH_CHECK( evtStore()->retrieve(inputTrackParticles, m_inputTrackParticleContainerName)); // FIXME Use Handles
87 ATH_MSG_DEBUG( "Track particle container size " << inputTrackParticles->size() );
88 // Low pT collection
89 const xAOD::TrackParticleContainer* lowPtTrackParticles{};
90 if (m_use_low_pT) {
91 StatusCode sc = evtStore()->retrieve(lowPtTrackParticles, m_inputLowPtTrackContainerName); // FIXME Use Handles
92 if (sc.isFailure()) {
93 ATH_MSG_WARNING("No low pT collection with key " << m_inputLowPtTrackContainerName << " found in StoreGate.");
94 return StatusCode::SUCCESS;;
95 }
96 else {
97 ATH_MSG_DEBUG("Low pT track particle container size " << lowPtTrackParticles->size());
98 }
99 }
100
101 // Look for B candidate
102 if (m_BVertexCollectionsToCheck.empty()) {
103 ATH_MSG_FATAL( "No B vertex collections provided" );
104 return StatusCode::FAILURE;
105 }
106 else {
107 for ( auto itr = m_BVertexCollectionsToCheck.begin(); itr != m_BVertexCollectionsToCheck.end(); ++itr) {
108 ATH_MSG_DEBUG( "Using " << *itr << " as the source B vertex collection" );
109 }
110 }
111
112 // Retrieve vertex containers
113 for (auto itr = m_BVertexCollectionsToCheck.begin(); itr!=m_BVertexCollectionsToCheck.end(); ++itr) {
114 // retieve vertex
115 const xAOD::VertexContainer* BVtxContainer{};
116 CHECK( evtStore()->retrieve(BVtxContainer, *itr)); // FIXME Use Handles
117 ATH_MSG_DEBUG( "Vertex Container (" << *itr << ") contains " << BVtxContainer->size() << " vertices" );
118
119 static const SG::Decorator< std::vector< VertexLink > > BGammaLinks( "BGammaLinks" );
120 static const std::vector< VertexLink > vertexLinks;
121
122 for (const xAOD::Vertex* vertex : *BVtxContainer) {
123 BGammaLinks(*vertex) = vertexLinks;
124
125 bool passedHypothesis = false;
126 BVertexTracks.clear();
127
128 for (const auto &flag : m_passFlagsToCheck) {
129 SG::ConstAccessor<Char_t> acc(flag);
130 bool pass = acc(*vertex);
131 if (pass) passedHypothesis = true;
132 }
133
134 if (!passedHypothesis) continue;
135 xAOD::BPhysHypoHelper Bc("Bc", vertex);
136
137 // link to Bc+ vertex
138 std::vector<const xAOD::Vertex*> precedingVertices(1, vertex);
139
140 // Collect up B-vertex tracks
141 for (size_t i = 0; i < vertex->nTrackParticles(); ++i) BVertexTracks.push_back(vertex->trackParticle(i));
142
143 // Track Selection
144 // Track1 Loop
145 for (xAOD::TrackParticleContainer::const_iterator tpIt1 = inputTrackParticles->begin(); tpIt1 != inputTrackParticles->end(); ++tpIt1) {
146 const xAOD::TrackParticle* trackParticle1 = *tpIt1;
147
148 auto itr1 = std::find(BVertexTracks.begin(), BVertexTracks.end(), trackParticle1);
149 if (itr1 != BVertexTracks.end()) continue;
150
151 const Trk::Perigee& trackPerigee1 = trackParticle1->perigeeParameters();
152
153 // Track2 Loop
154 for (xAOD::TrackParticleContainer::const_iterator tpIt2 = tpIt1 + 1; tpIt2 != inputTrackParticles->end(); ++tpIt2) {
155 const xAOD::TrackParticle* trackParticle2 = *tpIt2;
156 if (trackParticle1 == trackParticle2) continue;
157
158 auto itr2 = std::find(BVertexTracks.begin(), BVertexTracks.end(), trackParticle2);
159 if (itr2 != BVertexTracks.end()) continue;
160
161 const Trk::Perigee& trackPerigee2 = trackParticle2->perigeeParameters();
162
163 // Track pair selection
164 TLorentzVector e1, e2, gamma_m, BcStar;
165 e1.SetPtEtaPhiM(trackParticle1->pt(), trackParticle1->eta(), trackParticle1->phi(), Trk::electron);
166 e2.SetPtEtaPhiM(trackParticle2->pt(), trackParticle2->eta(), trackParticle2->phi(), Trk::electron);
167
168 gamma_m = e1 + e2;
169 if (gamma_m.M() > m_maxGammaMass) continue;
170
171 TLorentzVector mu1 = Bc.refTrk(0, Trk::muon);
172 TLorentzVector mu2 = Bc.refTrk(1, Trk::muon);
173 TLorentzVector mu3 = Bc.refTrk(2, Trk::muon);
174
175 BcStar = mu1 + mu2 + mu3 + e1 + e2;
176 double Q = BcStar.M() - Bc.mass() - 2 * Trk::electron;
177 if (Q > m_maxDeltaQ) continue;
178
179 // Estimate starting point + cuts on compatiblity of tracks
180 int sflag = 0;
181 int errorcode = 0;
182 Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&trackPerigee1, &trackPerigee2, sflag, errorcode);
183 if (errorcode != 0) startingPoint = Amg::Vector3D::Zero(3);
184
185 std::vector<float> RefTrackPx, RefTrackPy, RefTrackPz, RefTrackE;
186 std::vector<float> OrigTrackPx, OrigTrackPy, OrigTrackPz, OrigTrackE;
187
188 std::vector<const xAOD::TrackParticle*> trackPair;
189 trackPair.clear();
190 trackPair.push_back(trackParticle1);
191 trackPair.push_back(trackParticle2);
192
193 // Do the vertex fit
194 xAOD::Vertex* convVertexCandidate = m_vertexFitter->fit(trackPair, startingPoint);
195
196 // Check for successful fit
197 if (convVertexCandidate) {
198 if (convVertexCandidate->chiSquared() / convVertexCandidate->numberDoF() > m_Chi2Cut) continue;
199
200 xAOD::BPhysHelper Photon(convVertexCandidate);
201 // set link to the parent Bc+ vertex
202 Photon.setPrecedingVertices(precedingVertices, BVtxContainer);
203
204 // Parameters at vertex
205 convVertexCandidate->clearTracks();
206 ElementLink<xAOD::TrackParticleContainer> newLink1;
207 newLink1.setElement(*tpIt1);
208 newLink1.setStorableObject(*inputTrackParticles);
209 ElementLink<xAOD::TrackParticleContainer> newLink2;
210 newLink2.setElement(*tpIt2);
211 newLink2.setStorableObject(*inputTrackParticles);
212 convVertexCandidate->addTrackAtVertex(newLink1);
213 convVertexCandidate->addTrackAtVertex(newLink2);
214
215 std::vector<Amg::Vector3D> positionList;
216
217 //Get photon momentum 3-vector
218 Amg::Vector3D momentum = m_v0Tools->V0Momentum(convVertexCandidate);
219
220 TLorentzVector photon, electron1, electron2, ph;
221 electron1.SetVectM( trackMomentum( convVertexCandidate, 0 ), Trk::electron );
222 electron2.SetVectM( trackMomentum( convVertexCandidate, 1 ), Trk::electron );
223 photon = electron1 + electron2;
224 ph.SetXYZM(momentum.x(), momentum.y(), momentum.z(), 0.);
225
226 // Use to keep track of which dimuon(s) gave a chi_c/b candidate
227 static const SG::Accessor<std::vector<float> > RefTrackPxAcc("RefTrackPx");
228 static const SG::Accessor<std::vector<float> > RefTrackPyAcc("RefTrackPy");
229 static const SG::Accessor<std::vector<float> > RefTrackPzAcc("RefTrackPz");
230 std::vector<float> B_Px = RefTrackPxAcc(*vertex);
231 std::vector<float> B_Py = RefTrackPyAcc(*vertex);
232 std::vector<float> B_Pz = RefTrackPzAcc(*vertex);
233
234 TLorentzVector muon1, muon2, muon3;
235 muon1.SetXYZM(B_Px.at(0), B_Py.at(0), B_Pz.at(0), Trk::muon);
236 muon2.SetXYZM(B_Px.at(1), B_Py.at(1), B_Pz.at(1), Trk::muon);
237 muon3.SetXYZM(B_Px.at(2), B_Py.at(2), B_Pz.at(2), Trk::muon);
238
239 TLorentzVector B_m = muon1 + muon2 + muon3;
240
241 const double deltaQ = (B_m + photon).M() - Bc.mass() - 2 * Trk::electron;
242 const double mass = photon.M();
243
244 RefTrackPx.push_back(trackMomentum(convVertexCandidate, 0).Px());
245 RefTrackPx.push_back(trackMomentum(convVertexCandidate, 1).Px());
246
247 RefTrackPy.push_back(trackMomentum(convVertexCandidate, 0).Py());
248 RefTrackPy.push_back(trackMomentum(convVertexCandidate, 1).Py());
249
250 RefTrackPz.push_back(trackMomentum(convVertexCandidate, 0).Pz());
251 RefTrackPz.push_back(trackMomentum(convVertexCandidate, 1).Pz());
252
253 for (size_t i = 0; i < B_Px.size(); i++) {
254 RefTrackPx.push_back(B_Px.at(i));
255 RefTrackPy.push_back(B_Py.at(i));
256 RefTrackPz.push_back(B_Pz.at(i));
257 }
258
259 RefTrackE.push_back(electron1.E());
260 RefTrackE.push_back(electron2.E());
261 RefTrackE.push_back(muon1.E());
262 RefTrackE.push_back(muon2.E());
263 RefTrackE.push_back(muon3.E());
264
265 OrigTrackPx.push_back(e1.Px());
266 OrigTrackPx.push_back(e2.Px());
267
268 OrigTrackPy.push_back(e1.Py());
269 OrigTrackPy.push_back(e2.Py());
270
271 OrigTrackPz.push_back(e1.Pz());
272 OrigTrackPz.push_back(e2.Pz());
273
274 OrigTrackE.push_back(e1.E());
275 OrigTrackE.push_back(e2.E());
276
277
278 ATH_MSG_DEBUG( "pt = " << photon.Pt() << " ph " << ph.Pt() << " mass " << photon.M() << " px size " << RefTrackPx.size() );
279 ATH_MSG_DEBUG( "Candidate DeltaM = " << (B_m + photon).M() << " MeV DiMuon " << " ( Mass = " << B_m.M() << " MeV )");
280
281 // Decorate selected conversions
282 ATH_MSG_DEBUG( "Decorating conversion vertices" );
283
284 static const SG::Accessor<float> pxAcc("px");
285 static const SG::Accessor<float> pyAcc("py");
286 static const SG::Accessor<float> pzAcc("pz");
287 pxAcc(*convVertexCandidate) = momentum.x();
288 pyAcc(*convVertexCandidate) = momentum.y();
289 pzAcc(*convVertexCandidate) = momentum.z();
290
291 static const SG::Accessor<float> deltaQAcc("deltaQ");
292 static const SG::Accessor<float> gamma_massAcc("gamma_mass");
293 static const SG::Accessor< std::vector<float> > RefTrackEAcc("RefTrackE");
294 deltaQAcc(*convVertexCandidate) = deltaQ;
295 gamma_massAcc(*convVertexCandidate) = mass;
296 RefTrackPxAcc(*convVertexCandidate) = RefTrackPx;
297 RefTrackPyAcc(*convVertexCandidate) = RefTrackPy;
298 RefTrackPzAcc(*convVertexCandidate) = RefTrackPz;
299 RefTrackEAcc(*convVertexCandidate) = RefTrackE;
300
301 static const SG::Accessor< std::vector<float> > OrigTrackPxAcc("OrigTrackPx");
302 static const SG::Accessor< std::vector<float> > OrigTrackPyAcc("OrigTrackPy");
303 static const SG::Accessor< std::vector<float> > OrigTrackPzAcc("OrigTrackPz");
304 static const SG::Accessor< std::vector<float> > OrigTrackEAcc("OrigTrackE");
305 OrigTrackPxAcc(*convVertexCandidate) = OrigTrackPx;
306 OrigTrackPyAcc(*convVertexCandidate) = OrigTrackPy;
307 OrigTrackPzAcc(*convVertexCandidate) = OrigTrackPz;
308 OrigTrackEAcc(*convVertexCandidate) = OrigTrackE;
309
310 static const SG::Accessor<Char_t> passed_GammaAcc("passed_Gamma");
311 passed_GammaAcc(*convVertexCandidate) = true; // Used in event skimming
312
313 conversionContainer->push_back( convVertexCandidate );
314
315 // add cross-link to the original Bc+ vertex
316 VertexLink BGammaLink;
317 BGammaLink.setElement(convVertexCandidate);
318 BGammaLink.setStorableObject(*conversionContainer);
319 BGammaLinks(*vertex).push_back(std::move(BGammaLink));
320 }
321 else {
322 ATH_MSG_DEBUG( "Vertex Fit Failed" );
323 }
324
325 } // end of Track2 Loop
326 } // end of Track1 Loop
327
328 } // end of Bc loop
329
330 } // end of vertex container loop
331
332 // Write the results to StoreGate
333 CHECK(evtStore()->record(conversionContainer.release(), m_conversionContainerName)); // FIXME Use Handles
334 CHECK(evtStore()->record(conversionAuxContainer.release(), m_conversionContainerName + "Aux.")); // FIXME Use Handles
335
336 return StatusCode::SUCCESS;
337}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
DataVector< xAOD::TrackParticle_v1 >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DerivationFramework::BPhysBGammaFinder::trackMomentum
TVector3 trackMomentum(const xAOD::Vertex *vxCandidate, int trkIndex) const
Definition BPhysBGammaFinder.cxx:341
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition TrackParticle_v1.cxx:415
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TrackParticle_v1.cxx:75
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TrackParticle_v1.cxx:79
xAOD::Vertex_v1::clearTracks
void clearTracks()
Remove all tracks from the vertex.
Definition Vertex_v1.cxx:331
xAOD::Vertex_v1::addTrackAtVertex
void addTrackAtVertex(const ElementLink< TrackParticleContainer > &tr, float weight=1.0)
Add a new track to the vertex.
Definition Vertex_v1.cxx:314
xAOD::Vertex_v1::numberDoF
float numberDoF() const
Returns the number of degrees of freedom of the vertex fit as float.
xAOD::Vertex_v1::chiSquared
float chiSquared() const
Returns the of the vertex fit as float.
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
Base_Fragment.mass
mass
Definition Sherpa_i/share/common/Base_Fragment.py:59
DerivationFramework::VertexLink
ElementLink< xAOD::VertexContainer > VertexLink
Definition JpsiPlusDpstCascade.cxx:23
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ParticleGun_EoverP_Config.momentum
momentum
Definition ParticleGun_EoverP_Config.py:63
Trk::Perigee
ParametersT< TrackParametersDim, Charged, PerigeeSurface > Perigee
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:33
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition VertexAuxContainer.h:19
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition VertexContainer.h:14
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17

◆ finalize()

StatusCode DerivationFramework::BPhysBGammaFinder::finalize ( )
override

Definition at line 67 of file BPhysBGammaFinder.cxx.

67 {
68 return StatusCode::SUCCESS;
69}

◆ initialize()

StatusCode DerivationFramework::BPhysBGammaFinder::initialize ( )
override

Definition at line 56 of file BPhysBGammaFinder.cxx.

56 {
57
58 ATH_MSG_DEBUG("in initialize()");
59
60 ATH_CHECK( m_v0Tools.retrieve() );
61 ATH_CHECK( m_vertexFitter.retrieve() );
62 ATH_CHECK( m_vertexEstimator.retrieve() );
63 return StatusCode::SUCCESS;
64}

◆ trackMomentum()

TVector3 DerivationFramework::BPhysBGammaFinder::trackMomentum ( const xAOD::Vertex * vxCandidate,
int trkIndex ) const

Definition at line 341 of file BPhysBGammaFinder.cxx.

341 {
342
343 double px = 0.;
344 double py = 0.;
345 double pz = 0.;
346 if (vxCandidate) {
347 const Trk::TrackParameters* aPerigee = vxCandidate->vxTrackAtVertex()[trkIndex].perigeeAtVertex();
348 px = aPerigee->momentum()[Trk::px];
349 py = aPerigee->momentum()[Trk::py];
350 pz = aPerigee->momentum()[Trk::pz];
351 }
352
353 return TVector3(px,py,pz);
354}
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
xAOD::Vertex_v1::vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex > & vxTrackAtVertex()
Non-const access to the VxTrackAtVertex vector.
Definition Vertex_v1.cxx:181
Trk::pz
@ pz
global momentum (cartesian)
Definition ParamDefs.h:61
Trk::px
@ px
Definition ParamDefs.h:59
Trk::py
@ py
Definition ParamDefs.h:60
Trk::TrackParameters
ParametersBase< TrackParametersDim, Charged > TrackParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:27
test_pyathena.px
px
Definition test_pyathena.py:18

Member Data Documentation

◆ m_BVertexCollectionsToCheck

std::vector<std::string> DerivationFramework::BPhysBGammaFinder::m_BVertexCollectionsToCheck
private

Definition at line 57 of file BPhysBGammaFinder.h.

◆ m_Chi2Cut

float DerivationFramework::BPhysBGammaFinder::m_Chi2Cut
private

Definition at line 74 of file BPhysBGammaFinder.h.

◆ m_conversionContainerName

std::string DerivationFramework::BPhysBGammaFinder::m_conversionContainerName
private

Definition at line 66 of file BPhysBGammaFinder.h.

◆ m_inputLowPtTrackContainerName

std::string DerivationFramework::BPhysBGammaFinder::m_inputLowPtTrackContainerName
private

Definition at line 65 of file BPhysBGammaFinder.h.

◆ m_inputTrackParticleContainerName

std::string DerivationFramework::BPhysBGammaFinder::m_inputTrackParticleContainerName
private

Definition at line 64 of file BPhysBGammaFinder.h.

◆ m_maxDeltaCotTheta

float DerivationFramework::BPhysBGammaFinder::m_maxDeltaCotTheta
private

Definition at line 69 of file BPhysBGammaFinder.h.

◆ m_maxDeltaQ

float DerivationFramework::BPhysBGammaFinder::m_maxDeltaQ
private

Definition at line 73 of file BPhysBGammaFinder.h.

◆ m_maxDistBetweenTracks

float DerivationFramework::BPhysBGammaFinder::m_maxDistBetweenTracks
private

Definition at line 68 of file BPhysBGammaFinder.h.

◆ m_maxGammaMass

float DerivationFramework::BPhysBGammaFinder::m_maxGammaMass
private

Definition at line 75 of file BPhysBGammaFinder.h.

◆ m_passFlagsToCheck

std::vector<std::string> DerivationFramework::BPhysBGammaFinder::m_passFlagsToCheck
private

Definition at line 58 of file BPhysBGammaFinder.h.

◆ m_requireDeltaQ

bool DerivationFramework::BPhysBGammaFinder::m_requireDeltaQ
private

Definition at line 71 of file BPhysBGammaFinder.h.

◆ m_use_low_pT

bool DerivationFramework::BPhysBGammaFinder::m_use_low_pT
private

Definition at line 72 of file BPhysBGammaFinder.h.

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::BPhysBGammaFinder::m_v0Tools
private

Definition at line 60 of file BPhysBGammaFinder.h.

◆ m_vertexEstimator

ToolHandle<InDet::VertexPointEstimator> DerivationFramework::BPhysBGammaFinder::m_vertexEstimator
private

Definition at line 62 of file BPhysBGammaFinder.h.

◆ m_vertexFitter

ToolHandle<Trk::IVertexFitter> DerivationFramework::BPhysBGammaFinder::m_vertexFitter
private

Definition at line 61 of file BPhysBGammaFinder.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0