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 30 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:213
TagNProbe::m_unique
bool m_unique
Definition TagNProbe.h:218
TagNProbe::m_particleType1
std::string m_particleType1
Definition TagNProbe.h:210
TagNProbe::m_massMin
double m_massMin
Definition TagNProbe.h:215
TagNProbe::m_massMax
double m_massMax
Definition TagNProbe.h:216
TagNProbe::m_mass0
double m_mass0
Definition TagNProbe.h:212
TagNProbe::construct
void construct()
Definition TagNProbe.cxx:48
TagNProbe::m_particleType0
std::string m_particleType0
Definition TagNProbe.h:209

◆ 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 38 of file TagNProbe.h.

38{ }

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 62 of file TagNProbe.h.

67 {
68 return GetRois( chains, selector, filter, selector, filter, hmass, hmass_obj, tom, tom );
69 }
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:62

◆ 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 72 of file TagNProbe.h.

80 {
81
82 std::vector<TIDA::Roi*> probes;
83
84 TIDA::Chain* chain_tag = findChain( tag(), chains );
85 TIDA::Chain* chain_probe = findChain( probe(), chains );
86
87 if ( chain_tag==0 || chain_probe==0 ) return probes;
88
89 // loop for possible probes
90 for ( size_t ip=0 ; ip<chain_probe->size() ; ip++ ) {
91
92 TIDA::Roi& proi = chain_probe->rois()[ip];
93
94 TIDARoiDescriptor roi_probe( proi.roi() );
95
96 bool found_tnp = false;
97
98 // loop for possible tags
99 for ( size_t it=0 ; it<chain_tag->size() ; it++ ) {
100
101 TIDA::Roi& troi = chain_tag->rois()[it];
102 TIDARoiDescriptor roi_tag( troi.roi() );
103
105 if ( roi_probe == roi_tag ) continue;
106
107 if ( selection( troi, proi, selector_tag, filter_tag, selector_probe, filter_probe,
108 hmass, hmass_obj, tom_tag, tom_probe ) ) {
109
110 found_tnp = true;
111 if ( m_unique ) break;
112 }
113
114 } // end loop on tags
115
116 if ( found_tnp ) probes.push_back( &proi );
117
118 } // end loop on probes
119
120 return probes;
121
122 }
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:51
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:50
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 130 of file TagNProbe.h.

130 {
131 TLorentzVector v1;
132 v1.SetPtEtaPhiM( pt(t1)*0.001, t1->eta(), t1->phi(), m_mass0 );
133 TLorentzVector v2;
134 v2.SetPtEtaPhiM( pt(t2)*0.001, t2->eta(), t2->phi(), m_mass1 );
135 return (v1+v2).M();
136 }
TagNProbe::pt
double pt(const TIDA::Track *t) const
Definition TagNProbe.h:126
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 56 of file TagNProbe.h.

56{ return m_mass0; };

◆ mass1()

double TagNProbe::mass1 ( ) const
inline

Definition at line 57 of file TagNProbe.h.

57{ 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:130
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 51 of file TagNProbe.h.

51{ return m_probeChainName; }
TagNProbe::m_probeChainName
std::string m_probeChainName
Definition TagNProbe.h:220

◆ probe() [2/2]

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

Definition at line 48 of file TagNProbe.h.

48{ m_probeChainName = chainName; }

◆ pt() [1/2]

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

Definition at line 126 of file TagNProbe.h.

126{ 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 127 of file TagNProbe.h.

127{ 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 140 of file TagNProbe.h.

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

◆ 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 150 of file TagNProbe.h.

158 {
159
161 TIDARoiDescriptor roi_tag( troi.roi() );
162
163 static_cast<Filter_Combined*>(filter_tag)->setRoi( &roi_tag );
164
165 std::vector<TIDA::Track*> refp_tag = selector_tag->tracks( filter_tag );
166
168
169 TIDARoiDescriptor roi_probe( proi.roi() );
170
171 static_cast<Filter_Combined*>( filter_probe )->setRoi( &roi_probe );
172
173 std::vector<TIDA::Track*> refp_probe = selector_probe->tracks( filter_probe );
174
176 bool found = false;
177
178 for ( size_t it=0; it<refp_tag.size() ; it++ ) {
179
181 for ( size_t ip=0; ip<refp_probe.size() ; ip++ ) {
182
184 double invmass = mass( refp_tag[it], refp_probe[ip] );
185 double invmass_obj = mass_obj( refp_tag[it], refp_probe[ip], tom_tag, tom_probe );
186 double deltaz0 = std::fabs(refp_tag[it]->z0() - refp_probe[ip]->z0() );
187
188 if ( invmass_obj>m_massMin && invmass_obj<m_massMax && deltaz0<5 ) {
189 hmass->Fill( invmass );
190 hmass_obj->Fill( invmass_obj );
191 found = true;
192 }
193 }
194 }
195
196 return found;
197
198 }
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 50 of file TagNProbe.h.

50{ return m_tagChainName; }
TagNProbe::m_tagChainName
std::string m_tagChainName
Definition TagNProbe.h:221

◆ tag() [2/2]

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

getters and setters

could be moved to the constructor now ...

Definition at line 47 of file TagNProbe.h.

47{ m_tagChainName = chainName; }

◆ type0()

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

Definition at line 53 of file TagNProbe.h.

53{ return m_particleType0; };

◆ type1()

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

Definition at line 54 of file TagNProbe.h.

54{ return m_particleType1; };

Member Data Documentation

◆ m_mass0

double TagNProbe::m_mass0
private

Definition at line 212 of file TagNProbe.h.

◆ m_mass1

double TagNProbe::m_mass1
private

Definition at line 213 of file TagNProbe.h.

◆ m_massMax

double TagNProbe::m_massMax
private

Definition at line 216 of file TagNProbe.h.

◆ m_massMin

double TagNProbe::m_massMin
private

Definition at line 215 of file TagNProbe.h.

◆ m_particleType0

std::string TagNProbe::m_particleType0
private

Definition at line 209 of file TagNProbe.h.

◆ m_particleType1

std::string TagNProbe::m_particleType1
private

Definition at line 210 of file TagNProbe.h.

◆ m_probeChainName

std::string TagNProbe::m_probeChainName
private

Definition at line 220 of file TagNProbe.h.

◆ m_tagChainName

std::string TagNProbe::m_tagChainName
private

Definition at line 221 of file TagNProbe.h.

◆ m_unique

bool TagNProbe::m_unique
private

Definition at line 218 of file TagNProbe.h.

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