ATLAS Offline Software
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)
 
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_useBeamCondSvc(false),
121  m_doOffline(true),
122  m_doMuons(false),
123  m_doElectrons(false),
124  m_doTaus(false),
125  m_doBjets(false),
126  m_pdgID(0),
127  m_parent_pdgID(0),
128  m_NRois(0),
129  m_NRefTracks(0),
130  m_NTestTracks(0),
131  m_runPurity(false),
132  m_shifter(false),
133  m_pTthreshold(0),
134  m_first(true),
135  m_containTracks(false),
136  m_tnp_flag(false),
137  m_invmass(0),
138  m_invmass_obj(0)
139  {
140 
143 
144  m_chainNames.push_back(testChainName);
145 
147 
148  m_TnP_tool = TnP_tool;
149 
150 #if 0
151  ChainString& chain = m_chainNames.back();
153 
154  std::cout << "\nT_AnalysisConfigR3_Tier0::name: " << name() << "\t" << this << std::endl;
155  std::cout << "T_AnalysisConfigR3_Tier0::chain specification: " << testChainName << " -> " << chain << "\t" << chain.raw() << std::endl;
156  std::cout << "\tchain: " << chain.head() << std::endl;
157  std::cout << "\tkey: " << chain.tail() << std::endl;
158  std::cout << "\troi: " << chain.roi() << std::endl;
159  std::cout << "\tvtx: " << chain.vtx() << std::endl;
160  std::cout << "\tte: " << chain.element() << std::endl;
161  std::cout << "\textra: " << chain.extra() << std::endl;
162 
163  std::cout << "\tpost: " << chain.post() << std::endl;
164  std::cout << "\tpt: " << chain.postvalue("pt") << std::endl;
165 
166  std::cout << "\tcontainTracks: " << m_containTracks << std::endl;
167 
168 #endif
169 
170  m_testType = testType;
171 
172  if ( m_TnP_tool ) m_tnp_flag = true;
173 
174  }

◆ ~T_AnalysisConfigR3_Tier0()

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

Definition at line 177 of file T_AnalysisConfigR3_Tier0.h.

177  {
178  if ( m_TnP_tool ) delete m_TnP_tool;
179  if ( m_invmass ) delete m_invmass;
180  if ( m_invmass_obj ) delete m_invmass_obj;
181  }

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 201 of file T_AnalysisConfig.h.

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

◆ addReferenceFilter()

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

Definition at line 210 of file T_AnalysisConfig.h.

