ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
T_AnalysisConfig< Provider > Class Template Referenceabstract

#include <T_AnalysisConfig.h>

Collaboration diagram for T_AnalysisConfig< Provider >:

Public Member Functions

 T_AnalysisConfig (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, const std::string &selectionChainName, const std::string &selectionType, const std::string &selectionKey, TrackFilter *testFilter, TrackFilter *referenceFilter, TrackFilter *selectionFilter, TrackAssociator *associator, TrackAnalysis *analysis)
 
 T_AnalysisConfig (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)
 
virtual ~T_AnalysisConfig ()
 
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 (Provider *p, ToolHandle< Trig::TrigDecisionTool > *tdt)
 
virtual void execute ()
 
virtual void finalize ()
 
virtual void book ()
 
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
 

Protected Member Functions

virtual void loop ()=0
 
template<class Collection >
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="")
 
template<class Collection >
bool selectTracks (TrigTrackSelector *selector, const ElementLink< TrigRoiDescriptorCollection > &roi_link, const std::string &key="")
 
template<class Collection >
bool selectTracks (TrigTrackSelector *selector, Trig::FeatureContainer::combination_const_iterator citr, const std::string &key="")
 lagacy run 2 access More...
 
template<class Collection >
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...
 
template<class Collection >
StatusCode retrieve (Collection const *&collection, const std::string &key="")
 
template<class Collection >
bool selectTracks (TrigTrackSelector *selector, const std::string &key)
 
template<class Collection >
bool selectTracksNotEmpty (TrigTrackSelector *selector, const std::string &key)
 
template<class Collection >
std::vector< double > getBeamspot (const std::string &key)
 
template<class Collection >
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

Provider * m_provider
 
ToolHandle< Trig::TrigDecisionTool > * m_tdt
 
std::string m_analysisInstanceName
 
std::vector< std::vector< std::string > > m_chainNames
 
std::vector< std::vector< std::string > > m_types
 
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<class Provider>
class T_AnalysisConfig< Provider >

Definition at line 59 of file T_AnalysisConfig.h.

Constructor & Destructor Documentation

◆ T_AnalysisConfig() [1/2]

template<class Provider >
T_AnalysisConfig< Provider >::T_AnalysisConfig ( 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,
const std::string &  selectionChainName,
const std::string &  selectionType,
const std::string &  selectionKey,
TrackFilter *  testFilter,
TrackFilter *  referenceFilter,
TrackFilter *  selectionFilter,
TrackAssociator *  associator,
TrackAnalysis *  analysis 
)
inline

Definition at line 69 of file T_AnalysisConfig.h.

75  :
76  m_provider(0),
77  m_analysisInstanceName(analysisInstanceName),
78  m_refChainName(referenceChainName),
79  m_refChainKey(referenceKey),
80  m_testChainName(testChainName),
81  m_testChainKey(testKey),
82  m_selectorRef(0),
83  m_selectorTest(0),
84  m_selectorSel(0),
85  m_associator(associator),
86  m_analysis(analysis),
87  m_mcTruth(false),
88  m_beamX(0),
89  m_beamY(0),
90  m_beamZ(0),
91  m_genericFlag(true),
92  m_releaseData(""),
93  m_keepAllEvents(false),
94  m_useHighestPT(false),
95  m_vtxIndex(-1),
96  m_filterOnRoi(true),
97  m_requireDecision(false)
98  {
99  // Rearrange objects in vectors: chain names
100  std::vector<std::string> testChainNames; testChainNames.push_back(testChainName);
101  std::vector<std::string> referenceChainNames; referenceChainNames.push_back(referenceChainName);
102  std::vector<std::string> selectionChainNames; selectionChainNames.push_back(selectionChainName);
103  m_chainNames.push_back(testChainNames); m_chainNames.push_back(referenceChainNames); m_chainNames.push_back(selectionChainNames);
104  // Types
105  std::vector<std::string> testTypes; testTypes.push_back(testType);
106  std::vector<std::string> referenceTypes; referenceTypes.push_back(referenceType);
107  std::vector<std::string> selectionTypes; selectionTypes.push_back(selectionType);
108  m_types.push_back(testTypes); m_types.push_back(referenceTypes); m_types.push_back(selectionTypes);
109  // Keys
110  std::vector<std::string> testKeys; testKeys.push_back(testKey);
111  std::vector<std::string> referenceKeys; referenceKeys.push_back(referenceKey);
112  std::vector<std::string> selectionKeys; selectionKeys.push_back(selectionKey);
113  m_keys.push_back(testKeys); m_keys.push_back(referenceKeys); m_keys.push_back(selectionKeys);
114  // Filters
115  std::vector<TrackFilter*> testFilters; testFilters.push_back(testFilter);
116  std::vector<TrackFilter*> referenceFilters; referenceFilters.push_back(referenceFilter);
117  std::vector<TrackFilter*> selectionFilters; selectionFilters.push_back(selectionFilter);
118  m_filters.push_back(testFilters); m_filters.push_back(referenceFilters); m_filters.push_back(selectionFilters);
119  }

