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

#include <TagNProbe.h>

Collaboration diagram for TagNProbe:

Public Member Functions

 TagNProbe (const std::string &refName, double massMin, double massMax, bool unique_flag=true)
 TagNProbe (const std::string &refName0, const std::string &refName1, double massMin, double massMax, bool unique_flag=true)
virtual ~TagNProbe ()
void construct ()
void tag (const std::string &chainName)
 getters and setters
void probe (const std::string &chainName)
const std::string & tag () const
const std::string & probe () const
const std::string & type0 () const
const std::string & type1 () const
double mass0 () const
double mass1 () const
template<typename T>
std::vector< TIDA::Roi * > GetRois (std::vector< TIDA::Chain > &chains, const TrackSelector *selector, TrackFilter *filter, T *hmass, T *hmass_obj, TrigObjectMatcher *tom=0) const
template<typename T>
std::vector< TIDA::Roi * > GetRois (std::vector< TIDA::Chain > &chains, const TrackSelector *selector_tag, TrackFilter *filter_tag, const TrackSelector *selector_probe, TrackFilter *filter_probe, T *hmass, T *hmass_obj, TrigObjectMatcher *tom_tag=0, TrigObjectMatcher *tom_probe=0) const

Protected Member Functions

double pt (const TIDA::Track *t) const
double pt (const TrackTrigObject *t) const
template<typename T1, typename T2>
double mass (const T1 *t1, const T2 *t2) const
template<typename T>
bool selection (const TIDA::Roi &troi, const TIDA::Roi &proi, const TrackSelector *selector, TrackFilter *filter, T *hmass, T *hmass_obj, TrigObjectMatcher *tom=0) const
template<typename T>
bool selection (const TIDA::Roi &troi, const TIDA::Roi &proi, const TrackSelector *selector_tag, TrackFilter *filter_tag, const TrackSelector *selector_probe, TrackFilter *filter_probe, T *hmass, T *hmass_obj, TrigObjectMatcher *tom_tag=0, TrigObjectMatcher *tom_probe=0) const
double mass_obj (const TIDA::Track *t1, const TIDA::Track *t2, TrigObjectMatcher *tom=0) const
double mass_obj (const TIDA::Track *t1, const TIDA::Track *t2, TrigObjectMatcher *tom_tag, TrigObjectMatcher *tom_probe) const
TIDA::Chain * findChain (const std::string &chainname, std::vector< TIDA::Chain > &chains) const

Private Attributes

std::string m_particleType0
std::string m_particleType1
double m_mass0
double m_mass1
double m_massMin
double m_massMax
bool m_unique
std::string m_probeChainName
std::string m_tagChainName

Detailed Description

Definition at line 31 of file TagNProbe.h.

Constructor & Destructor Documentation

◆ TagNProbe() [1/2]

TagNProbe::TagNProbe ( const std::string & refName,
double massMin,
double massMax,
bool unique_flag = true )

Definition at line 34 of file TagNProbe.cxx.

35 :
36 m_particleType0(refName),
37 m_particleType1(refName),
38 m_mass0(0),
39 m_mass1(0),
40 m_massMin(massMin),
41 m_massMax(massMax),
42 m_unique(unique_flag)
43{
44 construct();
45}
TagNProbe::m_mass1
double m_mass1
Definition TagNProbe.h:214
TagNProbe::m_unique
bool m_unique
Definition TagNProbe.h:219
TagNProbe::m_particleType1
std::string m_particleType1
Definition TagNProbe.h:211
TagNProbe::m_massMin
double m_massMin
Definition TagNProbe.h:216
TagNProbe::m_massMax
double m_massMax
Definition TagNProbe.h:217
TagNProbe::m_mass0
double m_mass0
Definition TagNProbe.h:213
TagNProbe::construct
void construct()
Definition TagNProbe.cxx:48
TagNProbe::m_particleType0
std::string m_particleType0
Definition TagNProbe.h:210

◆ TagNProbe() [2/2]

TagNProbe::TagNProbe ( const std::string & refName0,
const std::string & refName1,
double massMin,
double massMax,
bool unique_flag = true )

Definition at line 20 of file TagNProbe.cxx.

22 :
23 m_particleType0(refName0),
24 m_particleType1(refName1),
25 m_mass0(0),
26 m_mass1(0),
27 m_massMin(massMin),
28 m_massMax(massMax),
29 m_unique(unique_flag)
30{
31 construct();
32}

◆ ~TagNProbe()

virtual TagNProbe::~TagNProbe ( )
inlinevirtual

Definition at line 39 of file TagNProbe.h.

39{ }

Member Function Documentation

◆ construct()

void TagNProbe::construct ( )

Definition at line 48 of file TagNProbe.cxx.

