Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
T_AnalysisConfigR3_Tier0< T, A > Class Template Reference

#include <T_AnalysisConfigR3_Tier0.h>

Inheritance diagram for T_AnalysisConfigR3_Tier0< T, A >:
Collaboration diagram for T_AnalysisConfigR3_Tier0< T, A >:

Public Member Functions

 T_AnalysisConfigR3_Tier0 (const std::string &analysisInstanceName, const std::string &testChainName, const std::string &testType, const std::string &testKey, const std::string &referenceChainName, const std::string &referenceType, const std::string &referenceKey, TrackFilter *testFilter, TrackFilter *referenceFilter, TrackAssociator *associator, TrackAnalysis *analysis, TagNProbe *TnP_tool=0)
 
virtual ~T_AnalysisConfigR3_Tier0 ()
 
void initialise ()
 
void setRunPurity (bool b)
 
void setShifter (bool b)
 
void useBeamCondSvc (bool b)
 
void containTracks (bool b)
 
void setPdgID (int i=0)
 
void setParentPdgID (int i=0)
 
void setMCTruthRef (bool b)
 
void setOfflineRef (bool b)
 
void setTypes (const std::vector< std::string > &t)
 
void set_monTool (ToolHandle< GenericMonitoringTool > *m)
 
ToolHandle< GenericMonitoringTool > * monTool ()
 
void addTestChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addReferenceChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addSelectionChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addTestFilter (TrackFilter *filter)
 
void addReferenceFilter (TrackFilter *filter)
 
void addSelectionFilter (TrackFilter *filter)
 
virtual void initialize (T *p, ToolHandle< Trig::TrigDecisionTool > *tdt)
 
virtual void execute ()
 
const std::string & name () const
 
const std::string testChains () const
 
const std::string referenceChains () const
 
const std::string selectionChains () const
 
const TrackAnalysis * analysis () const
 
void setMCTruth (bool b=true)
 
bool mcTruth () const
 
void setBeamX (double d)
 
void setBeamY (double d)
 
void setBeamZ (double d)
 
double beamX () const
 
double beamY () const
 
double beamZ () const
 
bool genericFlag () const
 
void setGenericFlag (bool b)
 
const std::string & releaseData () const
 
void releaseData (const std::string &s)
 
void keepAllEvents (bool b)
 
void setUseHighestPT (bool b)
 
bool getUseHighestPT () const
 
void setVtxIndex (int i)
 
int getVtxIndex () const
 
bool filterOnRoi () const
 
bool setFilterOnRoi (bool b)
 
void setRequireDecision (bool b)
 
bool requireDecision () const
 

Public Attributes

A * m_manalysis
 

Protected Member Functions

virtual void loop ()
 
virtual void book ()
 
virtual void finalize ()
 
std::pair< typename Collection::const_iterator, typename Collection::const_iterator > getCollection (const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
 new MT feature access More...
 
bool select (std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
 
bool select (std::vector< TIDA::Vertex > &vertices, const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
 
bool select (std::vector< TIDA::Vertex > &vertices, const std::string &key="")
 
bool selectTracks (TrigTrackSelector *selector, const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
 
bool selectTracks (TrigTrackSelector *selector, Trig::FeatureContainer::combination_const_iterator citr, const std::string &key="")
 lagacy run 2 access More...
 
bool selectTracks (TrigTrackSelector *selector, Trig::FeatureContainer::combination_const_iterator citr, const TrigInDetTrackTruthMap *truthmap, const std::string &key="", unsigned index=0)
 NB: because we want to use this for the L2Star chains, we have to use this method, not the above method without the TruthMap argument - if we don't want/have the TruthMap, just set the pointer to 0 - there should be abetter way to do this, but shan't worry about it now. More...
 
bool selectTracks (TrigTrackSelector *selector, const std::string &key)
 
StatusCode retrieve (Collection const *&collection, const std::string &key="")
 
bool selectTracksNotEmpty (TrigTrackSelector *selector, const std::string &key)
 
std::vector< double > getBeamspot (const std::string &key)
 
std::vector< double > getBeamspot (Trig::FeatureContainer::combination_const_iterator citr, const std::string &key="")
 
unsigned processElectrons (TrigTrackSelector &selectorRef, std::vector< TrackTrigObject > *elevec=0, const unsigned int selection=0, bool raw_track=false, double ETOffline=0, const std::string &containerName="ElectronAODCollection")
 select offline electrons More...
 
unsigned processMuons (TrigTrackSelector &selectorRef, const unsigned int selection=0, double ETOffline=0, const std::string &containerName="StacoMuonCollection")
 select offlinqe muons More...
 
unsigned processTaus (TrigTrackSelector &selectorRef, std::vector< TrackTrigObject > *tauvec=0, const unsigned selection=0, int requireNtracks=0, double EtCutOffline=0, const std::string &containerName="TauRecContainer")
 select offline taus More...
 

Protected Attributes

bool m_useBeamCondSvc
 
std::vector< ChainString > m_chainNames
 
std::vector< A * > m_analyses
 
std::string m_testType
 
bool m_doOffline
 
bool m_doMuons
 
bool m_doElectrons
 
bool m_doTaus
 
bool m_doBjets
 
bool m_doTauThreeProng
 
bool m_tauEtCutOffline
 
std::vector< std::string > m_offline_types
 
std::vector< std::string > m_types
 
std::string m_outputFileName
 
int m_pdgID
 
int m_parent_pdgID
 
int m_NRois
 output stats More...
 
int m_NRefTracks
 
int m_NTestTracks
 
bool m_runPurity
 
bool m_shifter
 
double m_pTthreshold
 
bool m_first
 
bool m_containTracks
 
TagNProbe * m_TnP_tool
 
bool m_tnp_flag
 
ToolHandle< GenericMonitoringTool > * m_monTool
 
TIDA::Histogram< float > * m_invmass
 
TIDA::Histogram< float > * m_invmass_obj
 
T * m_provider
 
ToolHandle< Trig::TrigDecisionTool > * m_tdt
 
std::string m_analysisInstanceName
 
std::vector< std::vector< std::string > > m_keys
 
std::string m_refChainName
 
std::string m_refChainKey
 
std::string m_testChainName
 
std::string m_testChainKey
 
std::vector< std::vector< TrackFilter * > > m_filters
 
TrigTrackSelector * m_selectorRef
 
TrigTrackSelector * m_selectorTest
 
TrigTrackSelector * m_selectorSel
 
TrackAssociator * m_associator
 
TrackAnalysis * m_analysis
 
bool m_mcTruth
 
double m_beamX
 
double m_beamY
 
double m_beamZ
 
int m_genericFlag
 
std::string m_releaseData
 
bool m_keepAllEvents
 
bool m_useHighestPT
 
int m_vtxIndex
 
bool m_filterOnRoi
 
bool m_requireDecision
 

Detailed Description

template<typename T, typename A = AnalysisR3_Tier0>
class T_AnalysisConfigR3_Tier0< T, A >

Definition at line 96 of file T_AnalysisConfigR3_Tier0.h.

Constructor & Destructor Documentation

◆ T_AnalysisConfigR3_Tier0()

template<typename T , typename A = AnalysisR3_Tier0>
T_AnalysisConfigR3_Tier0< T, A >::T_AnalysisConfigR3_Tier0 ( const std::string &  analysisInstanceName,
const std::string &  testChainName,
const std::string &  testType,
const std::string &  testKey,
const std::string &  referenceChainName,
const std::string &  referenceType,
const std::string &  referenceKey,
TrackFilter *  testFilter,
TrackFilter *  referenceFilter,
TrackAssociator *  associator,
TrackAnalysis *  analysis,
TagNProbe *  TnP_tool = 0 
)
inline

leave in for development std::cout << "chain size: " << m_chainNames.size() << "(" << this << ")" << std::endl;

std::cout << "chain size: " << m_chainNames.size() << "(" << this << ")" << std::endl;

Definition at line 107 of file T_AnalysisConfigR3_Tier0.h.

113  :
114  T_AnalysisConfig<T>( analysisInstanceName,
115  testChainName, testType, testKey,
116  referenceChainName, referenceType, referenceKey,
117  testFilter, referenceFilter,
118  associator,
119  analysis),
120  m_manalysis(0),
121  m_useBeamCondSvc(false),
122  m_doOffline(true),
123  m_doMuons(false),
124  m_doElectrons(false),
125  m_doTaus(false),
126  m_doBjets(false),
127  m_doTauThreeProng(false),
128  m_tauEtCutOffline(false),
129  m_pdgID(0),
130  m_parent_pdgID(0),
131  m_NRois(0),
132  m_NRefTracks(0),
133  m_NTestTracks(0),
134  m_runPurity(false),
135  m_shifter(false),
136  m_pTthreshold(0),
137  m_first(true),
138  m_containTracks(false),
139  m_tnp_flag(false),
140  m_monTool(0),
141  m_invmass(0),
142  m_invmass_obj(0)
143  {
144 
147 
148  m_chainNames.push_back(testChainName);
149 
151 
152  m_TnP_tool = TnP_tool;
153 
154 #if 0
155  ChainString& chain = m_chainNames.back();
157 
158  std::cout << "\nT_AnalysisConfigR3_Tier0::name: " << name() << "\t" << this << std::endl;
159  std::cout << "T_AnalysisConfigR3_Tier0::chain specification: " << testChainName << " -> " << chain << "\t" << chain.raw() << std::endl;
160  std::cout << "\tchain: " << chain.head() << std::endl;
161  std::cout << "\tkey: " << chain.tail() << std::endl;
162  std::cout << "\troi: " << chain.roi() << std::endl;
163  std::cout << "\tvtx: " << chain.vtx() << std::endl;
164  std::cout << "\tte: " << chain.element() << std::endl;
165  std::cout << "\textra: " << chain.extra() << std::endl;
166 
167  std::cout << "\tpost: " << chain.post() << std::endl;
168  std::cout << "\tpt: " << chain.postvalue("pt") << std::endl;
169 
170  std::cout << "\tcontainTracks: " << m_containTracks << std::endl;
171 
172 #endif
173 
174  m_testType = testType;
175 
176  if ( m_TnP_tool ) m_tnp_flag = true;
177 
178  }

◆ ~T_AnalysisConfigR3_Tier0()

template<typename T , typename A = AnalysisR3_Tier0>
virtual T_AnalysisConfigR3_Tier0< T, A >::~T_AnalysisConfigR3_Tier0 ( )
inlinevirtual

Definition at line 181 of file T_AnalysisConfigR3_Tier0.h.

181  {
182  if ( m_TnP_tool ) delete m_TnP_tool;
183  if ( m_invmass ) delete m_invmass;
184  if ( m_invmass_obj ) delete m_invmass_obj;
185  }

Member Function Documentation

◆ addReferenceChain()

void T_AnalysisConfig< T >::addReferenceChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inlineinherited

Definition at line 203 of file T_AnalysisConfig.h.

203  {
204  m_chainNames[1].push_back(chainName); m_types[1].push_back(type); m_keys[1].push_back(key);
205  }

◆ addReferenceFilter()

void T_AnalysisConfig< T >::addReferenceFilter ( TrackFilter *  filter)
inlineinherited

Definition at line 212 of file T_AnalysisConfig.h.

212 { m_filters[1].push_back(filter); }

◆ addSelectionChain()

void T_AnalysisConfig< T >::addSelectionChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inlineinherited

Definition at line 207 of file T_AnalysisConfig.h.

207  {
208  m_chainNames[2].push_back(chainName); m_types[2].push_back(type); m_keys[2].push_back(key);
209  }

◆ addSelectionFilter()

void T_AnalysisConfig< T >::addSelectionFilter ( TrackFilter *  filter)
inlineinherited

Definition at line 213 of file T_AnalysisConfig.h.

213 { m_filters[2].push_back(filter); }

◆ addTestChain()

void T_AnalysisConfig< T >::addTestChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inlineinherited

Definition at line 199 of file T_AnalysisConfig.h.

199  {
200  m_chainNames[0].push_back(chainName); m_types[0].push_back(type); m_keys[0].push_back(key);
201  }

◆ addTestFilter()

void T_AnalysisConfig< T >::addTestFilter ( TrackFilter *  filter)
inlineinherited

Definition at line 211 of file T_AnalysisConfig.h.

211 { m_filters[0].push_back(filter); }

◆ analysis()

const TrackAnalysis* T_AnalysisConfig< T >::analysis ( ) const
inlineinherited

Definition at line 258 of file T_AnalysisConfig.h.

258 {return m_analysis;}

◆ beamX()

double T_AnalysisConfig< T >::beamX ( ) const
inlineinherited

Definition at line 266 of file T_AnalysisConfig.h.

266 { return m_beamX; }

◆ beamY()

double T_AnalysisConfig< T >::beamY ( ) const
inlineinherited

Definition at line 267 of file T_AnalysisConfig.h.

267 { return m_beamY; }

◆ beamZ()

double T_AnalysisConfig< T >::beamZ ( ) const
inlineinherited

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_beamZ; }

◆ book()

template<typename T , typename A = AnalysisR3_Tier0>
virtual void T_AnalysisConfigR3_Tier0< T, A >::book ( )
inlineprotectedvirtual

get list of configured triggers

don't use test_type now ?

these are the Expert / non-Shifter histograms - encode the full chain names

add trigger element and roi descriptor names

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1116 of file T_AnalysisConfigR3_Tier0.h.

1116  {
1117 
1118  if(m_provider->msg().level() <= MSG::VERBOSE)
1119  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::book() " << name() << endmsg;
1120 
1121  // get the TriggerDecisionTool
1122 
1123  if( m_tdt->retrieve().isFailure() ) {
1124  if(m_provider->msg().level() <= MSG::ERROR)
1125  m_provider->msg(MSG::ERROR) << " Unable to retrieve the TrigDecisionTool: Please check job options file" << endmsg;
1126  return;
1127  }
1128 
1129  if(m_provider->msg().level() <= MSG::VERBOSE) {
1130  m_provider->msg(MSG::VERBOSE) << " Successfully retrived the TrigDecisionTool" << endmsg;
1131  }
1132 
1133 
1135  if (m_provider->msg().level() <= MSG::VERBOSE) {
1136  std::vector<std::string> configuredChains = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
1137 
1138  m_provider->msg(MSG::VERBOSE) << "Configured chains" << endmsg;
1139  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
1140  if( m_provider->msg().level() <= MSG::VERBOSE)
1141  m_provider->msg(MSG::VERBOSE) << " Chain " << configuredChains[i] << endmsg;
1142  }
1143  }
1144 
1145 
1146  for ( unsigned ic=0 ; ic<m_chainNames.size() ; ic++ ) {
1147 
1148  if ( ic>0 ) {
1149  m_provider->msg(MSG::WARNING) << "more than one chain configured for this analysis - skipping " << m_chainNames[ic] << endmsg;
1150  continue;
1151  }
1152 
1153  m_provider->msg(MSG::VERBOSE) << "Analyse chain " << m_chainNames[ic] << endmsg;
1154 
1155  // m_provider->msg(MSG::VERBOSE) << "--------------------------------------------------" << endmsg;
1156 
1157  std::string folder_name = "";
1158 
1159  if ( name()!="" ) folder_name = name();
1160  else folder_name = "HLT/TRIDT/IDMon";
1161 
1163  if( m_testType != "" ) folder_name = folder_name + "/" + m_testType;
1164 
1165  std::string mongroup;
1166 
1167 #if 0
1168 
1171  if ( name().find("Shifter")!=std::string::npos || m_shifter ) {
1173  if ( m_chainNames.at(ic).tail().find("_FTF") != std::string::npos ) mongroup = folder_name + "/FTF";
1174  else if ( m_chainNames.at(ic).tail().find("_IDTrig") != std::string::npos ||
1175  m_chainNames.at(ic).tail().find("_EFID") != std::string::npos ) mongroup = folder_name + "/EFID";
1176  else if ( m_chainNames.at(ic).tail().find("InDetTrigParticle") != std::string::npos ) mongroup = folder_name + "/EFID_RUN1";
1177  else if ( m_chainNames.at(ic).tail().find("_GSF") != std::string::npos ) mongroup = folder_name + "/GSF";
1178  else mongroup = folder_name + "/Unknown";
1179 
1180  if ( m_chainNames.at(ic).vtx()!="" ) mongroup += "/" + m_chainNames.at(ic).vtx();
1181 
1182  }
1183 #endif
1184  // else {
1186 
1187  if ( m_chainNames[ic].head() == "" ) mongroup = folder_name + "/Fullscan";
1188  else mongroup = folder_name + "/" + m_chainNames[ic].head();
1189 
1190  std::string track_collection = "";
1191 
1192  if ( m_chainNames.at(ic).tail()!="" ) {
1193  track_collection = "/" + m_chainNames.at(ic).tail();
1194  if ( m_chainNames.at(ic).extra()!="" ) track_collection += "_" + m_chainNames.at(ic).extra();
1195  }
1196 
1197  if ( m_chainNames.at(ic).roi()!="" ) {
1198  if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].roi();
1199  else track_collection = "/" + m_chainNames[ic].roi();
1200  }
1201 
1202  if ( m_chainNames.at(ic).vtx()!="" ) {
1203  if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].vtx();
1204  else track_collection = "/" + m_chainNames[ic].vtx();
1205  }
1206 
1208  if ( m_chainNames.at(ic).element()!="" ) {
1209  if ( track_collection!="" ) track_collection += "_" + m_chainNames[ic].element();
1210  else track_collection = "/" + m_chainNames[ic].element();
1211  }
1212 
1213  if ( track_collection!="" ) mongroup += track_collection;
1214 
1215  if ( !m_chainNames.at(ic).passed() ) mongroup += "/DTE";
1216 
1217  // }
1218 
1219  m_provider->msg(MSG::VERBOSE) << " book mongroup " << mongroup << endmsg;
1220 
1221  m_manalysis = dynamic_cast<A*>(m_analysis);
1222 
1223  if ( monTool() ) m_manalysis->set_monTool( monTool() );
1224 
1225  m_analysis->initialise();
1226 
1227  if(m_provider->msg().level() <= MSG::VERBOSE) {
1228  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::book() done" << endmsg;
1229  }
1230  }
1231 
1232  }