◆ T_AnalysisConfig() [2/2]

template<class Provider >
T_AnalysisConfig< Provider >::T_AnalysisConfig ( 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 
)
inline

Definition at line 128 of file T_AnalysisConfig.h.

133  :
134  m_provider(0),
135  m_analysisInstanceName(analysisInstanceName),
136  m_refChainName(referenceChainName),
137  m_refChainKey(referenceKey),
138  m_testChainName(testChainName),
139  m_testChainKey(testKey),
140  m_selectorRef(0),
141  m_selectorTest(0),
142  m_selectorSel(0),
143  m_associator(associator),
144  m_analysis(analysis),
145  m_mcTruth(false),
146  m_beamX(0),
147  m_beamY(0),
148  m_beamZ(0),
149  m_genericFlag(true),
150  m_releaseData(""),
151  m_keepAllEvents(false),
152  m_useHighestPT(false),
153  m_vtxIndex(-1),
154  m_filterOnRoi(true),
155  m_requireDecision(false)
156  {
157  // Rearrange objects in vectors: chain names
158  std::vector<std::string> testChainNames; testChainNames.push_back(testChainName);
159  std::vector<std::string> referenceChainNames; referenceChainNames.push_back(referenceChainName);
160  std::vector<std::string> selectionChainNames; selectionChainNames.push_back("NONE");
161  m_chainNames.push_back(testChainNames); m_chainNames.push_back(referenceChainNames); m_chainNames.push_back(selectionChainNames);
162  // Types
163  std::vector<std::string> testTypes; testTypes.push_back(testType);
164  std::vector<std::string> referenceTypes; referenceTypes.push_back(referenceType);
165  std::vector<std::string> selectionTypes; selectionTypes.push_back("");
166  m_types.push_back(testTypes); m_types.push_back(referenceTypes); m_types.push_back(selectionTypes);
167  // Keys
168  std::vector<std::string> testKeys; testKeys.push_back(testKey);
169  std::vector<std::string> referenceKeys; referenceKeys.push_back(referenceKey);
170  std::vector<std::string> selectionKeys; selectionKeys.push_back("");
171  m_keys.push_back(testKeys); m_keys.push_back(referenceKeys); m_keys.push_back(selectionKeys);
172  // Filters
173  std::vector<TrackFilter*> testFilters; testFilters.push_back(testFilter);
174  std::vector<TrackFilter*> referenceFilters; referenceFilters.push_back(referenceFilter);
175  std::vector<TrackFilter*> selectionFilters;
176  m_filters.push_back(testFilters); m_filters.push_back(referenceFilters); m_filters.push_back(selectionFilters);
177 
178  // m_selectorRef = new TrigTrackSelector( referenceFilter );
179  // m_selectorTest = new TrigTrackSelector( testFilter );
180  }