48 {
49
50
51#ifdef TRUTHUTILS_PARTICLECONSTANTS_H
52 const double muonMass = ParticleConstants::muonMassInMeV/1000.; // Convert MeV to GeV
53 const double electronMass = ParticleConstants::electronMassInMeV/1000.; // Convert MeV to GeV
54 const double tauMass = ParticleConstants::tauMassInMeV/1000.; // Convert MeV to GeV NB: mass in ParticleConstants is wrong
55#else
56 const double muonMass = 0.10565; // GeV
57 const double electronMass = 0.000511; // GeV
58 const double tauMass = 1.77686; // GeV
59#endif
60
61 if ( m_particleType0.find("Muon")!=std::string::npos ) m_mass0 = muonMass;
62 else if ( m_particleType0.find("Electron")!=std::string::npos ) m_mass0 = electronMass;
63 else if ( m_particleType0.find("Tau")!=std::string::npos ) m_mass0 = tauMass;
64
65 if ( m_particleType1.find("Muon")!=std::string::npos ) m_mass1 = muonMass;
66 else if ( m_particleType1.find("Electron")!=std::string::npos ) m_mass1 = electronMass;
67 else if ( m_particleType1.find("Tau")!=std::string::npos ) m_mass1 = tauMass;
68}
ParticleConstants::PDG2011::muonMassInMeV
constexpr double muonMassInMeV
the mass of the muon (in MeV)
Definition ParticleConstants.h:29
ParticleConstants::PDG2011::tauMassInMeV
constexpr double tauMassInMeV
the mass of the tau (in MeV)
Definition ParticleConstants.h:32
ParticleConstants::PDG2011::electronMassInMeV
constexpr double electronMassInMeV
the mass of the electron (in MeV)
Definition ParticleConstants.h:26

◆ findChain()

TIDA::Chain * TagNProbe::findChain ( const std::string & chainname,
std::vector< TIDA::Chain > & chains ) const
protected

Definition at line 106 of file TagNProbe.cxx.

106 {
107 for ( size_t i=chains.size() ; i-- ; ) {
108 if ( chains[i].name() == chainname ) return &chains[i];
109 }
110 return 0;
111}

◆ GetRois() [1/2]

template<typename T>
std::vector< TIDA::Roi * > TagNProbe::GetRois ( std::vector< TIDA::Chain > & chains,
const TrackSelector * selector,
TrackFilter * filter,
T * hmass,
T * hmass_obj,
TrigObjectMatcher * tom = 0 ) const
inline

Definition at line 63 of file TagNProbe.h.

68 {
69 return GetRois( chains, selector, filter, selector, filter, hmass, hmass_obj, tom, tom );
70 }
TagNProbe::GetRois
std::vector< TIDA::Roi * > GetRois(std::vector< TIDA::Chain > &chains, const TrackSelector *selector, TrackFilter *filter, T *hmass, T *hmass_obj, TrigObjectMatcher *tom=0) const
Definition TagNProbe.h:63

◆ GetRois() [2/2]

template<typename T>
std::vector< TIDA::Roi * > TagNProbe::GetRois ( std::vector< TIDA::Chain > & chains,
const TrackSelector * selector_tag,
TrackFilter * filter_tag,
const TrackSelector * selector_probe,
TrackFilter * filter_probe,
T * hmass,
T * hmass_obj,
TrigObjectMatcher * tom_tag = 0,
TrigObjectMatcher * tom_probe = 0 ) const
inline

tag and probe are the same: skip this tag

Definition at line 73 of file TagNProbe.h.

81 {
82
83 std::vector<TIDA::Roi*> probes;
84
85 TIDA::Chain* chain_tag = findChain( tag(), chains );
86 TIDA::Chain* chain_probe = findChain( probe(), chains );
87
88 if ( chain_tag==0 || chain_probe==0 ) return probes;
89
90 // loop for possible probes
91 for ( size_t ip=0 ; ip<chain_probe->size() ; ip++ ) {
92
93 TIDA::Roi& proi = chain_probe->rois()[ip];
94
95 TIDARoiDescriptor roi_probe( proi.roi() );
96
97 bool found_tnp = false;
98
99 // loop for possible tags
100 for ( size_t it=0 ; it<chain_tag->size() ; it++ ) {
101
102 TIDA::Roi& troi = chain_tag->rois()[it];
103 TIDARoiDescriptor roi_tag( troi.roi() );
104
106 if ( roi_probe == roi_tag ) continue;
107
108 if ( selection( troi, proi, selector_tag, filter_tag, selector_probe, filter_probe,
109 hmass, hmass_obj, tom_tag, tom_probe ) ) {
110
111 found_tnp = true;
112 if ( m_unique ) break;
113 }
114
115 } // end loop on tags
116
117 if ( found_tnp ) probes.push_back( &proi );
118
119 } // end loop on probes
120
121 return probes;
122
123 }
TIDA::Chain::rois
const std::vector< TIDA::Roi > & rois() const
get back roi vector
Definition TIDAChain.h:50
TIDA::Chain::size
unsigned size() const
number of rois
Definition TIDAChain.h:54
TIDA::Roi::roi
const TIDARoiDescriptor & roi() const
access the roi information
Definition TIDARoi.h:42
TagNProbe::probe
const std::string & probe() const
Definition TagNProbe.h:52
TagNProbe::findChain
TIDA::Chain * findChain(const std::string &chainname, std::vector< TIDA::Chain > &chains) const
Definition TagNProbe.cxx:106
TagNProbe::tag
const std::string & tag() const
Definition TagNProbe.h:51
selection
const std::string selection
Definition fbtTestBasics.cxx:75
TrigSteeringEventDict::troi
TrigRoiDescriptorCollection troi
Definition TrigSteeringEventDict.h:29
find_tgc_unfilled_channelids.ip
ip
Definition find_tgc_unfilled_channelids.py:3