210 { 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 205 of file T_AnalysisConfig.h.

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

◆ addSelectionFilter()

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

Definition at line 211 of file T_AnalysisConfig.h.

211 { 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 197 of file T_AnalysisConfig.h.

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

◆ addTestFilter()

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

Definition at line 209 of file T_AnalysisConfig.h.

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

◆ analysis()

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

Definition at line 256 of file T_AnalysisConfig.h.

256 {return m_analysis;}

◆ beamX()

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

Definition at line 264 of file T_AnalysisConfig.h.

264 { return m_beamX; }

◆ beamY()

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

Definition at line 265 of file T_AnalysisConfig.h.

265 { return m_beamY; }

◆ beamZ()

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

Definition at line 266 of file T_AnalysisConfig.h.

266 { 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 1112 of file T_AnalysisConfigR3_Tier0.h.

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

◆ containTracks()

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

Definition at line 207 of file T_AnalysisConfigR3_Tier0.h.

207 { m_containTracks = b; }

◆ execute()

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

Definition at line 223 of file T_AnalysisConfig.h.

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

◆ filterOnRoi()

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

Definition at line 282 of file T_AnalysisConfig.h.

282 { 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 1232 of file T_AnalysisConfigR3_Tier0.h.

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

◆ genericFlag()

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

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_genericFlag; }

◆ getBeamspot() [1/2]

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

Definition at line 632 of file T_AnalysisConfig.h.

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

◆ getBeamspot() [2/2]

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

Definition at line 661 of file T_AnalysisConfig.h.

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

◆ 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 297 of file T_AnalysisConfig.h.

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

◆ getUseHighestPT()

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

Definition at line 277 of file T_AnalysisConfig.h.

277 { return m_useHighestPT; }

◆ getVtxIndex()

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

Definition at line 280 of file T_AnalysisConfig.h.

280 { return m_vtxIndex; }

◆ initialise()

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

Definition at line 184 of file T_AnalysisConfigR3_Tier0.h.

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

◆ initialize()

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

Definition at line 214 of file T_AnalysisConfig.h.

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

◆ keepAllEvents()

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

Definition at line 274 of file T_AnalysisConfig.h.

274 { 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 242 of file T_AnalysisConfigR3_Tier0.h.

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

◆ mcTruth()

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

Definition at line 259 of file T_AnalysisConfig.h.

259 { return m_mcTruth; }

◆ monTool()

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

Definition at line 221 of file T_AnalysisConfigR3_Tier0.h.

221 { return m_monTool; }

◆ name()

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

Definition at line 233 of file T_AnalysisConfig.h.

233 {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 701 of file T_AnalysisConfig.h.

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

◆ 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 787 of file T_AnalysisConfig.h.

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

◆ 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 844 of file T_AnalysisConfig.h.

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

◆ referenceChains()

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

Definition at line 242 of file T_AnalysisConfig.h.

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

◆ releaseData() [1/2]

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

Definition at line 271 of file T_AnalysisConfig.h.

271 { return m_releaseData; }

◆ releaseData() [2/2]

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

Definition at line 272 of file T_AnalysisConfig.h.

272 { m_releaseData = s; }

◆ requireDecision()

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

Definition at line 286 of file T_AnalysisConfig.h.

286 { 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 571 of file T_AnalysisConfig.h.

571  {
574  if ( m_provider->evtStore()->template contains<Collection>( key ) ) {
575  SG::ReadHandle<Collection> handle(key);
576  if ( handle.isValid() ) {
579  collection = handle.cptr();
580  return StatusCode::SUCCESS;
581  }
582  }
583  return StatusCode::FAILURE;
584  }

◆ 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 369 of file T_AnalysisConfig.h.

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

◆ select() [2/3]

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

Definition at line 392 of file T_AnalysisConfig.h.

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

◆ 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 340 of file T_AnalysisConfig.h.

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

◆ selectionChains()

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

Definition at line 249 of file T_AnalysisConfig.h.

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

◆ 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 439 of file T_AnalysisConfig.h.

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

◆ 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 589 of file T_AnalysisConfig.h.

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

◆ 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 485 of file T_AnalysisConfig.h.

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

◆ 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 521 of file T_AnalysisConfig.h.

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

◆ selectTracksNotEmpty()

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

Definition at line 606 of file T_AnalysisConfig.h.

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

◆ set_monTool()

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

Definition at line 219 of file T_AnalysisConfigR3_Tier0.h.

219 { m_monTool=m; }

◆ setBeamX()

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

Definition at line 261 of file T_AnalysisConfig.h.

261 { m_beamX=d; }

◆ setBeamY()

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

Definition at line 262 of file T_AnalysisConfig.h.

262 { m_beamY=d; }

◆ setBeamZ()

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

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamZ=d; }

◆ setFilterOnRoi()

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

Definition at line 283 of file T_AnalysisConfig.h.

283 { return m_filterOnRoi=b; }

◆ setGenericFlag()

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

Definition at line 269 of file T_AnalysisConfig.h.

269 { m_genericFlag=b; }

◆ setMCTruth()

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

Definition at line 258 of file T_AnalysisConfig.h.

258 { m_mcTruth=b; }

◆ setMCTruthRef()

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

Definition at line 213 of file T_AnalysisConfigR3_Tier0.h.

213 { m_mcTruth=b; }

◆ setOfflineRef()

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

Definition at line 215 of file T_AnalysisConfigR3_Tier0.h.

215 { 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 211 of file T_AnalysisConfigR3_Tier0.h.

211 { 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 209 of file T_AnalysisConfigR3_Tier0.h.

209 { m_pdgID=i; }

◆ setRequireDecision()

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

Definition at line 285 of file T_AnalysisConfig.h.

285 { m_requireDecision=b; }

◆ setRunPurity()

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

Definition at line 201 of file T_AnalysisConfigR3_Tier0.h.

201 { m_runPurity=b; }

◆ setShifter()

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

Definition at line 203 of file T_AnalysisConfigR3_Tier0.h.

203 { 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 217 of file T_AnalysisConfigR3_Tier0.h.

217 { m_types=t; }

◆ setUseHighestPT()

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

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_useHighestPT=b; }

◆ setVtxIndex()

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

Definition at line 279 of file T_AnalysisConfig.h.

279 { m_vtxIndex=i; }

◆ testChains()

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

Definition at line 235 of file T_AnalysisConfig.h.

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

◆ useBeamCondSvc()

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

Definition at line 205 of file T_AnalysisConfigR3_Tier0.h.

205 { 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 1253 of file T_AnalysisConfigR3_Tier0.h.

◆ m_analysis

TrackAnalysis* T_AnalysisConfig< T >::m_analysis
protectedinherited

Definition at line 984 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

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

Definition at line 963 of file T_AnalysisConfig.h.

◆ m_associator

TrackAssociator* T_AnalysisConfig< T >::m_associator
protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_beamX

double T_AnalysisConfig< T >::m_beamX
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamY

double T_AnalysisConfig< T >::m_beamY
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamZ

double T_AnalysisConfig< T >::m_beamZ
protectedinherited

Definition at line 988 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 1252 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 1285 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 1260 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 1258 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 1257 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 1256 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 1259 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 1261 of file T_AnalysisConfigR3_Tier0.h.

◆ m_filterOnRoi

bool T_AnalysisConfig< T >::m_filterOnRoi
protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

◆ m_filters

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

Definition at line 977 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 1283 of file T_AnalysisConfigR3_Tier0.h.

◆ m_genericFlag

int T_AnalysisConfig< T >::m_genericFlag
protectedinherited

Definition at line 990 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 1293 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 1294 of file T_AnalysisConfigR3_Tier0.h.

◆ m_keepAllEvents

bool T_AnalysisConfig< T >::m_keepAllEvents
protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_keys

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

Definition at line 968 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 225 of file T_AnalysisConfigR3_Tier0.h.

◆ m_mcTruth

bool T_AnalysisConfig< T >::m_mcTruth
protectedinherited

Definition at line 986 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 1291 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 1274 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 1273 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 1275 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 1264 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 1267 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 1270 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 1269 of file T_AnalysisConfigR3_Tier0.h.

◆ m_provider

T * T_AnalysisConfig< T >::m_provider
protectedinherited

Definition at line 955 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 1281 of file T_AnalysisConfigR3_Tier0.h.

◆ m_refChainKey

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

Definition at line 971 of file T_AnalysisConfig.h.

◆ m_refChainName

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

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_releaseData

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

Definition at line 991 of file T_AnalysisConfig.h.

◆ m_requireDecision

bool T_AnalysisConfig< T >::m_requireDecision
protectedinherited

Definition at line 1001 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 1277 of file T_AnalysisConfigR3_Tier0.h.

◆ m_selectorRef

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorRef
protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_selectorSel

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorSel
protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorTest

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorTest
protectedinherited

Definition at line 980 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 1279 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 1262 of file T_AnalysisConfigR3_Tier0.h.

◆ m_tdt

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

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_testChainKey

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

Definition at line 974 of file T_AnalysisConfig.h.

◆ m_testChainName

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

Definition at line 973 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 1254 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 1289 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 1287 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 1265 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 1250 of file T_AnalysisConfigR3_Tier0.h.

◆ m_useHighestPT

bool T_AnalysisConfig< T >::m_useHighestPT
protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_vtxIndex

int T_AnalysisConfig< T >::m_vtxIndex
protectedinherited

Definition at line 997 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:1257
T_AnalysisConfigR3_Tier0::m_useBeamCondSvc
bool m_useBeamCondSvc
Definition: T_AnalysisConfigR3_Tier0.h:1250
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:1294
T_AnalysisConfig< T >::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:967
TIDA::Associator
Definition: TIDAAssociator.h:24
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
T_AnalysisConfigR3_Tier0::m_tnp_flag
bool m_tnp_flag
Definition: T_AnalysisConfigR3_Tier0.h:1289
T_AnalysisConfigR3_Tier0::m_chainNames
std::vector< ChainString > m_chainNames
Definition: T_AnalysisConfigR3_Tier0.h:1252
T_AnalysisConfig< T >::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:986
Trig::Feature
Definition: Feature.h:112
T_AnalysisConfigR3_Tier0::m_offline_types
std::vector< std::string > m_offline_types
Definition: T_AnalysisConfigR3_Tier0.h:1264
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:999
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:955
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:957
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:137
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
ChainString::head
std::string head() const
Definition: ChainString.h:33
skel.it
it
Definition: skel.GENtoEVGEN.py:396
T_AnalysisConfigR3_Tier0::m_NRefTracks
int m_NRefTracks
Definition: T_AnalysisConfigR3_Tier0.h:1274
T_AnalysisConfig< T >::analysis
const TrackAnalysis * analysis() const
Definition: T_AnalysisConfig.h:256
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:121
T_AnalysisConfigR3_Tier0::m_pdgID
int m_pdgID
Definition: T_AnalysisConfigR3_Tier0.h:1269
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:277
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:225
TIDA::Event
Definition: TIDAEvent.h:33
TIDA::Event::lumi_block
void lumi_block(unsigned lb)
Definition: TIDAEvent.h:44
ChainString::roi
std::string roi() const
Definition: ChainString.h:35
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:1275
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:1254
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:963
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:968
HepMC::end
GenEvent::particle_iterator end(HepMC::GenEvent &e)
Definition: GenEvent.h:621
ChainString::extra
std::string extra() const
Definition: ChainString.h:38
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:1258
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:988
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
T_AnalysisConfig< T >::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:988
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:984
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
T_AnalysisConfig< T >::getVtxIndex
int getVtxIndex() const
Definition: T_AnalysisConfig.h:280
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfigR3_Tier0::m_first
bool m_first
Definition: T_AnalysisConfigR3_Tier0.h:1283
T_AnalysisConfigR3_Tier0::m_containTracks
bool m_containTracks
Definition: T_AnalysisConfigR3_Tier0.h:1285
T_AnalysisConfig< T >::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1001
T_AnalysisConfigR3_Tier0::m_invmass
TIDA::Histogram< float > * m_invmass
Definition: T_AnalysisConfigR3_Tier0.h:1293
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:993
T_AnalysisConfigR3_Tier0::m_monTool
ToolHandle< GenericMonitoringTool > * m_monTool
Definition: T_AnalysisConfigR3_Tier0.h:1291
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
selection
std::string selection
Definition: fbtTestBasics.cxx:75
Filter_True
default simple filter which accepts all tracks
Definition: Filters.h:26
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
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:1279
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:310
ChainString::element
std::string element() const
Definition: ChainString.h:37
T_AnalysisConfig< T >::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:571
T_AnalysisConfigR3_Tier0::m_doOffline
bool m_doOffline
Definition: T_AnalysisConfigR3_Tier0.h:1256
dbg
Definition: SGImplSvc.cxx:69
T_AnalysisConfig< T >::m_associator
TrackAssociator * m_associator
Definition: T_AnalysisConfig.h:983
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:1277
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:995
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
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:1273
ChainString::vtx
std::string vtx() const
Definition: ChainString.h:36
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:997
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:282
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
T_AnalysisConfig< T >::name
const std::string name() const
Definition: T_AnalysisConfig.h:233
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
T_AnalysisConfigR3_Tier0::m_TnP_tool
TagNProbe * m_TnP_tool
Definition: T_AnalysisConfigR3_Tier0.h:1287
TIDA::Associator::match
virtual void match(const std::vector< T * > &s1, const std::vector< S * > &s2)=0
python.StandardJetMods.vr
vr
Definition: StandardJetMods.py:294
T_AnalysisConfig< T >::m_genericFlag
int m_genericFlag
Definition: T_AnalysisConfig.h:990
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:988
T_AnalysisConfig< T >::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:977
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:1270
T_AnalysisConfigR3_Tier0::m_pTthreshold
double m_pTthreshold
Definition: T_AnalysisConfigR3_Tier0.h:1281
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
T_AnalysisConfigR3_Tier0::m_doBjets
bool m_doBjets
Definition: T_AnalysisConfigR3_Tier0.h:1260
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
T_AnalysisConfigR3_Tier0::monTool
ToolHandle< GenericMonitoringTool > * monTool()
Definition: T_AnalysisConfigR3_Tier0.h:221
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
T_AnalysisConfigR3_Tier0::m_manalysis
A * m_manalysis
Definition: T_AnalysisConfigR3_Tier0.h:225
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:1265
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:340
T_AnalysisConfig< T >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig< T >::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:991
T_AnalysisConfig< T >::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:966
T_AnalysisConfigR3_Tier0::m_doTaus
bool m_doTaus
Definition: T_AnalysisConfigR3_Tier0.h:1259
Generated on Thu Nov 7 2024 21:57:05 for ATLAS Offline Software by   doxygen 1.8.18