◆ ~T_AnalysisConfig()

template<class Provider >
virtual T_AnalysisConfig< Provider >::~T_AnalysisConfig ( )
inlinevirtual

Definition at line 187 of file T_AnalysisConfig.h.

187  {
188  // if ( m_selectorRef ) delete m_selectorRef;
189  // if ( m_selectorTest ) delete m_selectorTest;
190  // if ( m_selectorSel ) delete m_selectorSel;
191  // if ( m_analysis ) delete m_analysis;
192  }

Member Function Documentation

◆ addReferenceChain()

template<class Provider >
void T_AnalysisConfig< Provider >::addReferenceChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inline

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()

template<class Provider >
void T_AnalysisConfig< Provider >::addReferenceFilter ( TrackFilter *  filter)
inline

Definition at line 210 of file T_AnalysisConfig.h.

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

◆ addSelectionChain()

template<class Provider >
void T_AnalysisConfig< Provider >::addSelectionChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inline

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()

template<class Provider >
void T_AnalysisConfig< Provider >::addSelectionFilter ( TrackFilter *  filter)
inline

Definition at line 211 of file T_AnalysisConfig.h.

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

◆ addTestChain()

template<class Provider >
void T_AnalysisConfig< Provider >::addTestChain ( const std::string &  chainName,
const std::string &  type,
const std::string &  key 
)
inline

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()

template<class Provider >
void T_AnalysisConfig< Provider >::addTestFilter ( TrackFilter *  filter)
inline

Definition at line 209 of file T_AnalysisConfig.h.

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

◆ analysis()

template<class Provider >
const TrackAnalysis* T_AnalysisConfig< Provider >::analysis ( ) const
inline

Definition at line 256 of file T_AnalysisConfig.h.

256 {return m_analysis;}

◆ beamX()

template<class Provider >
double T_AnalysisConfig< Provider >::beamX ( ) const
inline

Definition at line 264 of file T_AnalysisConfig.h.

264 { return m_beamX; }

◆ beamY()

template<class Provider >
double T_AnalysisConfig< Provider >::beamY ( ) const
inline

Definition at line 265 of file T_AnalysisConfig.h.

265 { return m_beamY; }

◆ beamZ()

template<class Provider >
double T_AnalysisConfig< Provider >::beamZ ( ) const
inline

Definition at line 266 of file T_AnalysisConfig.h.

266 { return m_beamZ; }

◆ book()

template<class Provider >
virtual void T_AnalysisConfig< Provider >::book ( )
inlinevirtual

Reimplemented in T_AnalysisConfig_Tier0< T >, T_AnalysisConfigR3_Tier0< T, A >, T_AnalysisConfigMT_Tier0< T, A >, and AnalysisConfig_Ntuple.

Definition at line 230 of file T_AnalysisConfig.h.

230 { }

◆ execute()

template<class Provider >
virtual void T_AnalysisConfig< Provider >::execute ( )
inlinevirtual

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()

template<class Provider >
bool T_AnalysisConfig< Provider >::filterOnRoi ( ) const
inline

Definition at line 282 of file T_AnalysisConfig.h.

282 { return m_filterOnRoi; }

◆ finalize()

template<class Provider >
virtual void T_AnalysisConfig< Provider >::finalize ( )
inlinevirtual

Reimplemented in T_AnalysisConfigR3_Tier0< T, A >, T_AnalysisConfig_Tier0< T >, T_AnalysisConfigMT_Tier0< T, A >, and AnalysisConfig_Ntuple.

Definition at line 228 of file T_AnalysisConfig.h.

228 { m_analysis->finalise(); }

◆ genericFlag()

template<class Provider >
bool T_AnalysisConfig< Provider >::genericFlag ( ) const
inline

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_genericFlag; }

◆ getBeamspot() [1/2]