◆ mass()

template<typename T1, typename T2>
double TagNProbe::mass ( const T1 * t1,
const T2 * t2 ) const
inlineprotected

Definition at line 131 of file TagNProbe.h.

131 {
132 TLorentzVector v1;
133 v1.SetPtEtaPhiM( pt(t1)*0.001, t1->eta(), t1->phi(), m_mass0 );
134 TLorentzVector v2;
135 v2.SetPtEtaPhiM( pt(t2)*0.001, t2->eta(), t2->phi(), m_mass1 );
136 return (v1+v2).M();
137 }
TagNProbe::pt
double pt(const TIDA::Track *t) const
Definition TagNProbe.h:127
ALFA_EventTPCnv_Dict::t2
std::vector< ALFA_RawDataContainer_p1 > t2
Definition ALFA_EventTPCnvDict.h:44
ALFA_EventTPCnv_Dict::t1
std::vector< ALFA_RawDataCollection_p1 > t1
Definition ALFA_EventTPCnvDict.h:43

◆ mass0()

double TagNProbe::mass0 ( ) const
inline

Definition at line 57 of file TagNProbe.h.

57{ return m_mass0; };

◆ mass1()

double TagNProbe::mass1 ( ) const
inline

Definition at line 58 of file TagNProbe.h.

58{ return m_mass1; };

◆ mass_obj() [1/2]

double TagNProbe::mass_obj ( const TIDA::Track * t1,
const TIDA::Track * t2,
TrigObjectMatcher * tom = 0 ) const
protected

Definition at line 72 of file TagNProbe.cxx.

72 {
73
74 if ( tom!=0 && tom->status() ) {
75 return mass( tom->object(t1->id()), tom->object(t2->id()) );
76 }
77 else {
78 return mass( t1, t2 );
79 }
80
81}
TagNProbe::mass
double mass(const T1 *t1, const T2 *t2) const
Definition TagNProbe.h:131
TrigObjectMatcher::object
const TrackTrigObject * object(unsigned long track_id)
Definition TrigObjectMatcher.h:59

◆ mass_obj() [2/2]

double TagNProbe::mass_obj ( const TIDA::Track * t1,
const TIDA::Track * t2,
TrigObjectMatcher * tom_tag,
TrigObjectMatcher * tom_probe ) const
protected

different toms for each leg - eg if we wanted electron + tau

only tag tom ...

only probe tom ...

just tracks ...

Definition at line 84 of file TagNProbe.cxx.

84 {
85
86 if ( tom_tag!=0 && tom_tag->status() && tom_probe!=0 && tom_probe->status() ) {
88 return mass( tom_tag->object(t1->id()), tom_probe->object(t2->id()) );
89 }
90 else if ( tom_tag!=0 && tom_tag->status() ) {
92 return mass( tom_tag->object(t1->id()), t2 );
93 }
94 else if ( tom_probe!=0 && tom_probe->status() ) {
96 return mass( t1, tom_probe->object(t2->id()) );
97 }
98 else {
100 return mass( t1, t2 );
101 }
102
103}

◆ probe() [1/2]

const std::string & TagNProbe::probe ( ) const
inline

Definition at line 52 of file TagNProbe.h.

52{ return m_probeChainName; }
TagNProbe::m_probeChainName
std::string m_probeChainName
Definition TagNProbe.h:221

◆ probe() [2/2]

void TagNProbe::probe ( const std::string & chainName)
inline

Definition at line 49 of file TagNProbe.h.

49{ m_probeChainName = chainName; }

◆ pt() [1/2]

double TagNProbe::pt ( const TIDA::Track * t) const
inlineprotected

Definition at line 127 of file TagNProbe.h.

127{ return t->pT(); }
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:8

◆ pt() [2/2]

double TagNProbe::pt ( const TrackTrigObject * t) const
inlineprotected