◆ containTracks()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::containTracks ( bool  b)
inline

Definition at line 211 of file T_AnalysisConfigR3_Tier0.h.

211 { m_containTracks = b; }

◆ execute()

virtual void T_AnalysisConfig< T >::execute ( )
inlinevirtualinherited

Definition at line 225 of file T_AnalysisConfig.h.

225  {
226  if ( !m_provider ) std::cerr << "ERROR T_AnalysisConfig::execute() called without initialising" << std::endl;
227  loop();
228  }

◆ filterOnRoi()

bool T_AnalysisConfig< T >::filterOnRoi ( ) const
inlineinherited

Definition at line 284 of file T_AnalysisConfig.h.

284 { return m_filterOnRoi; }

◆ finalize()

template<typename T , typename A = AnalysisR3_Tier0>
virtual void T_AnalysisConfigR3_Tier0< T, A >::finalize ( )
inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1236 of file T_AnalysisConfigR3_Tier0.h.

1236  {
1237 
1238  if(m_provider->msg().level() <= MSG::VERBOSE){
1239  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::finalise() " << m_provider->name() << endmsg;
1240  }
1241 
1242  m_analysis->finalise();
1243 
1244  m_provider->msg(MSG::INFO) << m_provider->name() << " " << m_chainNames[0] << " \tNRois processed: " << m_NRois << "\tRef tracks: " << m_NRefTracks << "\tTestTracks: " << m_NTestTracks << endmsg;
1245 
1246  if(m_provider->msg().level() <= MSG::VERBOSE) {
1247  m_provider->msg(MSG::VERBOSE) << m_provider->name() << " finalised" << endmsg;
1248  }
1249  }

◆ genericFlag()

bool T_AnalysisConfig< T >::genericFlag ( ) const
inlineinherited

Definition at line 270 of file T_AnalysisConfig.h.

270 { return m_genericFlag; }

◆ getBeamspot() [1/2]

std::vector<double> T_AnalysisConfig< T >::getBeamspot ( const std::string &  key)
inlineprotectedinherited

Definition at line 634 of file T_AnalysisConfig.h.

634  {
635  const Collection* collection = 0;
636  std::vector<double> v;
637 
638  if ( key!="" ) {
639  if ( m_provider->evtStore()->template contains<Collection>( key ) ) {
640  StatusCode sc = retrieve( collection, key );
641  if( sc.isSuccess() && collection ) {
642  m_provider->msg(MSG::DEBUG) << "SG Collection->size() " << collection->size() << " (" << key << ")" << endmsg;
643 
644  typename Collection::const_iterator trackitr = collection->begin();
645  typename Collection::const_iterator trackend = collection->end();
646  if ( trackitr!=trackend ) {
647  v.resize(3);
648  v[0] = (*trackitr)->vx();
649  v[1] = (*trackitr)->vy();
650  v[2] = (*trackitr)->vz();
651  return v;
652  } // only need to look at the first track
653  }
654  }
655  }
656  return v;
657  }

◆ getBeamspot() [2/2]

std::vector<double> T_AnalysisConfig< T >::getBeamspot ( Trig::FeatureContainer::combination_const_iterator  citr,
const std::string &  key = "" 
)
inlineprotectedinherited

Definition at line 663 of file T_AnalysisConfig.h.

663  {
664  std::vector< Trig::Feature<Collection> > trackcollections = citr->get<Collection>( key, TrigDefs::alsoDeactivateTEs );
665  std::vector<double> v;
666  if ( !trackcollections.empty() ) {
667  // NB!! a combination should never have more than one entry for a track collection from a single algorithm,
668  // if ( trackcollections.size()>1 ) std::cerr << "SUTT OH NO!!!!!!!!" << endmsg;
669  for ( unsigned ifeat=0 ; ifeat<trackcollections.size() ; ifeat++ ) {
670  // std::cout << "selectTracks() ifeat=" << ifeat << "\tkey " << key << std::endl;
671  Trig::Feature<Collection> trackfeature = trackcollections.at(ifeat);
672  if ( !trackfeature.empty() ) {
673  // m_provider->msg(MSG::DEBUG) << "TDT TrackFeature->size() " << trackfeature.cptr()->size() << " (" << key << ")" << endmsg;
674  // actually select the tracks from this roi at last!!
675  const Collection* trigtracks = trackfeature.cptr();
676 
677  typename Collection::const_iterator trackitr = trigtracks->begin();
678  typename Collection::const_iterator trackend = trigtracks->end();
679  if ( trackitr!=trackend ) {
680  v.resize(3);
681  v[0] = (*trackitr)->vx();
682  v[1] = (*trackitr)->vy();
683  v[2] = (*trackitr)->vz();
684  return v;
685  } // only need to look at the first track
686  }
687  }
688  return v;
689  }
690  else {
691  m_provider->msg(MSG::DEBUG) << "TDT TrackFeature collection (" << key << ") is empty " << endmsg;
692  return v;
693  }
694  }

◆ getCollection()

std::pair< typename Collection::const_iterator, typename Collection::const_iterator > T_AnalysisConfig< T >::getCollection ( const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotectedinherited

new MT feature access

will need this printout for debugging the feature access, so leave this commented until it has been properly debugged, then it can be removed

will not use the te name here, but keep it on just the same for the time being, for subsequent development

Definition at line 299 of file T_AnalysisConfig.h.

300  {
301 
304  // std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;
305 
308  std::string key_collection = key;
309  std::string key_tename = "";
310  size_t pos = key_collection.find("/");
311  if ( pos!=std::string::npos ) {
312  key_collection = key.substr( pos+1, key.size()-pos );
313  key_tename = key.substr( 0, pos );
314  }
315 
316  std::pair< typename Collection::const_iterator,
317  typename Collection::const_iterator > itrpair;
318 
319  SG::ReadHandle<Collection> handle(key);
320 
321  CLID checkCLID;
322  const std::string* keyStr = m_provider->evtStore()->keyToString(roi_link.key(), checkCLID);
323  m_provider->msg(MSG::DEBUG) << "Requesting range over (" << key << ") associated to ROI from " << (keyStr == nullptr ? "UNKNOWN" : *keyStr) << endmsg;
324 
325  itrpair = (*m_tdt)->associateToEventView( handle, roi_link );
326 
327  return itrpair;
328  }

◆ getUseHighestPT()

bool T_AnalysisConfig< T >::getUseHighestPT ( ) const
inlineinherited

Definition at line 279 of file T_AnalysisConfig.h.

279 { return m_useHighestPT; }

◆ getVtxIndex()

int T_AnalysisConfig< T >::getVtxIndex ( ) const
inlineinherited

Definition at line 282 of file T_AnalysisConfig.h.

282 { return m_vtxIndex; }

◆ initialise()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::initialise ( )
inline

Definition at line 188 of file T_AnalysisConfigR3_Tier0.h.

188  {
189 
190  if ( m_tnp_flag ) {
191  if ( m_invmass==0 ) m_invmass = new TIDA::Histogram<float>( monTool(), "invmass" );
192  if ( m_invmass_obj==0 ) m_invmass_obj = new TIDA::Histogram<float>( monTool(), "invmass_obj" );
193  }
194 
195  for ( size_t it=0 ; it<m_types.size() ; it++ ) {
196  if ( m_types[it]=="" ) m_offline_types.push_back( "InDetTrackParticles" );
197  else m_offline_types.push_back( m_types[it] );
198  }
199 
200  if ( m_offline_types.empty() ) m_offline_types.push_back( "InDetTrackParticles" );
201 
202  }

◆ initialize()

virtual void T_AnalysisConfig< T >::initialize ( Provider *  p,
ToolHandle< Trig::TrigDecisionTool > *  tdt 
)
inlinevirtualinherited

Definition at line 216 of file T_AnalysisConfig.h.

216  {
217  m_provider = p;
218  m_tdt = tdt;
219  if ( m_tdt==0 ) m_analysis->initialise();
220 
221  }

◆ keepAllEvents()

void T_AnalysisConfig< T >::keepAllEvents ( bool  b)
inlineinherited

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_keepAllEvents = b; }

◆ loop()

template<typename T , typename A = AnalysisR3_Tier0>
virtual void T_AnalysisConfigR3_Tier0< T, A >::loop ( )
inlineprotectedvirtual

this isn't working yet - will renable once we have a workaround

will need to add a vertex filter at some point probably

switch reference selector to truth if requested

this isn't working yet - will renable once we have a workaround if ( xbeam!=0 || ybeam!=0 ) { std::cerr << "Oh no ! setBeamLine() : " << xbeam << " " << ybeam << std::endl; pselectorRef->setBeamline( xbeam, ybeam ); }

now start everything going for this event properly ...

the fourth value will store the number of vertices

(obviously) get the event info

for debugging ...

first check whether the chains have actually run, otherwise there's no point doing anything

for debugging ...

for Monte Carlo get the truth particles if requested to do so

get the offline vertices into our structure

fetch offline vertices ...

add the truth particles if needed

now add the vertices

now add the offline tracks and reco objects

FIXME: most of the different truth selection can go

AOD

xAOD::TruthParticles

anything else?

selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );

now as a check go through the GenEvent collection

found this key

not found any truth collection

count of "events" - or interactions

count of particles

count of "events with some particles"

count of particles in this interaction

hooray! actually found a sensible event