template<class Provider >
template<class Collection >
std::vector<double> T_AnalysisConfig< Provider >::getBeamspot ( const std::string &  key)
inlineprotected

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]

template<class Provider >
template<class Collection >
std::vector<double> T_AnalysisConfig< Provider >::getBeamspot ( Trig::FeatureContainer::combination_const_iterator  citr,
const std::string &  key = "" 
)
inlineprotected

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()

template<class Provider >
template<class Collection >
std::pair< typename Collection::const_iterator, typename Collection::const_iterator > T_AnalysisConfig< Provider >::getCollection ( const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotected

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()

template<class Provider >
bool T_AnalysisConfig< Provider >::getUseHighestPT ( ) const
inline

Definition at line 277 of file T_AnalysisConfig.h.

277 { return m_useHighestPT; }

◆ getVtxIndex()

template<class Provider >
int T_AnalysisConfig< Provider >::getVtxIndex ( ) const
inline

Definition at line 280 of file T_AnalysisConfig.h.

280 { return m_vtxIndex; }

◆ initialize()

template<class Provider >
virtual void T_AnalysisConfig< Provider >::initialize ( Provider *  p,
ToolHandle< Trig::TrigDecisionTool > *  tdt 
)
inlinevirtual

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()

template<class Provider >
void T_AnalysisConfig< Provider >::keepAllEvents ( bool  b)
inline

Definition at line 274 of file T_AnalysisConfig.h.

274 { m_keepAllEvents = b; }

◆ loop()

template<class Provider >
virtual void T_AnalysisConfig< Provider >::loop ( )
protectedpure virtual

Implemented in T_AnalysisConfigR3_Tier0< T, A >, T_AnalysisConfigMT_Tier0< T, A >, T_AnalysisConfig_Tier0< T >, AnalysisConfig_Ntuple, and AnalysisConfigMT_Ntuple.

◆ mcTruth()

template<class Provider >
bool T_AnalysisConfig< Provider >::mcTruth ( ) const
inline

Definition at line 259 of file T_AnalysisConfig.h.

259 { return m_mcTruth; }

◆ name()

template<class Provider >
const std::string T_AnalysisConfig< Provider >::name ( ) const
inline

Definition at line 233 of file T_AnalysisConfig.h.

233 {return m_analysisInstanceName;}

◆ processElectrons()

template<class Provider >
unsigned T_AnalysisConfig< Provider >::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" 
)
inlineprotected

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()

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

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()

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

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()

template<class Provider >
const std::string T_AnalysisConfig< Provider >::referenceChains ( ) const
inline

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]

template<class Provider >
std::string T_AnalysisConfig< Provider >::releaseData ( ) const
inline

Definition at line 271 of file T_AnalysisConfig.h.

271 { return m_releaseData; }

◆ releaseData() [2/2]

template<class Provider >
void T_AnalysisConfig< Provider >::releaseData ( const std::string &  s)
inline

Definition at line 272 of file T_AnalysisConfig.h.

272 { m_releaseData = s; }

◆ requireDecision()

template<class Provider >
bool T_AnalysisConfig< Provider >::requireDecision ( ) const
inline

Definition at line 286 of file T_AnalysisConfig.h.

286 { return m_requireDecision; }

◆ retrieve()

template<class Provider >
template<class Collection >
StatusCode T_AnalysisConfig< Provider >::retrieve ( Collection const *&  collection,
const std::string &  key = "" 
)
inlineprotected

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]

template<class Provider >
bool T_AnalysisConfig< Provider >::select ( std::vector< TIDA::Vertex > &  vertices,
const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotected

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]

template<class Provider >
bool T_AnalysisConfig< Provider >::select ( std::vector< TIDA::Vertex > &  vertices,
const std::string &  key = "" 
)
inlineprotected

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]

template<class Provider >
bool T_AnalysisConfig< Provider >::select ( std::vector< TIDA::Vertex > &  vertices,
xAOD::VertexContainer::const_iterator  vtx_start,
xAOD::VertexContainer::const_iterator  vtx_end 
)
inlineprotected

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()