Definition at line 128 of file TagNProbe.h.

128{ return t->pt(); }

◆ selection() [1/2]

template<typename T>
bool TagNProbe::selection ( const TIDA::Roi & troi,
const TIDA::Roi & proi,
const TrackSelector * selector,
TrackFilter * filter,
T * hmass,
T * hmass_obj,
TrigObjectMatcher * tom = 0 ) const
inlineprotected

Definition at line 141 of file TagNProbe.h.

146 {
147 return selection( troi, proi, selector, filter, selector, filter, hmass, hmass_obj, tom, tom );
148 }

◆ selection() [2/2]

template<typename T>
bool TagNProbe::selection ( const TIDA::Roi & troi,
const TIDA::Roi & proi,
const TrackSelector * selector_tag,
TrackFilter * filter_tag,
const TrackSelector * selector_probe,
TrackFilter * filter_probe,
T * hmass,
T * hmass_obj,
TrigObjectMatcher * tom_tag = 0,
TrigObjectMatcher * tom_probe = 0 ) const
inlineprotected

get reference tracks from the tag roi

get reference tracks from the probe roi

loop over tag ref tracks

loop over probe ref tracks

check compatibility of the track z and invariant mass ...

Definition at line 151 of file TagNProbe.h.

159 {
160
162 TIDARoiDescriptor roi_tag( troi.roi() );
163
164 static_cast<Filter_Combined*>(filter_tag)->setRoi( &roi_tag );
165
166 std::vector<TIDA::Track*> refp_tag = selector_tag->tracks( filter_tag );
167
169
170 TIDARoiDescriptor roi_probe( proi.roi() );
171
172 static_cast<Filter_Combined* >( filter_probe )->setRoi( &roi_probe );
173
174 std::vector<TIDA::Track*> refp_probe = selector_probe->tracks( filter_probe );
175
177 bool found = false;
178
179 for ( size_t it=0; it<refp_tag.size() ; it++ ) {
180
182 for ( size_t ip=0; ip<refp_probe.size() ; ip++ ) {
183
185 double invmass = mass( refp_tag[it], refp_probe[ip] );
186 double invmass_obj = mass_obj( refp_tag[it], refp_probe[ip], tom_tag, tom_probe );
187 double deltaz0 = std::fabs(refp_tag[it]->z0() - refp_probe[ip]->z0() );
188
189 if ( invmass_obj>m_massMin && invmass_obj<m_massMax && deltaz0<5 ) {
190 hmass->Fill( invmass );
191 hmass_obj->Fill( invmass_obj );
192 found = true;
193 }
194 }
195 }
196
197 return found;
198
199 }
TagNProbe::mass_obj
double mass_obj(const TIDA::Track *t1, const TIDA::Track *t2, TrigObjectMatcher *tom=0) const
Definition TagNProbe.cxx:72
LCE_postprocessing.found
bool found
Definition LCE_postprocessing.py:46

◆ tag() [1/2]

const std::string & TagNProbe::tag ( ) const
inline

Definition at line 51 of file TagNProbe.h.

51{ return m_tagChainName; }
TagNProbe::m_tagChainName
std::string m_tagChainName
Definition TagNProbe.h:222

◆ tag() [2/2]

void TagNProbe::tag ( const std::string & chainName)
inline

getters and setters

could be moved to the constructor now ...

Definition at line 48 of file TagNProbe.h.

48{ m_tagChainName = chainName; }

◆ type0()

const std::string & TagNProbe::type0 ( ) const
inline

Definition at line 54 of file TagNProbe.h.

54{ return m_particleType0; };

◆ type1()

const std::string & TagNProbe::type1 ( ) const
inline

Definition at line 55 of file TagNProbe.h.

55{ return m_particleType1; };

Member Data Documentation

◆ m_mass0

double TagNProbe::m_mass0
private

Definition at line 213 of file TagNProbe.h.

◆ m_mass1

double TagNProbe::m_mass1
private

Definition at line 214 of file TagNProbe.h.

◆ m_massMax

double TagNProbe::m_massMax
private

Definition at line 217 of file TagNProbe.h.

◆ m_massMin

double TagNProbe::m_massMin
private

Definition at line 216 of file TagNProbe.h.

◆ m_particleType0

std::string TagNProbe::m_particleType0
private

Definition at line 210 of file TagNProbe.h.

◆ m_particleType1

std::string TagNProbe::m_particleType1
private

Definition at line 211 of file TagNProbe.h.

◆ m_probeChainName

std::string TagNProbe::m_probeChainName
private

Definition at line 221 of file TagNProbe.h.

◆ m_tagChainName

std::string TagNProbe::m_tagChainName
private

Definition at line 222 of file TagNProbe.h.

◆ m_unique

bool TagNProbe::m_unique
private

Definition at line 219 of file TagNProbe.h.

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