if there were some particles in this interaction ...

need to be careful here, if not requiring truth only should not return

do we still want to support Rec::TrackParticles ? Would this even still work ?

clone the asociator

now loop over all relevant chains to get the trigger tracks...

create chains for ntpl

why does this need to be a class variable ???

useful debug information to be kept in for the time being

useful debug information to be kept in

Get chain combinations and loop on them

  • loop made on chain selected as the one steering RoI creation

only use the TDT for extracting collections if this was a trigger analysis for fullscan "offline" type analyses (ie fullscan FTK) do not use this

do we still want the blind chain access for track collections ???

dummy full scan chain

MT Vertex access

new Roi based feature access

new FeatureRequestDescriptor with leg access

a hack to fetch back the Rois with "_probe" in the name if the standard named RoiDescriptors are not actually present for this chain ...

count of how many rois processed so far

don't extract any additional rois if a superRoi is requested: In this case, the superRoi would be shared between the different chains - this shouldn't be needed now ...

check this is not a spurious TDT match

invalid feature links can happen for missing (or truncated) Aux containers

for debug ...

get the tracks

create analysis chain

get tracks

now get the vertices

retrieve online vertices

"offline" of "roi" type chains

This is nonsense and needs restructuring - why is the truth and offline selection done within this RoI loop? It means the complete offline and truth tracks will be retrieved for every RoI ! really we should have the structure

  • check_a_trigger_chain_has_passed
  • get_offline_or_truth_particles
  • loop_over_rois
    • get_trigger_tracks
    • filter_offline_or_truth_reference
    • match_tracks
    • call_analyis_routine

will leave as it is for the time being

debug ...

get the beamline

the original code sets a class variable on the fill class this will not be reentrant, as another instance could overwrite it, but will keep it in for now. MAybe we could clone the analysis class each time we have an instance. Need to investigate whether such an event-by-event might be fast enough. Foe the time being, leave the original code here, but commented

if we want a purity, we need to swap round which tracks are the reference tracks and which the test tracks

stats book keeping

match test and reference tracks

filter on highest pt track only if required

ignore all tracks belong the specific analysis pt threshold if set

should be included - but leave commented out here to allow study of rois with *no relevant truth particles !!!

stats book keeping

match test and reference tracks

this setting of the roi is not thread safe so it has been diabled for the time being in principle we may be able to remove it completely, but we need to check whether we can do without this functionality, so leave the code in place until we either fix it properly in the future, or determine that it is not needed

get vertices for this roi - have to copy to a vector<Vertex*>

Implements T_AnalysisConfig< T >.

Definition at line 246 of file T_AnalysisConfigR3_Tier0.h.