template<class Provider >
const std::string T_AnalysisConfig< Provider >::selectionChains ( ) const
inline

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]

template<class Provider >
template<class Collection >
bool T_AnalysisConfig< Provider >::selectTracks ( TrigTrackSelector *  selector,
const ElementLink< TrigRoiDescriptorCollection > &  roi_link,
const std::string &  key = "" 
)
inlineprotected

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]

template<class Provider >
template<class Collection >
bool T_AnalysisConfig< Provider >::selectTracks ( TrigTrackSelector *  selector,
const std::string &  key 
)
inlineprotected

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]

template<class Provider >
template<class Collection >
bool T_AnalysisConfig< Provider >::selectTracks ( TrigTrackSelector *  selector,
Trig::FeatureContainer::combination_const_iterator  citr,
const std::string &  key = "" 
)
inlineprotected

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]

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

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()

template<class Provider >
template<class Collection >
bool T_AnalysisConfig< Provider >::selectTracksNotEmpty ( TrigTrackSelector *  selector,
const std::string &  key 
)
inlineprotected

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  }

◆ setBeamX()

template<class Provider >
void T_AnalysisConfig< Provider >::setBeamX ( double  d)
inline

Definition at line 261 of file T_AnalysisConfig.h.

261 { m_beamX=d; }

◆ setBeamY()

template<class Provider >
void T_AnalysisConfig< Provider >::setBeamY ( double  d)
inline

Definition at line 262 of file T_AnalysisConfig.h.

262 { m_beamY=d; }

◆ setBeamZ()

template<class Provider >
void T_AnalysisConfig< Provider >::setBeamZ ( double  d)
inline

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamZ=d; }

◆ setFilterOnRoi()

template<class Provider >
bool T_AnalysisConfig< Provider >::setFilterOnRoi ( bool  b)
inline

Definition at line 283 of file T_AnalysisConfig.h.

283 { return m_filterOnRoi=b; }

◆ setGenericFlag()

template<class Provider >
void T_AnalysisConfig< Provider >::setGenericFlag ( bool  b)
inline

Definition at line 269 of file T_AnalysisConfig.h.

269 { m_genericFlag=b; }

◆ setMCTruth()

template<class Provider >
void T_AnalysisConfig< Provider >::setMCTruth ( bool  b = true)
inline

Definition at line 258 of file T_AnalysisConfig.h.

258 { m_mcTruth=b; }

◆ setRequireDecision()

template<class Provider >
void T_AnalysisConfig< Provider >::setRequireDecision ( bool  b)
inline

Definition at line 285 of file T_AnalysisConfig.h.

285 { m_requireDecision=b; }

◆ setUseHighestPT()

template<class Provider >
void T_AnalysisConfig< Provider >::setUseHighestPT ( bool  b)
inline

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_useHighestPT=b; }

◆ setVtxIndex()

template<class Provider >
void T_AnalysisConfig< Provider >::setVtxIndex ( int  i)
inline

Definition at line 279 of file T_AnalysisConfig.h.

279 { m_vtxIndex=i; }

◆ testChains()

template<class Provider >
const std::string T_AnalysisConfig< Provider >::testChains ( ) const
inline

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  }

Member Data Documentation

◆ m_analysis

template<class Provider >
TrackAnalysis* T_AnalysisConfig< Provider >::m_analysis
protected

Definition at line 984 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_analysisInstanceName
protected

Definition at line 963 of file T_AnalysisConfig.h.

◆ m_associator

template<class Provider >
TrackAssociator* T_AnalysisConfig< Provider >::m_associator
protected

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_beamX

template<class Provider >
double T_AnalysisConfig< Provider >::m_beamX
protected

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamY

template<class Provider >
double T_AnalysisConfig< Provider >::m_beamY
protected

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamZ

template<class Provider >
double T_AnalysisConfig< Provider >::m_beamZ
protected

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_chainNames

template<class Provider >
std::vector< std::vector<std::string> > T_AnalysisConfig< Provider >::m_chainNames
protected

Definition at line 966 of file T_AnalysisConfig.h.

◆ m_filterOnRoi

template<class Provider >
bool T_AnalysisConfig< Provider >::m_filterOnRoi
protected

Definition at line 999 of file T_AnalysisConfig.h.

◆ m_filters

template<class Provider >
std::vector< std::vector<TrackFilter*> > T_AnalysisConfig< Provider >::m_filters
protected

Definition at line 977 of file T_AnalysisConfig.h.

◆ m_genericFlag

template<class Provider >
int T_AnalysisConfig< Provider >::m_genericFlag
protected

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_keepAllEvents

template<class Provider >
bool T_AnalysisConfig< Provider >::m_keepAllEvents
protected

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_keys

template<class Provider >
std::vector< std::vector<std::string> > T_AnalysisConfig< Provider >::m_keys
protected

Definition at line 968 of file T_AnalysisConfig.h.

◆ m_mcTruth

template<class Provider >
bool T_AnalysisConfig< Provider >::m_mcTruth
protected

Definition at line 986 of file T_AnalysisConfig.h.

◆ m_provider

template<class Provider >
Provider* T_AnalysisConfig< Provider >::m_provider
protected

Definition at line 955 of file T_AnalysisConfig.h.

◆ m_refChainKey

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_refChainKey
protected

Definition at line 971 of file T_AnalysisConfig.h.

◆ m_refChainName

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_refChainName
protected

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_releaseData

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_releaseData
protected

Definition at line 991 of file T_AnalysisConfig.h.

◆ m_requireDecision

template<class Provider >
bool T_AnalysisConfig< Provider >::m_requireDecision
protected

Definition at line 1001 of file T_AnalysisConfig.h.

◆ m_selectorRef

template<class Provider >
TrigTrackSelector* T_AnalysisConfig< Provider >::m_selectorRef
protected

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_selectorSel

template<class Provider >
TrigTrackSelector* T_AnalysisConfig< Provider >::m_selectorSel
protected

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorTest

template<class Provider >
TrigTrackSelector* T_AnalysisConfig< Provider >::m_selectorTest
protected

Definition at line 980 of file T_AnalysisConfig.h.

◆ m_tdt

template<class Provider >
ToolHandle<Trig::TrigDecisionTool>* T_AnalysisConfig< Provider >::m_tdt
protected

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_testChainKey

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_testChainKey
protected

Definition at line 974 of file T_AnalysisConfig.h.

◆ m_testChainName

template<class Provider >
std::string T_AnalysisConfig< Provider >::m_testChainName
protected

Definition at line 973 of file T_AnalysisConfig.h.

◆ m_types

template<class Provider >
std::vector< std::vector<std::string> > T_AnalysisConfig< Provider >::m_types
protected

Definition at line 967 of file T_AnalysisConfig.h.

◆ m_useHighestPT

template<class Provider >
bool T_AnalysisConfig< Provider >::m_useHighestPT
protected

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_vtxIndex

template<class Provider >
int T_AnalysisConfig< Provider >::m_vtxIndex
protected

Definition at line 997 of file T_AnalysisConfig.h.