246  {
247 
248  const TagNProbe* pTnP_tool = m_TnP_tool;
249 
250  if( m_provider->msg().level() <= MSG::VERBOSE) {
251  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigR3_Tier0::loop() for " << T_AnalysisConfig<T>::m_analysisInstanceName << endmsg;
252  }
253 
255  // get (offline) beam position
256  // double xbeam = 0;
257  // double ybeam = 0;
258 
259 #if 0
260 
261  if ( m_first ) {
262 
263  m_first = false;
264 
265  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
266  m_provider->msg(MSG::VERBOSE) << " using beam position\tx=" << xbeam << "\ty=" << ybeam << endmsg;
267 
268  std::vector<std::string> configuredChains = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
269 
270  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
272  // std::cout << "Configured chain " << configuredChains[i] << std::endl;
273  m_provider->msg(MSG::VERBOSE) << "Chain " << configuredChains[i] << endmsg;
274  }
275  }
276 
277  // std::cout << "\tloop() analyse chains " << m_chainNames.size() << std::endl;
278 
279  }
280 
281 #endif
282 
283  Filter_True filter;
284 
285  Filter_etaPT filter_etaPT( 5, 200 );
286  Filter_Combined filter_truth( &filter_etaPT, &filter_etaPT);
287 
289  // Filter_Combined filterRef (&filter_offline, &filter_vertex);
290 
291  int iRefFilter = 1;
292  int iTestFilter = 0;
293 
294  if ( m_runPurity ) {
295  iRefFilter = 0;
296  iTestFilter = 1;
297  }
298 
299 
300  TrackFilter* rfilter = m_filters[iRefFilter][0];
301  TrackFilter* tfilter = m_filters[iTestFilter][0];
302 
303  Filter_Combined filterRef( rfilter, &filter );
304  Filter_Combined filterTest( tfilter, &filter );
305 
306  TrigTrackSelector selectorTruth( &filter_truth, m_pdgID, m_parent_pdgID );
307 
308  TrigTrackSelector selectorRef( &filterRef );
309  TrigTrackSelector* pselectorRef = &selectorRef;
310 
311  TrigTrackSelector selectorTest( &filterTest );
312  TrigTrackSelector* pselectorTest = &selectorTest;
313 
315  if ( m_mcTruth ) pselectorRef = &selectorTruth;
316 
322 
324 
325  TIDA::Event event;
326  TIDA::Event* eventp = &event;
327 
328  double beamline[4] = { 0, 0, 0, 0 };
329 
330  // clear the ntuple TIDA::Event class
331  eventp->clear();
332 
334 
335  const xAOD::EventInfo* pEventInfo = 0;
336 
337  unsigned run_number = 0;
338  unsigned long long event_number = 0;
339  unsigned lumi_block = 0;
340  unsigned bunch_crossing_id = 0;
341  unsigned time_stamp = 0;
342  double mu_val = 0;
343 
345  // std::cout << "\tloop() get EventInfo" << std::endl;
346 
347  if ( this->template retrieve( pEventInfo, "EventInfo" ).isFailure() ) {
348  m_provider->msg(MSG::WARNING) << "Failed to get EventInfo " << endmsg;
349  } else {
350 
351  run_number = pEventInfo->runNumber();
352  event_number = pEventInfo->eventNumber();
353  lumi_block = pEventInfo->lumiBlock();
354  time_stamp = pEventInfo->timeStamp();
355  bunch_crossing_id = pEventInfo->bcid();
356  mu_val = pEventInfo->averageInteractionsPerCrossing();
357  }
358 
359  if(m_provider->msg().level() <= MSG::VERBOSE){
360  m_provider->msg(MSG::VERBOSE) << "run " << run_number
361  << "\tevent " << event_number
362  << "\tlb " << lumi_block << endmsg;
363  }
364 
365  // clear the ntuple TIDA::Event class
366  eventp->clear();
367 
368  eventp->run_number(run_number);
369  eventp->event_number(event_number);
370  eventp->lumi_block(lumi_block);
371  eventp->time_stamp(time_stamp);
372  eventp->bunch_crossing_id(bunch_crossing_id);
373  eventp->mu(mu_val);
374 
377 
378  bool analyse = false;
379 
380  // Check HLTResult
381 
382  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
383 
384  const std::string& chainname = m_chainNames[ichain].head();
385 
386  if ( chainname == "" ) analyse = true;
387  else {
388 
389  //Only for trigger chains
390  if ( chainname.find("L2") == std::string::npos &&
391  chainname.find("EF") == std::string::npos &&
392  chainname.find("HLT") == std::string::npos ) continue;
393 
394  if ( m_provider->msg().level() <= MSG::DEBUG ) {
395  m_provider->msg(MSG::DEBUG) << "Chain " << chainname
396  << "\tpass " << (*m_tdt)->isPassed(chainname)
397  << "\tpres " << (*m_tdt)->getPrescale(chainname) << endmsg;
398  }
399 
401  // std::cout << "\tChain " << chainname << "\tpass " << (*m_tdt)->isPassed(chainname)
402  // << "\tpres " << (*m_tdt)->getPrescale(chainname) << std::endl;
403 
404  if ( (*(m_tdt))->isPassed(chainname) ) analyse = true;
405 
406  }
407 
408  }
409 
410 
411  if ( !this->m_keepAllEvents && !analyse ) {
412  if(m_provider->msg().level() <= MSG::VERBOSE) {
413  m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
414  }
415  return;
416  }
417 
418 
420 
421  selectorTruth.clear();
422 
423  if(m_provider->msg().level() <= MSG::VERBOSE)
424  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
425 
427 
428  std::vector<TIDA::Vertex> vertices;
429  std::vector<TIDA::Vertex> vertices_rec;
430 
431  std::vector<double> refbeamspot;
432  std::vector<double> testbeamspot;
433 
435 
436  m_provider->msg(MSG::VERBOSE) << "fetching AOD Primary vertex container" << endmsg;
437 
438  if ( !this->select( vertices, "PrimaryVertices" ) ) {
439  m_provider->msg(MSG::VERBOSE) << "could not retrieve the 'PrimaryVertices' vertex collection" << std::endl;
440  }
441 
443 
444  if ( m_mcTruth ) {
445  eventp->addChain( "Truth" );
446  eventp->back().addRoi(TIDARoiDescriptor());
447  eventp->back().back().addTracks(selectorTruth.tracks());
448  }
449 
451 
452  if ( m_doOffline ) {
453  for ( unsigned i=0 ; i<vertices.size() ; i++ ) {
454  if(m_provider->msg().level() <= MSG::VERBOSE)
455  m_provider->msg(MSG::VERBOSE) << "vertex " << i << " " << vertices[i] << endmsg;
456  eventp->addVertex(vertices[i]);
457  }
458  }
459 
460 
461 
463 
464  std::vector<TIDA::Track*> offline_tracks;
465  std::vector<TIDA::Track*> electron_tracks;
466  std::vector<TIDA::Track*> muon_tracks;
467 
468  std::vector<TIDA::Track*> ref_tracks;
469  std::vector<TIDA::Track*> test_tracks;
470 
471  offline_tracks.clear();
472  electron_tracks.clear();
473  muon_tracks.clear();
474 
475  ref_tracks.clear();
476  test_tracks.clear();
477 
478  // offline track retrieval now done once for each chain rather than each roi
479  if ( m_provider->msg().level() <= MSG::VERBOSE )
480  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
481 
482  bool foundTruth = false;
483 
485 
486  if ( m_mcTruth ) {
487 
488  filter_truth.setRoi( 0 ); // don't filter on RoI yet (or until needed)
489 
490  selectorTruth.clear();
491 
492  if ( m_provider->msg().level() <= MSG::VERBOSE )
493  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
494 
495  if ( m_provider->evtStore()->template contains<TruthParticleContainer>("INav4MomTruthEvent") ) {
496  //ESD
497  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
498  foundTruth = true;
499  }
500  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("SpclMC") ) {
502  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
503  foundTruth = true;
504  }
505  else if ( m_provider->evtStore()->template contains<xAOD::TruthParticleContainer>("TruthParticles") ) {
507  this->template selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "TruthParticles");
508  foundTruth = true;
509  }
510  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("") ) {
512  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "");
513  foundTruth = true;
514  }
515  else
516  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
517  m_provider->msg(MSG::VERBOSE) << "Truth not found - none whatsoever!" << endmsg;
518  }
519  }
520 
521  if ( m_mcTruth && !foundTruth ) {
522 
523  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
524  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
525  }
526 
528 
529  const McEventCollection* mcevent = nullptr;
530 
532 
533  std::string keys[4] = { "GEN_AOD", "TruthEvent", "", "G4Truth" };
534 
535  std::string key = "";
536 
537  bool foundcollection = false;
538 
539  for ( int ik=0 ; ik<4 ; ik++ ) {
540 
541  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
542  m_provider->msg(MSG::VERBOSE) << "Try McEventCollection: " << keys[ik] << endmsg;
543  }
544 
545  if ( !m_provider->evtStore()->template contains<McEventCollection>(keys[ik]) ) {
546  if( m_provider->msg().level() <= MSG::VERBOSE )
547  m_provider->msg(MSG::VERBOSE) << "No McEventCollection: " << keys[ik] << endmsg;
548  continue;
549  }
550 
551  if ( m_provider->msg().level() <= MSG::VERBOSE )
552  m_provider->msg(MSG::VERBOSE) << "evtStore()->retrieve( mcevent, " << keys[ik] << " )" << endmsg;
553 
554  if ( this->template retrieve( mcevent, keys[ik] ).isFailure() ) {
555  if ( m_provider->msg().level() <= MSG::VERBOSE )
556  m_provider->msg(MSG::VERBOSE) << "Failed to get McEventCollection: " << keys[ik] << endmsg;
557  }
558  else {
560  key = keys[ik];
561  if(m_provider->msg().level() <= MSG::VERBOSE)
562  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << endmsg;
563  foundcollection = true;
564  break;
565  }
566  }
567 
569  if ( !foundcollection ) {
570  if(m_provider->msg().level() <= MSG::VERBOSE)
571  m_provider->msg(MSG::WARNING) << "No MC Truth Collections of any sort, whatsoever!!!" << endmsg;
572 
573  // m_tree->Fill();
574  // return StatusCode::FAILURE;
575 
576  return;
577  }
578 
579  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
580  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << "\tNevents " << mcevent->size() << endmsg;
581  }
582 
583  McEventCollection::const_iterator evitr = mcevent->begin();
584  McEventCollection::const_iterator evend = mcevent->end();
585 
586  unsigned ie = 0;
587  unsigned ip = 0;
588 
589  unsigned ie_ip = 0;
590 
591  while ( evitr!=evend ) {
592 
593  int ipc = 0;
594 
595  int pid = HepMC::signal_process_id((*evitr));
596 
597  //The logic should be clarified here
598  if ( pid!=0 ) {
599 
600  // For HepMC2-based builds the following two functions return
601  // GenEvent::particle_const_iterator
602  // while for HepMC3-based builds they return
603  // std::vector<HepMC3::ConstGenParticlePtr>::const_iterator
604  // see AtlasHepMC/GenEvent.h for function definitions.
605  auto pitr(HepMC::begin(**evitr));
606  const auto pend(HepMC::end(**evitr));
607 
608  while ( pitr!=pend ) {
609 
610  selectorTruth.selectTrack( *pitr++ );
611 
612  ++ipc;
613 
614  }
615 
616  }
617  ++ie;
618  ++evitr;
619 
620  if ( ipc>0 ) {
622  // m_provider->msg(MSG::VERBOSE) << "Found " << ie << "\tpid " << pid << "\t with " << ip << " TruthParticles (GenParticles)" << endmsg;
623  ++ie_ip;
624  ip += ipc;
625  }
626  }
627 
628  if(m_provider->msg().level() <= MSG::VERBOSE){
629  m_provider->msg(MSG::VERBOSE) << "Found " << ip << " TruthParticles (GenParticles) in " << ie_ip << " GenEvents out of " << ie << endmsg;
630  m_provider->msg(MSG::VERBOSE) << "selected " << selectorTruth.size() << " TruthParticles (GenParticles)" << endmsg;
631  }
632 
633  if(selectorTruth.size() > 0) foundTruth = true;
634 
635  if ( !(ip>0) ) {
636  if (m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::WARNING) << "NO TRUTH PARTICLES - returning" << endmsg;
637  return;
638  }
639 
640  }
641 
642  if ( m_doOffline && !m_mcTruth) {
643 
644  bool found_offline = false;
645 
646  for ( size_t it=0 ; it<m_offline_types.size() ; it++ ) {
647  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>( m_offline_types[it] ) ) {
648  this->template selectTracks<xAOD::TrackParticleContainer>( pselectorRef, m_offline_types[it] );
649  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( m_offline_types[it] );
650  found_offline = true;
651  }
652  else {
653  m_provider->msg(MSG::WARNING) << "Offline tracks not found: " << m_offline_types[it] << endmsg;
654  }
655  }
656 
657  if ( !found_offline ) {
658  if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
660  this->template selectTracks<Rec::TrackParticleContainer>( pselectorRef, "TrackParticleCandidate" );
661  }
662  else {
663  m_provider->msg(MSG::WARNING) << "Offline tracks not found: " << "TrackParticleCandidate" << endmsg;
664  }
665  }
666 
667  }
668 
670 
671  TrackAssociator* associator = m_associator->clone();
672 
673  // std::cout << "\tloop() loop over chains proper ..." << std::endl;
674 
676  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
677 
679 
680  // std::string& chainname = chains[ichain];
681  const std::string& chainname = m_chainNames[ichain].head();
682  const std::string& key = m_chainNames[ichain].tail();
683  const std::string& vtx_name = m_chainNames[ichain].vtx();
684 
685  // Not used left just in case
686  // const std::string& roi_name = m_chainNames[ichain].roi();
687  // const std::string& te_name = m_chainNames[ichain].element();
688  m_pTthreshold = 0;
689 
690  if ( m_chainNames[ichain].postcount() ) {
691  std::string ptvalue = m_chainNames[ichain].postvalue("pt");
692  if ( ptvalue!="" ) m_pTthreshold = std::stod(ptvalue);
693  }
694 
695 
696  unsigned decisiontype = TrigDefs::Physics;
697 
698  if ( !m_chainNames[ichain].passed() ) decisiontype = TrigDefs::includeFailedDecisions;
699 
701  // if ( decisiontype==TrigDefs::requireDecision ) std::cout << "\tSUTT TrigDefs::requireDecision " << decisiontype << std::endl;
702  // if ( decisiontype==TrigDefs::Physics ) std::cout << "\tSUTT TrigDefs::Physics " << decisiontype << std::endl;
703 
704  if ( chainname!="" && m_provider->msg().level() <= MSG::VERBOSE ) {
705 
706  m_provider->msg(MSG::VERBOSE) << "status for chain " << chainname
707  << "\tpass " << (*m_tdt)->isPassed(chainname)
708  << "\tprescale " << (*m_tdt)->getPrescale(chainname) << endmsg;
709 
710  m_provider->msg(MSG::VERBOSE) << "fetching features for chain " << chainname << endmsg;
711 
712  m_provider->msg(MSG::VERBOSE) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << endmsg;
713  }
714 
716  // std::cout << "\tstatus for chain " << chainname
717  // << "\tpass " << (*m_tdt)->isPassed( chainname )
718  // << "\tpassdt " << (*m_tdt)->isPassed( chainname, decisiontype )
719  // << "\tprescale " << (*m_tdt)->getPrescale( chainname ) << std::endl;
720 
721 
722  // m_provider->msg(MSG::INFO) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << "\t" << m_chainNames[ichain] << "\trun " << run_number << "\tevent " << event_number << endmsg;
723 
724 
725  if ( chainname!="" && !this->m_keepAllEvents && !(*m_tdt)->isPassed( chainname, decisiontype ) ) continue;
726 
729  // Trig::FeatureContainer f = (*m_tdt)->features( chainname, TrigDefs::alsoDeactivateTEs);
730 
733 
734  // tag and probe analysis processes multiple chains passed in the tag and probe tool at once so loop over vector of chains
735  std::vector<std::string> chainNames ;
736 
737  if ( !m_tnp_flag ) {
738  chainNames.push_back(m_chainNames[ichain].raw()) ;
739  }
740  else {
741  chainNames.push_back(pTnP_tool->tag());
742  chainNames.push_back(pTnP_tool->probe());
743  }
744 
745  // loop over new chainNames vector but doing the same stuff
746  for ( size_t i=0 ; i<chainNames.size() ; i++ ) {
747 
748  ChainString chainConfig = chainNames[i] ;
749  std::string chainName = chainConfig.head();
750 
751  eventp->addChain( chainNames[i] );
752 
753  TIDA::Chain& chain = eventp->back();
754 
755  if ( chainName == "" ) {
756 
758 
759  pselectorTest->clear();
760 
762 
763  // TIDARoiDescriptor roifs(true);
764 
765  // chain.addRoi( roifs );
766 
767  chain.addRoi( TIDARoiDescriptor(true) );
768 
769  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>(key) ) {
770  this->template selectTracks<xAOD::TrackParticleContainer>( pselectorTest, key );
771  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( key );
772  }
773 
774  const std::vector<TIDA::Track*>& testtracks = pselectorTest->tracks();
775 
776  chain.back().addTracks(testtracks);
777 
778  if ( vtx_name!="" ) {
779 
781 
782  m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
783 
784  std::vector<TIDA::Vertex> tidavertices;
785 
786  if ( this->select( tidavertices, vtx_name ) ) chain.back().addVertices( tidavertices );
787  }
788 
789 
790  // if ( roiInfo ) delete roiInfo;
791 
792  }
793  else {
794 
796 
797  //std::string roi_key = m_chainNames[ichain].roi();
798 
799  std::string roi_key = chainConfig.roi();
800 
801  unsigned feature_type =TrigDefs::lastFeatureOfType;
802 
803  if ( roi_key!="" ) feature_type= TrigDefs::allFeaturesOfType;
804 
806 
807  int leg = -1;
808 
809  if ( chainConfig.element()!="" ) {
810  leg = std::atoi(chainConfig.element().c_str());
811  }
812 
813  std::string rgex = roi_key;
814 
815  std::vector< TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection> > rois =
816  (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,
817  decisiontype,
818  rgex,
819  feature_type,
820  "roi",
821  leg ) );
822 
825 
826  if ( rois.empty() ) {
827  if ( !rgex.empty() ) {
828  rgex += "_probe";
829  rois = (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,
830  decisiontype,
831  rgex,
832  feature_type,
833  "roi",
834  leg ) );
835  }
836  }
837 
838  int iroi = 0;
839 
840  for ( const TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>& roi_info : rois ) {
841 
842  iroi++;
843 
847 
848  if ( roi_key=="SuperRoi" && iroi>1 ) continue;
849 
850  // std::cout << "\troi: get link " << roi_key << " ..." << std::endl;
851 
852  const ElementLink<TrigRoiDescriptorCollection> roi_link = roi_info.link;
853 
855  if ( roi_key!="" && roi_link.dataID()!=rgex ) continue;
856 
858  if ( !roi_link.isValid() ) continue;
859 
860  const TrigRoiDescriptor* const* roiptr = roi_link.cptr();
861 
862  if ( roiptr == 0 ) continue;
863 
864 
866  // std::cout << "\troi: link deref ..." << *roiptr << std::endl;
867 
868  if (m_provider->msg().level() <= MSG::VERBOSE) {
869  m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainname << " " << **roiptr << endmsg;
870  }
871 
872  TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor( TIDARoiDescriptorBuilder(**roiptr) );
873 
874  // if ( dbg ) std::cout << "\troi " << iroi << " " << *roiInfo << std::endl;
875 
877 
878  pselectorTest->clear();
879 
880  if ( this->template selectTracks<xAOD::TrackParticleContainer>( pselectorTest, roi_link, key ) ) { }
881 
882  // beamspot stuff not needed for xAOD::TrackParticles
883 
885 
886  chain.addRoi( *roiInfo );
887 
889 
890  const std::vector<TIDA::Track*>& testtracks = pselectorTest->tracks();
891 
892  chain.back().addTracks(testtracks);
893 
894 
896 
897  if ( vtx_name!="" ) {
898 
899  std::vector<TIDA::Vertex> tidavertices;
900 
901  this->select( tidavertices, roi_link, vtx_name );
902 
903  chain.back().addVertices( tidavertices );
904 
905  }
906 
907 
908 #if 0
909  if ( dbg ) {
910  std::cout << "\tTIDA analysis for chain: " << chainname << "\t key: " << key << "\t" << **roiptr << std::endl;
911  std::cout << "\tcollections: " << chain.back() << std::endl;
912  }
913 #endif
914 
915  delete roiInfo;
916 
917  }
918 
919 
920  }
921 
922  } // end of loop chainNames vector loop
923 
924 
925  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
926  m_provider->msg(MSG::VERBOSE) << "event: " << *eventp << endmsg;
927  }
928 
929  }
930 
931  // close previous loop over chains and open new one
932 
933  for ( unsigned ichain=0 ; ichain<eventp->size() ; ichain++ ) {
934 
935  TIDA::Chain& chain = (*eventp)[ichain];
936  ChainString chainConfig(chain.name());
937  const std::string& vtx_name = chainConfig.vtx();
938 
939  // skip tag chains to avoid performing standard analysis on them (done for tnp at the same time as probes)
940  if ( m_tnp_flag && chainConfig.extra().find("_tag")!=std::string::npos ) continue ;
941 
942  std::vector<TIDA::Roi*> rois ;
943 
944  if (m_tnp_flag) {
945  // needs to be done AFTER retrieving offline tracks as pselectorRef passed as arguement, hence restructuring
946  rois = pTnP_tool->GetRois( eventp->chains(), pselectorRef, &filterRef, m_invmass, m_invmass_obj );
947  }
948  else {
949  rois.reserve( chain.size() );
950  for ( size_t ir=0 ; ir<chain.size() ; ir++ ) {
951  rois.push_back( &(chain.rois()[ir]) );
952  }
953  }
954 
955  // now loop over the rois (again)
956 
957  for ( unsigned iroi=0 ; iroi<rois.size() ; iroi++ ) {
958 
959  if ( this->filterOnRoi() ) {
960  filterRef.setRoi( &(rois.at(iroi)->roi() ) );
961  filterRef.containtracks( m_containTracks );
962  }
963  else filterRef.setRoi( 0 );
964 
965  test_tracks.clear();
966 
967  // this block is before the track retrieval in the original, is it working the same here?
968 
982 
983  if ( m_provider->msg().level() <= MSG::VERBOSE )
984  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
985 
986  if ( m_mcTruth ) {
987  if ( this->filterOnRoi() ) filter_truth.setRoi( &(rois.at(iroi)->roi() ) );
988  ref_tracks = pselectorRef->tracks(&filter_truth);
989  }
990  else { // ie. if ( m_doOffline )
991  ref_tracks = pselectorRef->tracks(&filterRef) ;
992  }
993 
994  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
995  m_provider->msg(MSG::VERBOSE) << "ref tracks.size() " << pselectorRef->tracks().size() << endmsg;
996  for ( int ii=pselectorRef->tracks().size() ; ii-- ; ) {
997  m_provider->msg(MSG::VERBOSE) << " ref track " << ii << " " << *pselectorRef->tracks()[ii] << endmsg;
998  }
999  }
1000 
1001  test_tracks.clear();
1002 
1003 
1004  for ( unsigned itrk=0 ; itrk<rois.at(iroi)->tracks().size() ; itrk++ ) {
1005  test_tracks.push_back(&(rois.at(iroi)->tracks().at(itrk)));
1006  }
1007 
1009  // std::cout << "sutt track multiplicities: offline " << offline_tracks.size() << "\ttest " << test_tracks.size() << std::endl;
1010 
1012 
1013  beamline[0] = pselectorTest->getBeamX();
1014  beamline[1] = pselectorTest->getBeamY();
1015  beamline[2] = pselectorTest->getBeamZ();
1016 
1017  beamline[3] = vertices.size();
1018 
1026  // m_manalysis->setvertices( vertices.size() ); /// what is this for ??? /// is this thread safe ???
1027 
1030 
1031  if ( m_runPurity ) {
1032 
1033  if ( this->getUseHighestPT() ) HighestPTOnly( test_tracks );
1034 
1035  if ( m_pTthreshold>0 ) FilterPT( test_tracks, m_pTthreshold );
1036 
1038  m_NRois++;
1039  m_NRefTracks += test_tracks.size();
1040  m_NTestTracks += ref_tracks.size();
1041 
1043  associator->match( test_tracks, ref_tracks );
1044 
1045  m_manalysis->execute( test_tracks, ref_tracks, associator, eventp, beamline );
1046 
1047  }
1048  else {
1049 
1051  if ( this->getUseHighestPT() ) HighestPTOnly( ref_tracks );
1052 
1054 
1055  if ( m_pTthreshold>0 ) FilterPT( ref_tracks, m_pTthreshold );
1056 
1059  // if ( ref_tracks.size()==0 ) continue;
1060 
1062  m_NRois++;
1063  m_NRefTracks += ref_tracks.size();
1064  m_NTestTracks += test_tracks.size();
1065 
1067  associator->match( ref_tracks, test_tracks );
1068 
1073  // m_manalysis->setroi( &rois.at(iroi)->roi() );
1074  m_manalysis->execute( ref_tracks, test_tracks, associator, eventp, beamline, &(rois.at(iroi)->roi()) );
1075 
1076  if ( vtx_name!="" ) {
1078  std::vector<TIDA::Vertex> vr = rois.at(iroi)->vertices();
1079  std::vector<TIDA::Vertex*> vtx_rec;
1080  for ( unsigned iv=0 ; iv<vr.size() ; iv++ ) vtx_rec.push_back( &vr[iv] );
1081 
1082  std::vector<TIDA::Vertex*> vtx;
1083  if ( this->getVtxIndex()<0 ) {
1084  for ( unsigned iv=0 ; iv<vertices.size() ; iv++ ) vtx.push_back( &vertices[iv] );
1085  }
1086  else {
1087  if ( vertices.size()>unsigned(this->getVtxIndex()) ) vtx.push_back( &vertices[this->getVtxIndex()] );
1088  }
1089 
1090  m_manalysis->execute_vtx( vtx, vtx_rec, eventp );
1091  }
1092 
1093  }
1094 
1095  if ( m_manalysis->debug() ) {
1096  m_provider->msg(MSG::INFO) << "Missing track for " << m_chainNames[ichain]
1097  << "\trun " << run_number
1098  << "\tevent " << event_number
1099  << "\tlb " << lumi_block << endmsg;
1100  }
1101 
1102  }
1103 
1104  }
1105 
1106  delete associator;
1107 
1108  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
1109  m_provider->msg(MSG::VERBOSE) << "\n\nEvent " << *eventp << endmsg;
1110  }
1111 
1112  }