The documentation for this class was generated from the following file:
T_AnalysisConfig::m_selectorRef
TrigTrackSelector * m_selectorRef
Definition: T_AnalysisConfig.h:979
Trk::y
@ y
Definition: ParamDefs.h:56
TrackAnalysis::initialise
virtual void initialise()=0
standard operation interface
T_AnalysisConfig::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:967
T_AnalysisConfig::m_refChainKey
std::string m_refChainKey
Definition: T_AnalysisConfig.h:971
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
T_AnalysisConfig::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:986
Trig::Feature
Definition: Feature.h:112
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
T_AnalysisConfig::m_filterOnRoi
bool m_filterOnRoi
Definition: T_AnalysisConfig.h:999
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:57
T_AnalysisConfig::m_provider
Provider * m_provider
Definition: T_AnalysisConfig.h:955
TrigTrackSelector::clear
virtual void clear() override
Definition: TrigTrackSelector.h:102
TrackAnalysis::finalise
virtual void finalise()=0
T_AnalysisConfig::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
T_AnalysisConfig::m_testChainName
std::string m_testChainName
Definition: T_AnalysisConfig.h:973
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
hist_file_dump.d
d
Definition: hist_file_dump.py:137
T_AnalysisConfig::m_refChainName
std::string m_refChainName
Definition: T_AnalysisConfig.h:970
T_AnalysisConfig::analysis
const TrackAnalysis * analysis() const
Definition: T_AnalysisConfig.h:256
T_AnalysisConfig::m_selectorSel
TrigTrackSelector * m_selectorSel
Definition: T_AnalysisConfig.h:981
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:121
Analysis::TauJetContainer
Definition: Reconstruction/tauEvent/tauEvent/TauJetContainer.h:31
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:225
Trig::Feature::empty
bool empty() const
test method to check if the object is truly there
Definition: Feature.h:197
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
T_AnalysisConfig::m_analysisInstanceName
std::string m_analysisInstanceName
Definition: T_AnalysisConfig.h:963
Container
storage of the time histories of all the cells
covarianceTool.filter
filter
Definition: covarianceTool.py:514
T_AnalysisConfig::m_keys
std::vector< std::vector< std::string > > m_keys
Definition: T_AnalysisConfig.h:968
HLT::NavigationCore
The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling.
Definition: NavigationCore.h:96
Trig::Feature::te
const HLT::TriggerElement * te() const
explicit conversion to TriggerElement
Definition: Feature.h:181
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_AnalysisConfig::m_beamY
double m_beamY
Definition: T_AnalysisConfig.h:988
T_AnalysisConfig::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:988
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
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::m_analysis
TrackAnalysis * m_analysis
Definition: T_AnalysisConfig.h:984
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfig::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1001
T_AnalysisConfig::m_keepAllEvents
bool m_keepAllEvents
Definition: T_AnalysisConfig.h:993
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
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
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
T_AnalysisConfig::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:571
T_AnalysisConfig::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
xAOD::Electron_v1
Definition: Electron_v1.h:34
T_AnalysisConfig::loop
virtual void loop()=0
T_AnalysisConfig::m_useHighestPT
bool m_useHighestPT
Definition: T_AnalysisConfig.h:995
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
Athena_test::testKeys
void testKeys(StoreGateSvc &rSG)
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.PyAthena.v
v
Definition: PyAthena.py:154
TrackTrigObject
Definition: TrackTrigObject.h:21
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
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
ElectronContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/ElectronContainer.h:32
T_AnalysisConfig::m_vtxIndex
int m_vtxIndex
Definition: T_AnalysisConfig.h:997
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
T_AnalysisConfig::name
const std::string name() const
Definition: T_AnalysisConfig.h:233
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
T_AnalysisConfig::m_genericFlag
int m_genericFlag
Definition: T_AnalysisConfig.h:990
Trk::x
@ x
Definition: ParamDefs.h:55
T_AnalysisConfig::m_beamZ
double m_beamZ
Definition: T_AnalysisConfig.h:988
T_AnalysisConfig::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:977
T_AnalysisConfig::m_selectorTest
TrigTrackSelector * m_selectorTest
Definition: T_AnalysisConfig.h:980
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
T_AnalysisConfig::m_testChainKey
std::string m_testChainKey
Definition: T_AnalysisConfig.h:974
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_AnalysisConfig::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
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:991
T_AnalysisConfig::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:966
Generated on Thu Nov 7 2024 21:57:04 for ATLAS Offline Software by   doxygen 1.8.18