◆ mcTruth()

bool T_AnalysisConfig< T >::mcTruth ( ) const
inlineinherited

Definition at line 261 of file T_AnalysisConfig.h.

261 { return m_mcTruth; }

◆ monTool()

template<typename T , typename A = AnalysisR3_Tier0>
ToolHandle<GenericMonitoringTool>* T_AnalysisConfigR3_Tier0< T, A >::monTool ( )
inline

Definition at line 225 of file T_AnalysisConfigR3_Tier0.h.

225 { return m_monTool; }

◆ name()

const std::string& T_AnalysisConfig< T >::name ( ) const
inlineinherited

Definition at line 235 of file T_AnalysisConfig.h.

235 {return m_analysisInstanceName;}

◆ processElectrons()

unsigned T_AnalysisConfig< T >::processElectrons ( TrigTrackSelector &  selectorRef,
std::vector< TrackTrigObject > *  elevec = 0,
const unsigned int  selection = 0,
bool  raw_track = false,
double  ETOffline = 0,
const std::string &  containerName = "ElectronAODCollection" 
)
inlineprotectedinherited

select offline electrons

Definition at line 703 of file T_AnalysisConfig.h.

713  {
714 
715  m_provider->msg(MSG::DEBUG) << "Fetching offline electrons: " << containerName << endmsg;
716 
717  selectorRef.clear();
718 
719 # ifdef XAODTRACKING_TRACKPARTICLE_H
720  typedef xAOD::ElectronContainer Container;
721 # else
722  typedef ElectronContainer Container;
723 # endif
724 
725 
726  const Container* container = 0;
727 
728  if( ! m_provider->evtStore()->template contains<Container>(containerName) ) {
729  m_provider->msg(MSG::WARNING) << "Error No Electron Container " << containerName << " !" << endmsg;
730  return 0;
731  }
732 
733  StatusCode sc = retrieve( container, containerName);
734  if( sc.isFailure() || !container ) {
735  m_provider->msg(MSG::WARNING) << "Error retrieving container: " << containerName << " !" << endmsg;
736  return 0;
737  }
738 
739  m_provider->msg(MSG::DEBUG) << "Event with " << container->size() << " Electron object(s) " << endmsg;
740 
741  Container::const_iterator elec = container->begin();
742  Container::const_iterator elec_end = container->end();
743 
744  for( ; elec!=elec_end ; ++elec ){
745  //m_provider->msg(MSG::DEBUG) << " Electron " << (*elec)
746  // << ", eta " << (*elec)->eta()
747  // << ", phi " << (*elec)->phi()
748  // << ", ET " << (*elec)->pt()
749  // << ", author " << (*elec)->author()
750  // << ", trackParticle " << (*elec)->trackParticle()
751  // << ", conversion " << (*elec)->conversion()
752  // << ", mediumPP " << ((*elec)->isem(egammaPID::ElectronMediumPP)==0)
753  // << endmsg;
754 
755  bool good_electron = false;
756 # ifdef XAODTRACKING_TRACKPARTICLE_H
757  good_electron = TIDA::isGoodOffline( *(*elec), selection, ETOffline );
758 # else
759  good_electron = TIDA::isGoodOffline( *(*elec));
760 # endif
761 
762  if (good_electron) {
763  const xAOD::Electron_v1& eleduff = *(*elec);
764  long unsigned eleid = (unsigned long)(&eleduff) ;
765  TrackTrigObject eleobj = TrackTrigObject( (*elec)->eta(),
766  (*elec)->phi(),
767  (*elec)->pt(),
768  0,
769  (*elec)->type(),
770  eleid );
771 
772  bool trk_added ;
773  if ( raw_track ) trk_added = selectorRef.selectTrack( xAOD::EgammaHelpers::getOriginalTrackParticle( *elec ) );
774  else trk_added = selectorRef.selectTrack( (*elec)->trackParticle() );
775 
776  if (trk_added) eleobj.addChild( selectorRef.tracks().back()->id() );
777  if (elevec) elevec->push_back( eleobj );
778  }
779  }
780 
781  return selectorRef.tracks().size();
782  }

◆ processMuons()

unsigned T_AnalysisConfig< T >::processMuons ( TrigTrackSelector &  selectorRef,
const unsigned int  selection = 0,
double  ETOffline = 0,
const std::string &  containerName = "StacoMuonCollection" 
)
inlineprotectedinherited

select offlinqe muons

Definition at line 789 of file T_AnalysisConfig.h.

796  {
797 
798 # ifdef XAODTRACKING_TRACKPARTICLE_H
799  typedef xAOD::MuonContainer Container;
800 # else
801  typedef Analysis::MuonContainer Container;
802 # endif
803 
804  m_provider->msg(MSG::DEBUG) << " Offline muons (" << containerName << ")" << endmsg;
805 
806  selectorRef.clear();
807 
808  const Container* container = 0;
809 
810  if( ! m_provider->evtStore()->template contains<Container>(containerName) ) {
811  m_provider->msg(MSG::WARNING) << "Error No MuonCollection" << containerName << " !" << endmsg;
812  return 0;
813  }
814 
815  StatusCode sc = retrieve( container, containerName );
816  if( sc.isFailure() || !container ) {
817  m_provider->msg(MSG::WARNING) << "Error retrieving " << containerName << " !" << endmsg;
818  return 0;
819  }
820 
821  auto muon = container->begin();
822  auto muon_end = container->end();
823 
824  // std::cout << "SUTT Offline muons " << container->size() << "\t threshold " << ETOffline << std::endl;
825 
826  for( ; muon!=muon_end ; ++muon ){
827 # ifdef XAODTRACKING_TRACKPARTICLE_H
828  if ( TIDA::isGoodOffline(*(*muon), selection, ETOffline ) ) selectorRef.selectTrack(*((*muon)->inDetTrackParticleLink()));
829 # else
830  if ( TIDA::isGoodOffline(*(*muon)) ) selectorRef.selectTrack((*muon)->inDetTrackParticle());
831 # endif
832  }
833 
834 
835  // std::cout << "SUTT found " << selectorRef.tracks().size() << " muons for " << containerName << std::endl;
836  m_provider->msg(MSG::DEBUG) << "found " << selectorRef.tracks().size() << " muons for " << containerName << endmsg;
837 
838  return selectorRef.tracks().size();
839 }

◆ processTaus()

unsigned T_AnalysisConfig< T >::processTaus ( TrigTrackSelector &  selectorRef,
std::vector< TrackTrigObject > *  tauvec = 0,
const unsigned  selection = 0,
int  requireNtracks = 0,
double  EtCutOffline = 0,
const std::string &  containerName = "TauRecContainer" 
)
inlineprotectedinherited

select offline taus

Definition at line 846 of file T_AnalysisConfig.h.

856  {
857 
858 # ifdef XAODTRACKING_TRACKPARTICLE_H
859  typedef xAOD::TauJetContainer Container;
860 # else
861  typedef Analysis::TauJetContainer Container;
862 # endif
863 
864  selectorRef.clear();
865 
866  const Container* container = 0;
867 
868  selectorRef.clear();
869 
870  m_provider->msg(MSG::DEBUG) << " Offline taus " << containerName << endmsg;
871 
872  if ( !m_provider->evtStore()->template contains<Container>(containerName)) {
873  m_provider->msg(MSG::WARNING) << " Offline taus not found" << endmsg;
874  return 0;
875  }
876 
877  StatusCode sc = retrieve( container, containerName);
878  if (sc != StatusCode::SUCCESS) {
879  m_provider->msg(MSG::WARNING) << " Offline tau retrieval not successful" << endmsg;
880  return 0;
881  }
882 
883  Container::const_iterator tau = container->begin();
884  Container::const_iterator tau_end = container->end();
885 
886 
887  for ( ; tau!=tau_end ; ++tau ) {
888 
889 # ifdef XAODTRACKING_TRACKPARTICLE_H
890  // unsigned N = (*tau)->nTracks();
891 
892 # ifndef XAODTAU_VERSIONS_TAUJET_V3_H
893  int N = (*tau)->nTracks();
894  // std::cout << "SUTT no tau detail " << N << "\t3prong: " << doThreeProng << std::endl;
895 # else
896  int N=0;
897  (*tau)->detail( xAOD::TauJetParameters::nChargedTracks, N );
898  // std::cout << "SUTT tau detail: N " << N << "\t3prong: " << doThreeProng << std::endl;
899 # endif
900 
901 # else
902  unsigned N = (*tau)->numTrack();
903 # endif
904 
905 
906  bool good_tau = false;
907 # ifdef XAODTRACKING_TRACKPARTICLE_H
908  good_tau = TIDA::isGoodOffline( *(*tau), selection, requireNtracks, EtCutOffline );
909 # else
910  good_tau = TIDA::isGoodOffline( *(*tau), requireNtracks, EtCutOffline );
911 # endif
912 
913  // std::cout << "SUTT tau ntracks: " << N << "\tgoodtau: " << good_tau << "\tpt: " << (*tau)->p4().Et() << "\t3prong: " << doThreeProng << std::endl;
914 
915  if (good_tau){
916  const xAOD::TauJet_v3& duff = *(*tau);
917  long unsigned tauid = (unsigned long)(&duff) ;
918  TrackTrigObject tauobj = TrackTrigObject( (*tau)->eta(),
919  (*tau)->phi(),
920  (*tau)->pt(),
921  0,
922  (*tau)->type(),
923  tauid );
924 
925  bool trk_added = false;
926 
927  for ( unsigned i=N ; i-- ; ) {
928 # ifdef XAODTAU_TAUTRACK_H
929 
930  std::vector< ElementLink<xAOD::TrackParticleContainer> > alink = (*tau)->track(i)->trackLinks();
931 
932  trk_added = false;
933 
934  for ( size_t ilink=0 ; ilink<alink.size() ; ilink++ ) {
935  if ( alink[ilink].isValid() ) trk_added = selectorRef.selectTrack((*alink[ilink]));
936  }
938  // trk_added = selectorRef.selectTrack((*tau)->track(i)->track());
940 # else
941  trk_added = selectorRef.selectTrack((*tau)->track(i));
942 # endif
943  if ( trk_added ) tauobj.addChild( selectorRef.tracks().back()->id() );
944  }
945  if ( tauvec ) tauvec->push_back( tauobj );
946  }
947  }
948 
949  return selectorRef.tracks().size();
950 
951 }

◆ referenceChains()

const std::string T_AnalysisConfig< T >::referenceChains ( ) const
inlineinherited

Definition at line 244 of file T_AnalysisConfig.h.

244  {
245  std::string name;
246  for(unsigned int i=0; i<m_chainNames[1].size(); i++)
247  name += (m_chainNames[1][i]+"::"+m_types[1][i]+"::"+m_keys[1][i]+" ");
248  return name;
249  }

◆ releaseData() [1/2]

const std::string& T_AnalysisConfig< T >::releaseData ( ) const
inlineinherited

Definition at line 273 of file T_AnalysisConfig.h.

273 { return m_releaseData; }

◆ releaseData() [2/2]

void T_AnalysisConfig< T >::releaseData ( const std::string &  s)
inlineinherited

Definition at line 274 of file T_AnalysisConfig.h.

274 { m_releaseData = s; }

◆ requireDecision()

bool T_AnalysisConfig< T >::requireDecision ( ) const
inlineinherited

Definition at line 288 of file T_AnalysisConfig.h.

288 { return m_requireDecision; }

◆ retrieve()

StatusCode T_AnalysisConfig< T >::retrieve ( Collection const *&  collection,
const std::string &  key = "" 
)
inlineprotectedinherited

old implementation - leave in place until after the full validation ... return m_provider->evtStore()->retrieve( container, containerName);

commented code intentionally left for development purposes ... std::cout << "\t\t\t T_AnalysisConfig::selectTracks() - > TrackSelector" << std::endl;

Definition at line 573 of file T_AnalysisConfig.h.

573  {
576  if ( m_provider->evtStore()->template contains<Collection>( key ) ) {
577  SG::ReadHandle<Collection> handle(key);
578  if ( handle.isValid() ) {
581  collection = handle.cptr();
582  return StatusCode::SUCCESS;
583  }
584  }
585  return StatusCode::FAILURE;
586  }

◆ select() [1/3]

bool T_AnalysisConfig< T >::select ( std::vector< TIDA::Vertex > &  vertices,
const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotectedinherited

Definition at line 371 of file T_AnalysisConfig.h.

373  {
374 
375  m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer for key: " << key << endmsg;
376 
377  std::pair< xAOD::VertexContainer::const_iterator,
378  xAOD::VertexContainer::const_iterator > vtx_itrpair = this->template getCollection<xAOD::VertexContainer>( roi_link, key );
379 
380  if ( vtx_itrpair.first == vtx_itrpair.second ) {
381  m_provider->msg(MSG::WARNING) << "\tNo xAOD::Vertex collection for key " << key << endmsg;
382  return false;
383  }
384 
385  m_provider->msg(MSG::DEBUG) << "\txAOD::VertexContainer found with size " << (vtx_itrpair.second - vtx_itrpair.first)
386  << "\t:" << key << endmsg;
387 
388  return select( vertices, vtx_itrpair.first, vtx_itrpair.second );
389  }

◆ select() [2/3]

bool T_AnalysisConfig< T >::select ( std::vector< TIDA::Vertex > &  vertices,
const std::string &  key = "" 
)
inlineprotectedinherited

Definition at line 394 of file T_AnalysisConfig.h.

394  {
395 
396  m_provider->msg(MSG::VERBOSE) << "fetching AOD vertex container" << endmsg;
397 
398  const xAOD::VertexContainer* xaodVtxCollection = 0;
399 
400  if ( retrieve( xaodVtxCollection, key ).isFailure()) {
401  m_provider->msg(MSG::WARNING) << "xAOD vertex container not found with key " << key << endmsg;
402  return false;
403  }
404 
405  if ( xaodVtxCollection!=0 ) {
406 
407  m_provider->msg(MSG::VERBOSE) << "xAOD vertex container " << xaodVtxCollection->size() << " entries" << endmsg;
408 
409  return select( vertices, xaodVtxCollection->begin(), xaodVtxCollection->end() );
410 
411 #if 0
412 
413  xAOD::VertexContainer::const_iterator vtxitr = xaodVtxCollection->begin();
414 
415  for ( ; vtxitr != xaodVtxCollection->end(); vtxitr++ ) {
416  if ( (*vtxitr)->nTrackParticles()>0 && (*vtxitr)->vertexType()!=0 ) {
417  vertices.push_back( TIDA::Vertex( (*vtxitr)->x(),
418  (*vtxitr)->y(),
419  (*vtxitr)->z(),
421  (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
422  (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
423  (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
424  (*vtxitr)->nTrackParticles(),
426  (*vtxitr)->chiSquared(),
427  (*vtxitr)->numberDoF() ) );
428  }
429  }
430 
431 #endif
432 
433  }
434 
435  return true;
436  }

◆ select() [3/3]

bool T_AnalysisConfig< T >::select ( std::vector< TIDA::Vertex > &  vertices,
xAOD::VertexContainer::const_iterator  vtx_start,
xAOD::VertexContainer::const_iterator  vtx_end 
)
inlineprotectedinherited

variances

quality

Definition at line 342 of file T_AnalysisConfig.h.

344  {
345 
346  xAOD::VertexContainer::const_iterator vtxitr = vtx_start;
347 
348  for ( ; vtxitr!=vtx_end ; ++vtxitr ) {
349  if ( (*vtxitr)->vertexType()!=0 ) {
350  m_provider->msg(MSG::VERBOSE) << "\tvertex " << (*vtxitr)->z() << endmsg;
351 
352  vertices.push_back( TIDA::Vertex( (*vtxitr)->x(),
353  (*vtxitr)->y(),
354  (*vtxitr)->z(),
356  (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
357  (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
358  (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
359  (*vtxitr)->nTrackParticles(),
361  (*vtxitr)->chiSquared(),
362  (*vtxitr)->numberDoF() ) );
363 
364  }
365  }
366 
367  return true;
368  }

◆ selectionChains()

const std::string T_AnalysisConfig< T >::selectionChains ( ) const
inlineinherited

Definition at line 251 of file T_AnalysisConfig.h.

251  {
252  std::string name;
253  for(unsigned int i=0; i<m_chainNames[2].size(); i++)
254  name += (m_chainNames[2][i]+"::"+m_types[2][i]+"::"+m_keys[2][i]+" ");
255  return name;
256  }

◆ selectTracks() [1/4]

bool T_AnalysisConfig< T >::selectTracks ( TrigTrackSelector *  selector,
const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotectedinherited

will need this printout for debugging the feature access, so leave this commented until it has been properly debugged, then it can be removed

will not use the te name here, but keep it on just the same for the time being, for subsequent development

Definition at line 441 of file T_AnalysisConfig.h.

444  {
445 
446 
449  // std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;
450 
453  std::string key_collection = key;
454  std::string key_tename = "";
455  size_t pos = key_collection.find("/");
456  if ( pos!=std::string::npos ) {
457  key_collection = key.substr( pos+1, key.size()-pos );
458  key_tename = key.substr( 0, pos );
459  }
460 
461  std::pair< typename Collection::const_iterator,
462  typename Collection::const_iterator > itrpair;
463 
464  SG::ReadHandle<Collection> handle(key);
465 
466  CLID checkCLID;
467  const std::string* keyStr = m_provider->evtStore()->keyToString(roi_link.key(), checkCLID);
468  m_provider->msg(MSG::DEBUG) << "Requesting range over (" << key << ") associated to ROI from " << (keyStr == nullptr ? "UNKNOWN" : *keyStr) << endmsg;
469 
470  itrpair = (*m_tdt)->associateToEventView( handle, roi_link );
471 
472  if ( itrpair.first != itrpair.second ) {
473  selector->selectTracks( itrpair.first, itrpair.second );
474  return true;
475  }
476  else {
477  m_provider->msg(MSG::DEBUG) << "TDT TrackFeature collection (" << key << ") is empty " << endmsg;
478  return false;
479  }
480  }

◆ selectTracks() [2/4]

bool T_AnalysisConfig< T >::selectTracks ( TrigTrackSelector *  selector,
const std::string &  key 
)
inlineprotectedinherited

commented code intentionally left for development purposes ...

Definition at line 591 of file T_AnalysisConfig.h.

591  {
592  if ( key!="" ) {
593  SG::ReadHandle<Collection> handle(key);
594  if ( handle.isValid() ) {
596  // std::cout << "\t\t\t T_AnalysisConfig::selectTracks() - > TrackSelector" << std::endl;
597  selector->selectTracks( handle.cptr() );
598  return true;
599  }
600  }
601  return false;
602  }

◆ selectTracks() [3/4]

bool T_AnalysisConfig< T >::selectTracks ( TrigTrackSelector *  selector,
Trig::FeatureContainer::combination_const_iterator  citr,
const std::string &  key = "" 
)
inlineprotectedinherited

lagacy run 2 access

Definition at line 487 of file T_AnalysisConfig.h.

487  {
488 
489  // std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;
490 
491  std::string key_collection = key;
492  std::string key_tename = "";
493  size_t pos = key_collection.find("/");
494  if ( pos!=std::string::npos ) {
495  key_collection = key.substr( pos+1, key.size()-pos );
496  key_tename = key.substr( 0, pos );
497  }
498 
499  std::vector< Trig::Feature<Collection> > trackcollections = citr->get<Collection>( key_collection, TrigDefs::alsoDeactivateTEs, key_tename );
500  if ( !trackcollections.empty() ) {
501  // NB!! a combination should never have more than one entry for a track collection from a single algorithm, for single object triggers
502  for ( unsigned ifeat=0 ; ifeat<trackcollections.size() ; ifeat++ ) {
503  Trig::Feature<Collection> trackfeature = trackcollections.at(ifeat);
504  if ( !trackfeature.empty() ) {
505  // actually select the tracks from this roi at last!!
506  const Collection* trigtracks = trackfeature.cptr();
507  selector->selectTracks( trigtracks );
508  }
509  }
510  return true;
511  }
512  else {
513  m_provider->msg(MSG::DEBUG) << "TDT TrackFeature collection (" << key << ") is empty " << endmsg;
514  return false;
515  }
516  }

◆ selectTracks() [4/4]

bool T_AnalysisConfig< T >::selectTracks ( TrigTrackSelector *  selector,
Trig::FeatureContainer::combination_const_iterator  citr,
const TrigInDetTrackTruthMap *  truthmap,
const std::string &  key = "",
unsigned  index = 0 
)
inlineprotectedinherited

NB: because we want to use this for the L2Star chains, we have to use this method, not the above method without the TruthMap argument - if we don't want/have the TruthMap, just set the pointer to 0 - there should be abetter way to do this, but shan't worry about it now.

get the correspondiong TE

get all the named collections attached to the TE

now got the collectionVector, can navigate through this

NB: this is safer than using index as an index, ie collectionVector[index] since it will do nothing if index is out of range, although it will be a little slower

useful for debug

Definition at line 523 of file T_AnalysisConfig.h.

523  {
524 
525  // std::cout << "try " << key << "\t" << m_provider->evtStore()->template transientContains<Collection>(key) << std::endl;
526 
527  std::vector< Trig::Feature<Collection> > trackcollections = citr->get<Collection>( key, TrigDefs::alsoDeactivateTEs );
528  if ( !trackcollections.empty() ) {
529 
530  const HLT::NavigationCore* nc = (*m_tdt)->ExperimentalAndExpertMethods().getNavigation();
531 
532  // NB!! a combination should never have more than one entry for a track collection from a single algorithm,
533  // if ( trackcollections.size()>1 ) std::cerr << "SUTT OH NO!!!!!!!!" << endmsg;
534  // maybe a bit dodgy, if we really do have multiple objects returned, but that should only be for
535  // multiple object triggers - then probably none of this would work anyhow
536  for ( unsigned ifeat=0 ; ifeat<trackcollections.size() ; ifeat++ ) {
537  // std::cout << "selectTracks() ifeat=" << ifeat << "\tkey " << key << "\t(truthmap)" << std::endl;
538  Trig::Feature<Collection> trackfeature = trackcollections.at(ifeat);
539 
541  const HLT::TriggerElement* te = trackfeature.te();
542 
544  std::vector< const Collection* > collectionVector;
545  if ( !const_cast<HLT::NavigationCore *>(nc)->getFeatures( te, collectionVector, key ) ) return false;
546 
547  // std::cout << "foundok " << foundok << "\tsize " << collectionVector.size() << std::endl;
548 
550 
551  for ( unsigned iv=collectionVector.size() ; iv-- ; ) {
555  if ( index!=iv ) continue;
557  // m_provider->msg(MSG::DEBUG) << "TDT TrackFeature->size() " << collectionVector[iv]->size() << " (" << key << ")" << endmsg;
558  selector->selectTracks( collectionVector[iv], truthmap );
559  break;
560  }
561  }
562  return true;
563  }
564  else {
565  m_provider->msg(MSG::DEBUG) << "TDT TrackFeature collection (" << key << ") is empty" << endmsg;
566  return false;
567  }
568  }

◆ selectTracksNotEmpty()

bool T_AnalysisConfig< T >::selectTracksNotEmpty ( TrigTrackSelector *  selector,
const std::string &  key 
)
inlineprotectedinherited

Definition at line 608 of file T_AnalysisConfig.h.

608  {
609  const Collection* collection = nullptr;
610  if ( key.empty() ) return false;
611  if ( !m_provider->evtStore()->template contains<Collection>( key ) ) return false;
612 
613  StatusCode sc = retrieve( collection, key );
614 
615  if ( !( sc.isSuccess() && collection ) ) return false;
616 
617  m_provider->msg(MSG::DEBUG) << "SG Collection->size() " << collection->size() << " (" << key << ")" << endmsg;
618 
619  // added to fix muon samples bug
620  if ( collection->size() == 0 ) {
621  m_provider->msg(MSG::WARNING) << "no particles in collection" << endmsg;
622  return false;
623  }
624 
625  selector->selectTracks( collection );
626  return true;
627  }

◆ set_monTool()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::set_monTool ( ToolHandle< GenericMonitoringTool > *  m)
inline

Definition at line 223 of file T_AnalysisConfigR3_Tier0.h.

223 { m_monTool=m; }

◆ setBeamX()

void T_AnalysisConfig< T >::setBeamX ( double  d)
inlineinherited

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamX=d; }

◆ setBeamY()

void T_AnalysisConfig< T >::setBeamY ( double  d)
inlineinherited

Definition at line 264 of file T_AnalysisConfig.h.

264 { m_beamY=d; }

◆ setBeamZ()

void T_AnalysisConfig< T >::setBeamZ ( double  d)
inlineinherited

Definition at line 265 of file T_AnalysisConfig.h.

265 { m_beamZ=d; }

◆ setFilterOnRoi()

bool T_AnalysisConfig< T >::setFilterOnRoi ( bool  b)
inlineinherited

Definition at line 285 of file T_AnalysisConfig.h.

285 { return m_filterOnRoi=b; }

◆ setGenericFlag()

void T_AnalysisConfig< T >::setGenericFlag ( bool  b)
inlineinherited

Definition at line 271 of file T_AnalysisConfig.h.

271 { m_genericFlag=b; }

◆ setMCTruth()

void T_AnalysisConfig< T >::setMCTruth ( bool  b = true)
inlineinherited

Definition at line 260 of file T_AnalysisConfig.h.

260 { m_mcTruth=b; }

◆ setMCTruthRef()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setMCTruthRef ( bool  b)
inline

Definition at line 217 of file T_AnalysisConfigR3_Tier0.h.

217 { m_mcTruth=b; }

◆ setOfflineRef()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setOfflineRef ( bool  b)
inline

Definition at line 219 of file T_AnalysisConfigR3_Tier0.h.

219 { m_doOffline=b; }

◆ setParentPdgID()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setParentPdgID ( int  i = 0)
inline

Definition at line 215 of file T_AnalysisConfigR3_Tier0.h.

215 { m_parent_pdgID=i; }

◆ setPdgID()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setPdgID ( int  i = 0)
inline

Definition at line 213 of file T_AnalysisConfigR3_Tier0.h.

213 { m_pdgID=i; }

◆ setRequireDecision()

void T_AnalysisConfig< T >::setRequireDecision ( bool  b)
inlineinherited

Definition at line 287 of file T_AnalysisConfig.h.

287 { m_requireDecision=b; }

◆ setRunPurity()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setRunPurity ( bool  b)
inline

Definition at line 205 of file T_AnalysisConfigR3_Tier0.h.

205 { m_runPurity=b; }

◆ setShifter()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setShifter ( bool  b)
inline

Definition at line 207 of file T_AnalysisConfigR3_Tier0.h.

207 { m_shifter=b; }

◆ setTypes()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::setTypes ( const std::vector< std::string > &  t)
inline

Definition at line 221 of file T_AnalysisConfigR3_Tier0.h.

221 { m_types=t; }

◆ setUseHighestPT()

void T_AnalysisConfig< T >::setUseHighestPT ( bool  b)
inlineinherited

Definition at line 278 of file T_AnalysisConfig.h.

278 { m_useHighestPT=b; }

◆ setVtxIndex()

void T_AnalysisConfig< T >::setVtxIndex ( int  i)
inlineinherited

Definition at line 281 of file T_AnalysisConfig.h.

281 { m_vtxIndex=i; }

◆ testChains()

const std::string T_AnalysisConfig< T >::testChains ( ) const
inlineinherited

Definition at line 237 of file T_AnalysisConfig.h.

237  {
238  std::string name;
239  for(unsigned int i=0; i<m_chainNames[0].size(); i++)
240  name += (m_chainNames[0][i]+"::"+m_types[0][i]+"::"+m_keys[0][i]+" ");
241  return name;
242  }

◆ useBeamCondSvc()

template<typename T , typename A = AnalysisR3_Tier0>
void T_AnalysisConfigR3_Tier0< T, A >::useBeamCondSvc ( bool  b)
inline

Definition at line 209 of file T_AnalysisConfigR3_Tier0.h.

209 { m_useBeamCondSvc = b; }

Member Data Documentation

◆ m_analyses

template<typename T , typename A = AnalysisR3_Tier0>
std::vector<A*> T_AnalysisConfigR3_Tier0< T, A >::m_analyses
protected

Definition at line 1257 of file T_AnalysisConfigR3_Tier0.h.

◆ m_analysis

TrackAnalysis* T_AnalysisConfig< T >::m_analysis
protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

std::string T_AnalysisConfig< T >::m_analysisInstanceName
protectedinherited

Definition at line 965 of file T_AnalysisConfig.h.

◆ m_associator

TrackAssociator* T_AnalysisConfig< T >::m_associator
protectedinherited

Definition at line 985 of file T_AnalysisConfig.h.

◆ m_beamX

double T_AnalysisConfig< T >::m_beamX
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_beamY

double T_AnalysisConfig< T >::m_beamY
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_beamZ

double T_AnalysisConfig< T >::m_beamZ
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_chainNames

template<typename T , typename A = AnalysisR3_Tier0>
std::vector<ChainString> T_AnalysisConfigR3_Tier0< T, A >::m_chainNames
protected

Definition at line 1256 of file T_AnalysisConfigR3_Tier0.h.

◆ m_containTracks

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_containTracks
protected

Definition at line 1289 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doBjets

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doBjets
protected

Definition at line 1264 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doElectrons

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doElectrons
protected

Definition at line 1262 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doMuons

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doMuons
protected

Definition at line 1261 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doOffline

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doOffline
protected

Definition at line 1260 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doTaus

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doTaus
protected

Definition at line 1263 of file T_AnalysisConfigR3_Tier0.h.

◆ m_doTauThreeProng

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_doTauThreeProng
protected

Definition at line 1265 of file T_AnalysisConfigR3_Tier0.h.

◆ m_filterOnRoi

bool T_AnalysisConfig< T >::m_filterOnRoi
protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

◆ m_filters

std::vector< std::vector<TrackFilter*> > T_AnalysisConfig< T >::m_filters
protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_first

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_first
protected

Definition at line 1287 of file T_AnalysisConfigR3_Tier0.h.

◆ m_genericFlag

int T_AnalysisConfig< T >::m_genericFlag
protectedinherited

Definition at line 992 of file T_AnalysisConfig.h.

◆ m_invmass

template<typename T , typename A = AnalysisR3_Tier0>
TIDA::Histogram<float>* T_AnalysisConfigR3_Tier0< T, A >::m_invmass
protected

Definition at line 1297 of file T_AnalysisConfigR3_Tier0.h.

◆ m_invmass_obj

template<typename T , typename A = AnalysisR3_Tier0>
TIDA::Histogram<float>* T_AnalysisConfigR3_Tier0< T, A >::m_invmass_obj
protected

Definition at line 1298 of file T_AnalysisConfigR3_Tier0.h.

◆ m_keepAllEvents

bool T_AnalysisConfig< T >::m_keepAllEvents
protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_keys

std::vector< std::vector<std::string> > T_AnalysisConfig< T >::m_keys
protectedinherited

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_manalysis

template<typename T , typename A = AnalysisR3_Tier0>
A* T_AnalysisConfigR3_Tier0< T, A >::m_manalysis

Definition at line 229 of file T_AnalysisConfigR3_Tier0.h.

◆ m_mcTruth

bool T_AnalysisConfig< T >::m_mcTruth
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_monTool

template<typename T , typename A = AnalysisR3_Tier0>
ToolHandle<GenericMonitoringTool>* T_AnalysisConfigR3_Tier0< T, A >::m_monTool
protected

Definition at line 1295 of file T_AnalysisConfigR3_Tier0.h.

◆ m_NRefTracks

template<typename T , typename A = AnalysisR3_Tier0>
int T_AnalysisConfigR3_Tier0< T, A >::m_NRefTracks
protected

Definition at line 1278 of file T_AnalysisConfigR3_Tier0.h.

◆ m_NRois

template<typename T , typename A = AnalysisR3_Tier0>
int T_AnalysisConfigR3_Tier0< T, A >::m_NRois
protected

output stats

Definition at line 1277 of file T_AnalysisConfigR3_Tier0.h.

◆ m_NTestTracks

template<typename T , typename A = AnalysisR3_Tier0>
int T_AnalysisConfigR3_Tier0< T, A >::m_NTestTracks
protected

Definition at line 1279 of file T_AnalysisConfigR3_Tier0.h.

◆ m_offline_types

template<typename T , typename A = AnalysisR3_Tier0>
std::vector<std::string> T_AnalysisConfigR3_Tier0< T, A >::m_offline_types
protected

Definition at line 1268 of file T_AnalysisConfigR3_Tier0.h.

◆ m_outputFileName

template<typename T , typename A = AnalysisR3_Tier0>
std::string T_AnalysisConfigR3_Tier0< T, A >::m_outputFileName
protected

Definition at line 1271 of file T_AnalysisConfigR3_Tier0.h.

◆ m_parent_pdgID

template<typename T , typename A = AnalysisR3_Tier0>
int T_AnalysisConfigR3_Tier0< T, A >::m_parent_pdgID
protected

Definition at line 1274 of file T_AnalysisConfigR3_Tier0.h.

◆ m_pdgID

template<typename T , typename A = AnalysisR3_Tier0>
int T_AnalysisConfigR3_Tier0< T, A >::m_pdgID
protected

Definition at line 1273 of file T_AnalysisConfigR3_Tier0.h.

◆ m_provider

T * T_AnalysisConfig< T >::m_provider
protectedinherited

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_pTthreshold

template<typename T , typename A = AnalysisR3_Tier0>
double T_AnalysisConfigR3_Tier0< T, A >::m_pTthreshold
protected

Definition at line 1285 of file T_AnalysisConfigR3_Tier0.h.

◆ m_refChainKey

std::string T_AnalysisConfig< T >::m_refChainKey
protectedinherited

Definition at line 973 of file T_AnalysisConfig.h.

◆ m_refChainName

std::string T_AnalysisConfig< T >::m_refChainName
protectedinherited

Definition at line 972 of file T_AnalysisConfig.h.

◆ m_releaseData

std::string T_AnalysisConfig< T >::m_releaseData
protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_requireDecision

bool T_AnalysisConfig< T >::m_requireDecision
protectedinherited

Definition at line 1003 of file T_AnalysisConfig.h.

◆ m_runPurity

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_runPurity
protected

Definition at line 1281 of file T_AnalysisConfigR3_Tier0.h.

◆ m_selectorRef

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorRef
protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorSel

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorSel
protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_selectorTest

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorTest
protectedinherited

Definition at line 982 of file T_AnalysisConfig.h.

◆ m_shifter

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_shifter
protected

Definition at line 1283 of file T_AnalysisConfigR3_Tier0.h.

◆ m_tauEtCutOffline

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_tauEtCutOffline
protected

Definition at line 1266 of file T_AnalysisConfigR3_Tier0.h.

◆ m_tdt

ToolHandle<Trig::TrigDecisionTool>* T_AnalysisConfig< T >::m_tdt
protectedinherited

Definition at line 959 of file T_AnalysisConfig.h.

◆ m_testChainKey

std::string T_AnalysisConfig< T >::m_testChainKey
protectedinherited

Definition at line 976 of file T_AnalysisConfig.h.

◆ m_testChainName

std::string T_AnalysisConfig< T >::m_testChainName
protectedinherited

Definition at line 975 of file T_AnalysisConfig.h.

◆ m_testType

template<typename T , typename A = AnalysisR3_Tier0>
std::string T_AnalysisConfigR3_Tier0< T, A >::m_testType
protected

Definition at line 1258 of file T_AnalysisConfigR3_Tier0.h.

◆ m_tnp_flag

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_tnp_flag
protected

Definition at line 1293 of file T_AnalysisConfigR3_Tier0.h.

◆ m_TnP_tool

template<typename T , typename A = AnalysisR3_Tier0>
TagNProbe* T_AnalysisConfigR3_Tier0< T, A >::m_TnP_tool
protected

Definition at line 1291 of file T_AnalysisConfigR3_Tier0.h.

◆ m_types

template<typename T , typename A = AnalysisR3_Tier0>
std::vector<std::string> T_AnalysisConfigR3_Tier0< T, A >::m_types
protected

Definition at line 1269 of file T_AnalysisConfigR3_Tier0.h.

◆ m_useBeamCondSvc

template<typename T , typename A = AnalysisR3_Tier0>
bool T_AnalysisConfigR3_Tier0< T, A >::m_useBeamCondSvc
protected

Definition at line 1254 of file T_AnalysisConfigR3_Tier0.h.

◆ m_useHighestPT

bool T_AnalysisConfig< T >::m_useHighestPT
protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

◆ m_vtxIndex

int T_AnalysisConfig< T >::m_vtxIndex
protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

The documentation for this class was generated from the following file:
T_AnalysisConfigR3_Tier0::m_doMuons
bool m_doMuons
Definition: T_AnalysisConfigR3_Tier0.h:1261
T_AnalysisConfigR3_Tier0::m_useBeamCondSvc
bool m_useBeamCondSvc
Definition: T_AnalysisConfigR3_Tier0.h:1254
Trk::y
@ y
Definition: ParamDefs.h:56
TrackAnalysis::initialise
virtual void initialise()=0
standard operation interface
Trig::FeatureRequestDescriptor
Definition: FeatureRequestDescriptor.h:37
T_AnalysisConfigR3_Tier0::m_invmass_obj
TIDA::Histogram< float > * m_invmass_obj
Definition: T_AnalysisConfigR3_Tier0.h:1298
T_AnalysisConfig< T >::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:969
TIDA::Associator
Definition: TIDAAssociator.h:24
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
T_AnalysisConfigR3_Tier0::m_tnp_flag
bool m_tnp_flag
Definition: T_AnalysisConfigR3_Tier0.h:1293
T_AnalysisConfigR3_Tier0::m_chainNames
std::vector< ChainString > m_chainNames
Definition: T_AnalysisConfigR3_Tier0.h:1256
T_AnalysisConfig< T >::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:988
Trig::Feature
Definition: Feature.h:112
T_AnalysisConfigR3_Tier0::m_offline_types
std::vector< std::string > m_offline_types
Definition: T_AnalysisConfigR3_Tier0.h:1268
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TIDA::isGoodOffline
bool isGoodOffline(const Analysis::Electron &elec)
Definition: OfflineObjectSelection.cxx:122
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
T_AnalysisConfig< T >::m_filterOnRoi
bool m_filterOnRoi
Definition: T_AnalysisConfig.h:1001
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:57
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
T_AnalysisConfig< T >::m_provider
T * m_provider
Definition: T_AnalysisConfig.h:957
TrigTrackSelector::clear
virtual void clear() override
Definition: TrigTrackSelector.h:102
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
TrackAnalysis::finalise
virtual void finalise()=0
TIDA::Roi::addTracks
void addTracks(const std::vector< TIDA::Track > &tracks)
accessors for the track vector
Definition: TIDARoi.h:46
T_AnalysisConfig< T >::m_tdt
ToolHandle< Trig::TrigDecisionTool > * m_tdt
Definition: T_AnalysisConfig.h:959
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition: DataVector.h:837
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
TrackFilter
Definition: TrackFilter.h:26
hist_file_dump.d
d
Definition: hist_file_dump.py:143
HepMC::signal_process_id
int signal_process_id(const GenEvent &e)
Definition: GenEvent.h:635
Filter_etaPT
Definition: Filter_etaPT.h:27
TIDA::Event::size
unsigned size() const
vertex multiplicity ?
Definition: TIDAEvent.h:64
skel.it
it
Definition: skel.GENtoEVGEN.py:407
T_AnalysisConfigR3_Tier0::m_NRefTracks
int m_NRefTracks
Definition: T_AnalysisConfigR3_Tier0.h:1278
T_AnalysisConfig< T >::analysis
const TrackAnalysis * analysis() const
Definition: T_AnalysisConfig.h:258
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:137
T_AnalysisConfigR3_Tier0::m_pdgID
int m_pdgID
Definition: T_AnalysisConfigR3_Tier0.h:1273
TIDARoiDescriptor
Describes the Region of Ineterest geometry It has basically 8 parameters.
Definition: TIDARoiDescriptor.h:42
Analysis::TauJetContainer
Definition: Reconstruction/tauEvent/tauEvent/TauJetContainer.h:31
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
ChainString
Definition: ChainString.h:23
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
TrigTrackSelector
L2 tracks.
Definition: TrigTrackSelector.h:58
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
T_AnalysisConfig< T >::getUseHighestPT
bool getUseHighestPT() const
Definition: T_AnalysisConfig.h:279
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:794
TIDA::Event
Definition: TIDAEvent.h:33
TIDA::Event::lumi_block
void lumi_block(unsigned lb)
Definition: TIDAEvent.h:44
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Trig::Feature::empty
bool empty() const
test method to check if the object is truly there
Definition: Feature.h:197
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
TIDA::Histogram< float >
T_AnalysisConfigR3_Tier0::m_NTestTracks
int m_NTestTracks
Definition: T_AnalysisConfigR3_Tier0.h:1279
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TIDA::Associator::clone
virtual Associator * clone()=0
T_AnalysisConfigR3_Tier0::m_testType
std::string m_testType
Definition: T_AnalysisConfigR3_Tier0.h:1258
TIDA::Event::chains
const std::vector< TIDA::Chain > & chains() const
Definition: TIDAEvent.h:76
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
TIDA::Chain::addRoi
void addRoi(TIDA::Roi &roi)
add and roi by root dictionary class
Definition: TIDAChain.h:44
T_AnalysisConfig< T >::m_analysisInstanceName
std::string m_analysisInstanceName
Definition: T_AnalysisConfig.h:965
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
Container
storage of the time histories of all the cells
covarianceTool.filter
filter
Definition: covarianceTool.py:514
T_AnalysisConfig< T >::m_keys
std::vector< std::vector< std::string > > m_keys
Definition: T_AnalysisConfig.h:970
HepMC::end
GenEvent::particle_iterator end(HepMC::GenEvent &e)
Definition: GenEvent.h:621
TrigTrackSelector::getBeamX
double getBeamX() const
Definition: TrigTrackSelector.h:96
TIDA::Chain::back
TIDA::Roi & back()
Definition: TIDAChain.h:60
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
HLT::NavigationCore
The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling.
Definition: NavigationCore.h:96
FilterPT
void FilterPT(std::vector< T * > &tracks, double pt)
Definition: TIDATools.h:41
Trig::Feature::te
const HLT::TriggerElement * te() const
explicit conversion to TriggerElement
Definition: Feature.h:181
TagNProbe
Definition: TagNProbe.h:28
A
HLT::NavigationCore::getFeatures
bool getFeatures(const TriggerElement *te, std::vector< const T * > &features, const std::string &label="", std::map< const T *, std::string > *labels=0) const
retrieve features attached to given TriggerElement
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
T_AnalysisConfigR3_Tier0::m_doElectrons
bool m_doElectrons
Definition: T_AnalysisConfigR3_Tier0.h:1262
TIDA::Event::addChain
void addChain(const std::string &chainname)
methods to add and access chains
Definition: TIDAEvent.h:67
TIDA::Event::time_stamp
void time_stamp(unsigned t)
Definition: TIDAEvent.h:45
T_AnalysisConfig< T >::m_beamY
double m_beamY
Definition: T_AnalysisConfig.h:990
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
T_AnalysisConfig< T >::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:990
TIDA::Event::back
TIDA::Chain & back()
get the last chain from the vector
Definition: TIDAEvent.h:89
lumiFormat.i
int i
Definition: lumiFormat.py:85
TIDA::Event::event_number
void event_number(unsigned long long e)
Definition: TIDAEvent.h:43
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TagNProbe::tag
void tag(const std::string &chainName)
getters and setters
Definition: TagNProbe.h:45
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
T_AnalysisConfig< T >::m_analysis
TrackAnalysis * m_analysis
Definition: T_AnalysisConfig.h:986
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
T_AnalysisConfig< T >::getVtxIndex
int getVtxIndex() const
Definition: T_AnalysisConfig.h:282
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfigR3_Tier0::m_first
bool m_first
Definition: T_AnalysisConfigR3_Tier0.h:1287
T_AnalysisConfigR3_Tier0::m_containTracks
bool m_containTracks
Definition: T_AnalysisConfigR3_Tier0.h:1289
T_AnalysisConfig< T >::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1003
T_AnalysisConfigR3_Tier0::m_invmass
TIDA::Histogram< float > * m_invmass
Definition: T_AnalysisConfigR3_Tier0.h:1297
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
compute_lumi.leg
leg
Definition: compute_lumi.py:95
HighestPTOnly
void HighestPTOnly(std::vector< T * > &tracks)
Definition: TIDATools.h:20
T_AnalysisConfig< T >::m_keepAllEvents
bool m_keepAllEvents
Definition: T_AnalysisConfig.h:995
T_AnalysisConfigR3_Tier0::m_monTool
ToolHandle< GenericMonitoringTool > * m_monTool
Definition: T_AnalysisConfigR3_Tier0.h:1295
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
Analysis::MuonContainer
definition of StoreGate container holding a vector of Analysis::Muon
Definition: Reconstruction/MuonIdentification/muonEvent/muonEvent/MuonContainer.h:38
Filter_True
default simple filter which accepts all tracks
Definition: Filters.h:26
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
ChainString::extra
const std::string & extra() const
Definition: ChainString.h:38
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
T_AnalysisConfigR3_Tier0::m_shifter
bool m_shifter
Definition: T_AnalysisConfigR3_Tier0.h:1283
TIDA::Vertex
Definition: TIDAVertex.h:23
TrigTrackSelector::selectTrack
bool selectTrack(const TrigInDetTrack *track, const TrigInDetTrackTruthMap *truthMap=0)
neater code to make use of vector function also for a single ancestor pdgid, instead of the full code...
Definition: TrigTrackSelector.cxx:116
grepfile.ic
int ic
Definition: grepfile.py:33
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition: EventInfo_v1.cxx:397
head
std::string head(std::string s, const std::string &pattern)
head of a string
Definition: computils.cxx:311
selection
const std::string selection
Definition: fbtTestBasics.cxx:74
T_AnalysisConfig< T >::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:573
T_AnalysisConfigR3_Tier0::m_doOffline
bool m_doOffline
Definition: T_AnalysisConfigR3_Tier0.h:1260
dbg
Definition: SGImplSvc.cxx:69
T_AnalysisConfig< T >::m_associator
TrackAssociator * m_associator
Definition: T_AnalysisConfig.h:985
TrackSelector::tracks
const std::vector< TIDA::Track * > & tracks() const
Definition: Trigger/TrigAnalysis/TrigInDetAnalysis/TrigInDetAnalysis/TrackSelector.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Filter_Combined
Definition: Filters.h:225
TIDA::Chain
Definition: TIDAChain.h:28
T_AnalysisConfigR3_Tier0::m_runPurity
bool m_runPurity
Definition: T_AnalysisConfigR3_Tier0.h:1281
TIDARoiDescriptorBuilder
Definition: TIDARoiDescriptorBuilder.h:21
xAOD::Electron_v1
Definition: Electron_v1.h:34
T_AnalysisConfig< T >::loop
virtual void loop()=0
T_AnalysisConfig< T >::m_useHighestPT
bool m_useHighestPT
Definition: T_AnalysisConfig.h:997
TIDA::Event::addVertex
void addVertex(const TIDA::Vertex &v)
Definition: TIDAEvent.h:71
TIDA::Event::clear
void clear()
clear the event
Definition: TIDAEvent.h:86
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TIDA::Event::mu
void mu(double m)
Definition: TIDAEvent.h:47
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
python.PyAthena.v
v
Definition: PyAthena.py:154
ChainString::head
const std::string & head() const
Definition: ChainString.h:33
ChainString::roi
const std::string & roi() const
Definition: ChainString.h:35
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:60
TrigCompositeUtils::LinkInfo
Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGr...
Definition: LinkInfo.h:28
TrackTrigObject
Definition: TrackTrigObject.h:21
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
T_AnalysisConfigR3_Tier0::m_NRois
int m_NRois
output stats
Definition: T_AnalysisConfigR3_Tier0.h:1277
T_AnalysisConfigR3_Tier0::m_doTauThreeProng
bool m_doTauThreeProng
Definition: T_AnalysisConfigR3_Tier0.h:1265
T_AnalysisConfigR3_Tier0::m_tauEtCutOffline
bool m_tauEtCutOffline
Definition: T_AnalysisConfigR3_Tier0.h:1266
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
TriggerTest.rois
rois
Definition: TriggerTest.py:23
ElectronContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/ElectronContainer.h:32
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
T_AnalysisConfig< T >::m_vtxIndex
int m_vtxIndex
Definition: T_AnalysisConfig.h:999
TrigTrackSelector::getBeamZ
double getBeamZ() const
Definition: TrigTrackSelector.h:98
HepMC::begin
GenEvent::particle_iterator begin(HepMC::GenEvent &e)
Definition: GenEvent.h:620
TrigTrackSelector::getBeamY
double getBeamY() const
Definition: TrigTrackSelector.h:97
xAOD::EgammaHelpers::getOriginalTrackParticle
const xAOD::TrackParticle * getOriginalTrackParticle(const xAOD::Electron *el)
Helper function for getting the "Original" Track Particle (i.e before GSF) via the electron.
Definition: ElectronxAODHelpers.cxx:11
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
T_AnalysisConfig< T >::filterOnRoi
bool filterOnRoi() const
Definition: T_AnalysisConfig.h:284
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
ChainString::element
const std::string & element() const
Definition: ChainString.h:37
T_AnalysisConfigR3_Tier0::m_TnP_tool
TagNProbe * m_TnP_tool
Definition: T_AnalysisConfigR3_Tier0.h:1291
TIDA::Associator::match
virtual void match(const std::vector< T * > &s1, const std::vector< S * > &s2)=0
python.StandardJetMods.vr
vr
Definition: StandardJetMods.py:305
T_AnalysisConfig< T >::m_genericFlag
int m_genericFlag
Definition: T_AnalysisConfig.h:992
TIDA::Event::bunch_crossing_id
void bunch_crossing_id(unsigned b)
Definition: TIDAEvent.h:46
Trk::x
@ x
Definition: ParamDefs.h:55
T_AnalysisConfig< T >::m_beamZ
double m_beamZ
Definition: T_AnalysisConfig.h:990
T_AnalysisConfig< T >::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:979
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
TIDA::Event::run_number
void run_number(unsigned r)
accessors
Definition: TIDAEvent.h:42
T_AnalysisConfigR3_Tier0::m_parent_pdgID
int m_parent_pdgID
Definition: T_AnalysisConfigR3_Tier0.h:1274
T_AnalysisConfigR3_Tier0::m_pTthreshold
double m_pTthreshold
Definition: T_AnalysisConfigR3_Tier0.h:1285
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
T_AnalysisConfigR3_Tier0::m_doBjets
bool m_doBjets
Definition: T_AnalysisConfigR3_Tier0.h:1264
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
T_AnalysisConfig< T >::name
const std::string & name() const
Definition: T_AnalysisConfig.h:235
T_AnalysisConfigR3_Tier0::monTool
ToolHandle< GenericMonitoringTool > * monTool()
Definition: T_AnalysisConfigR3_Tier0.h:225
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
T_AnalysisConfigR3_Tier0::m_manalysis
A * m_manalysis
Definition: T_AnalysisConfigR3_Tier0.h:229
TagNProbe::probe
void probe(const std::string &chainName)
Definition: TagNProbe.h:46
Trig::Feature::cptr
const T * cptr() const
explicit conversion to object
Definition: Feature.h:171
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
T_AnalysisConfigR3_Tier0::m_types
std::vector< std::string > m_types
Definition: T_AnalysisConfigR3_Tier0.h:1269
T_AnalysisConfig< T >::select
bool select(std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
Definition: T_AnalysisConfig.h:342
ChainString::vtx
const std::string & vtx() const
Definition: ChainString.h:36
T_AnalysisConfig< T >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig< T >::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:993
T_AnalysisConfig< T >::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:968
T_AnalysisConfigR3_Tier0::m_doTaus
bool m_doTaus
Definition: T_AnalysisConfigR3_Tier0.h:1263
Generated on Fri Mar 21 2025 21:42:06 for ATLAS Offline Software by   doxygen 1.8.18