ATLAS Offline Software
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | List of all members
T_AnalysisConfig_Tier0< T > Class Template Reference

#include <T_AnalysisConfig_Tier0.h>

Inheritance diagram for T_AnalysisConfig_Tier0< T >:
Collaboration diagram for T_AnalysisConfig_Tier0< T >:

Public Member Functions

 T_AnalysisConfig_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)
 
virtual ~T_AnalysisConfig_Tier0 ()
 
void setRunPurity (bool b)
 
void setShifter (bool b)
 
void useBeamCondSvc (bool b)
 
void containTracks (bool b)
 
void addTestChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addReferenceChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addSelectionChain (const std::string &chainName, const std::string &type, const std::string &key)
 
void addTestFilter (TrackFilter *filter)
 
void addReferenceFilter (TrackFilter *filter)
 
void addSelectionFilter (TrackFilter *filter)
 
virtual void initialize (T *p, ToolHandle< Trig::TrigDecisionTool > *tdt)
 
virtual void execute ()
 
const std::string & name () const
 
const std::string testChains () const
 
const std::string referenceChains () const
 
const std::string selectionChains () const
 
const TrackAnalysis * analysis () const
 
void setMCTruth (bool b=true)
 
bool mcTruth () const
 
void setBeamX (double d)
 
void setBeamY (double d)
 
void setBeamZ (double d)
 
double beamX () const
 
double beamY () const
 
double beamZ () const
 
bool genericFlag () const
 
void setGenericFlag (bool b)
 
const std::string & releaseData () const
 
void releaseData (const std::string &s)
 
void keepAllEvents (bool b)
 
void setUseHighestPT (bool b)
 
bool getUseHighestPT () const
 
void setVtxIndex (int i)
 
int getVtxIndex () const
 
bool filterOnRoi () const
 
bool setFilterOnRoi (bool b)
 
void setRequireDecision (bool b)
 
bool requireDecision () const
 

Public Attributes

Analysis_Tier0 * _analysis
 

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
 
TIDA::Event * m_event
 
std::vector< ChainString > m_chainNames
 
std::vector< Analysis_Tier0 * > m_analyses
 
std::string m_testType
 
bool m_doOffline
 
bool m_doMuons
 
bool m_doElectrons
 
bool m_doTaus
 
bool m_doBjets
 
bool m_hasTruthMap
 
bool m_doTauThreeProng
 
bool m_tauEtCutOffline
 
std::string m_outputFileName
 
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
 
T * m_provider
 
ToolHandle< Trig::TrigDecisionTool > * m_tdt
 
std::string m_analysisInstanceName
 
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<typename T>
class T_AnalysisConfig_Tier0< T >

Definition at line 87 of file T_AnalysisConfig_Tier0.h.

Constructor & Destructor Documentation

◆ T_AnalysisConfig_Tier0()

template<typename T >
T_AnalysisConfig_Tier0< T >::T_AnalysisConfig_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 
)
inline

Definition at line 97 of file T_AnalysisConfig_Tier0.h.

102  :
103  T_AnalysisConfig<T>( analysisInstanceName,
104  testChainName, testType, testKey,
105  referenceChainName, referenceType, referenceKey,
106  testFilter, referenceFilter,
107  associator,
108  analysis ),
109  _analysis(0),
110  m_useBeamCondSvc(false),
111  m_doOffline(true),
112  m_doMuons(false),
113  m_doElectrons(false),
114  m_doTaus(false),
115  m_doBjets(false),
116  m_hasTruthMap(false),
117  m_doTauThreeProng(false),
118  m_tauEtCutOffline(false),
119  m_NRois(0),
120  m_NRefTracks(0),
121  m_NTestTracks(0),
122  m_runPurity(false),
123  m_shifter(false),
124  m_pTthreshold(0),
125  m_first(true),
126  m_containTracks(false)
127  {
128  m_event = new TIDA::Event();
129  m_chainNames.push_back(testChainName);
130 
131 #if 0
132  ChainString& chain = m_chainNames.back();
133 
134  std::cout << "\nT_AnalysisConfig_Tier0::name: " << name() << "\t" << this << std::endl;
135  std::cout << "T_AnalysisConfig_Tier0::chain specification: " << testChainName << " -> " << chain << "\t" << chain.raw() << std::endl;
136  std::cout << "\tchain: " << chain.head() << std::endl;
137  std::cout << "\tkey: " << chain.tail() << std::endl;
138  std::cout << "\troi: " << chain.roi() << std::endl;
139  std::cout << "\tvtx: " << chain.vtx() << std::endl;
140  std::cout << "\tte: " << chain.element() << std::endl;
141 
142  std::cout << "\tpost: " << chain.post() << std::endl;
143  std::cout << "\tpt: " << chain.postvalue("pt") << std::endl;
144 
145  std::cout << "\tcontainTracks: " << m_containTracks << std::endl;
146 #endif
147 
148  m_testType = testType;
149  }

◆ ~T_AnalysisConfig_Tier0()

template<typename T >
virtual T_AnalysisConfig_Tier0< T >::~T_AnalysisConfig_Tier0 ( )
inlinevirtual

Definition at line 151 of file T_AnalysisConfig_Tier0.h.

151 { delete m_event; }

Member Function Documentation

◆ addReferenceChain()

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

Definition at line 203 of file T_AnalysisConfig.h.

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

◆ addReferenceFilter()

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

Definition at line 212 of file T_AnalysisConfig.h.

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

◆ addSelectionChain()

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

Definition at line 207 of file T_AnalysisConfig.h.

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

◆ addSelectionFilter()

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

Definition at line 213 of file T_AnalysisConfig.h.

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

◆ addTestChain()

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

Definition at line 199 of file T_AnalysisConfig.h.

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

◆ addTestFilter()

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

Definition at line 211 of file T_AnalysisConfig.h.

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

◆ analysis()

const TrackAnalysis* T_AnalysisConfig< T >::analysis
inlineinherited

Definition at line 258 of file T_AnalysisConfig.h.

258 {return m_analysis;}

◆ beamX()

double T_AnalysisConfig< T >::beamX
inlineinherited

Definition at line 266 of file T_AnalysisConfig.h.

266 { return m_beamX; }

◆ beamY()

double T_AnalysisConfig< T >::beamY
inlineinherited

Definition at line 267 of file T_AnalysisConfig.h.

267 { return m_beamY; }

◆ beamZ()

double T_AnalysisConfig< T >::beamZ
inlineinherited

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_beamZ; }

◆ book()

template<typename T >
virtual void T_AnalysisConfig_Tier0< T >::book ( )
inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1192 of file T_AnalysisConfig_Tier0.h.

1192  {
1193 
1194  if(m_provider->msg().level() <= MSG::VERBOSE)
1195  m_provider->msg(MSG::VERBOSE) << "AnalysisConfig_Tier0::book() " << name() << endmsg;
1196 
1197  m_provider->msg(MSG::ERROR) << "AnalysisConfig_Tier0::book() should no longer ever be called: " << name() << endmsg;
1198 
1199  }

◆ containTracks()

template<typename T >
void T_AnalysisConfig_Tier0< T >::containTracks ( bool  b)
inline

Definition at line 159 of file T_AnalysisConfig_Tier0.h.

159 { m_containTracks = b; }

◆ execute()

virtual void T_AnalysisConfig< T >::execute
inlinevirtualinherited

Definition at line 225 of file T_AnalysisConfig.h.

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

◆ filterOnRoi()

bool T_AnalysisConfig< T >::filterOnRoi
inlineinherited

Definition at line 284 of file T_AnalysisConfig.h.

284 { return m_filterOnRoi; }

◆ finalize()

template<typename T >
virtual void T_AnalysisConfig_Tier0< T >::finalize ( )
inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1203 of file T_AnalysisConfig_Tier0.h.

1203  {
1204 
1205  if(m_provider->msg().level() <= MSG::VERBOSE)
1206  m_provider->msg(MSG::VERBOSE) << "AnalysisConfig_Tier0::finalise() " << m_provider->name() << endmsg;
1207 
1208  m_analysis->finalise();
1209 
1210  m_provider->msg(MSG::INFO) << m_provider->name() << " " << m_chainNames[0] << " \tNRois processed: " << m_NRois << "\tRef tracks: " << m_NRefTracks << "\tTestTracks: " << m_NTestTracks << endmsg;
1211 
1212  if(m_provider->msg().level() <= MSG::VERBOSE)
1213  m_provider->msg(MSG::VERBOSE) << m_provider->name() << " finalised" << endmsg;
1214 
1215  }

◆ genericFlag()

bool T_AnalysisConfig< T >::genericFlag
inlineinherited

Definition at line 270 of file T_AnalysisConfig.h.

270 { return m_genericFlag; }

◆ getBeamspot() [1/2]

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

Definition at line 634 of file T_AnalysisConfig.h.

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

◆ getBeamspot() [2/2]

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

Definition at line 663 of file T_AnalysisConfig.h.

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

◆ getCollection()

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

new MT feature access

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

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

Definition at line 299 of file T_AnalysisConfig.h.

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

◆ getUseHighestPT()

bool T_AnalysisConfig< T >::getUseHighestPT
inlineinherited

Definition at line 279 of file T_AnalysisConfig.h.

279 { return m_useHighestPT; }

◆ getVtxIndex()

int T_AnalysisConfig< T >::getVtxIndex
inlineinherited

Definition at line 282 of file T_AnalysisConfig.h.

282 { return m_vtxIndex; }

◆ initialize()

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

Definition at line 216 of file T_AnalysisConfig.h.

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

◆ keepAllEvents()

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

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_keepAllEvents = b; }

◆ loop()

template<typename T >
virtual void T_AnalysisConfig_Tier0< T >::loop ( )
inlineprotectedvirtual

handle wildcard chain selection - but only the first time NB: also check all other chains as well - only set up an analysis for configured chains

get chain

get matching chains

replace wildcard with actual matching chains ...

end of first event setup

all this should perhaps be class variables

will need to add a vertex filter at some point probably

now start everything going for this event properly ...

(obviously) get the event info

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

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

get the offline vertices into our structure

add the truth particles if needed

now add the vertices

now add the offline tracks and reco objects

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

create chains for ntpl

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

and the index of the collection (if any)

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

dummy full scan chain

HLT and EF-like EDM

L2 track EDM

get vertex information

now also add xAOD vertices

leave this code commented so that we have a record of the change - as soon as we can fix the missing track multiplicity from the vertex this will need to go back

variances

quality

retrieve online vertices

loop over combinations

"offline" type chains

now loop over the rois (again)

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

AOD

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

get offline tracks

what is this ???

what is this for ???

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

stats book keeping

match test and reference tracks

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

Implements T_AnalysisConfig< T >.

Definition at line 188 of file T_AnalysisConfig_Tier0.h.

188  {
189 
190  if( m_provider->msg().level() <= MSG::VERBOSE) {
191  m_provider->msg(MSG::VERBOSE) << "AnalysisConfig_Tier0::loop() for " << T_AnalysisConfig<T>::m_analysisInstanceName << endmsg;
192  }
193 
194  // get (offline) beam position
195  double xbeam = 0;
196  double ybeam = 0;
197 
198  if ( m_first ) {
199 
200  m_first = false;
201 
202  m_provider->msg(MSG::VERBOSE) << " using beam position\tx=" << xbeam << "\ty=" << ybeam << endmsg;
203 
204  if (m_provider->msg().level() <= MSG::VERBOSE) {
205 
206  std::vector<std::string> configuredChains = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
207 
208  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
209  m_provider->msg(MSG::VERBOSE) << "Chain " << configuredChains[i] << endmsg;
210  }
211 
212  }
213 
214 
215  std::vector<ChainString>::iterator chainitr = m_chainNames.begin();
216 
217  std::vector<ChainString> chains;
218 
222  while ( chainitr!=m_chainNames.end() ) {
223 
225  ChainString& chainName = (*chainitr);
226 
227  m_provider->msg(MSG::INFO) << "process chain " << chainName << endmsg;
228 
229  if ( chainName.head() == "" ) {
230 
231  std::string selectChain = chainName.raw();
232 
233  chains.push_back( ChainString(selectChain) );
234 
235  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
236  m_provider->msg(MSG::VERBOSE) << "Matching chain " << selectChain << " (" << chainName.head() << ")" << endmsg;
237  }
238 
239  }
240  else {
241 
243  std::vector<std::string> selectChains = (*(m_tdt))->getListOfTriggers( chainName.head() );
244 
245 
246  for ( unsigned iselected=0 ; iselected<selectChains.size() ; iselected++ ) {
247 
248  selectChains[iselected] = chainName.subs( selectChains[iselected] );
249 
250 #if 0
251  std::cout << "sorting:: chain specification: " << chainName << "\traw:" << chainName.raw() << std::endl;
252  std::cout << "\tchain: " << chainName.head() << std::endl;
253  std::cout << "\tkey: " << chainName.tail() << std::endl;
254  std::cout << "\troi: " << chainName.roi() << std::endl;
255  std::cout << "\tvtx: " << chainName.vtx() << std::endl;
256  std::cout << "\tte: " << chainName.element() << std::endl;
257  std::cout << "\tind: " << chainName.extra() << std::endl;
258 #endif
259 
261  chains.push_back( ChainString(selectChains[iselected]) );
262 
263  if(m_provider->msg().level() <= MSG::VERBOSE) {
264  m_provider->msg(MSG::VERBOSE) << "Matching chain " << selectChains[iselected] << " (" << chainName.head() << ")" << endmsg;
265  }
266 
267  }
268  }
269 
270  ++chainitr;
271  }
272 
273  // m_chainNames.insert( m_chainNames.end(), chains.begin(), chains.end() );
274  m_chainNames = chains;
275 
276  for ( unsigned ic=0 ; ic<m_chainNames.size() ; ic++ ) m_provider->msg(MSG::VERBOSE) << "Analyse chain " << m_chainNames[ic] << endmsg;
277 
278  }
279 
280 
282  Filter_True filter;
283 
284  Filter_etaPT filter_etaPT(5,200);
285  Filter_Combined filter_truth( &filter_etaPT, &filter_etaPT);
286 
288  // Filter_Combined filterRef (&filter_offline, &filter_vertex);
289 
290  int iRefFilter = 1;
291  int iTestFilter = 0;
292 
293  if ( m_runPurity ) {
294  iRefFilter = 0;
295  iTestFilter = 1;
296  }
297 
298  Filter_Combined filterRef( m_filters[iRefFilter][0], &filter );
299  Filter_Combined filterTest( m_filters[iTestFilter][0], &filter );
300 
301  TrigTrackSelector selectorTruth( &filter_truth );
302  TrigTrackSelector selectorRef( &filterRef );
303  m_selectorRef = &selectorRef;
304  TrigTrackSelector selectorTest( &filterTest );
305  m_selectorTest = &selectorTest;
306 
307  if ( xbeam!=0 || ybeam!=0 ) {
308  m_selectorRef->setBeamline( xbeam, ybeam );
309  }
310 
312 
313  // clear the ntuple TIDA::Event class
314  m_event->clear();
315 
317 #ifndef XAODTRACKING_TRACKPARTICLE_H
318  const EventInfo* pEventInfo;
319 #else
320  const xAOD::EventInfo* pEventInfo;
321 #endif
322  unsigned run_number = 0;
323  uint64_t event_number = 0;
324  unsigned lumi_block = 0;
325  unsigned bunch_crossing_id = 0;
326  unsigned time_stamp = 0;
327  double mu_val = 0;
328 
329  if ( this->template retrieve(pEventInfo, "EventInfo").isFailure() ) {
330  m_provider->msg(MSG::WARNING) << "Failed to get EventInfo " << endmsg;
331  } else {
332 
333 #ifndef XAODTRACKING_TRACKPARTICLE_H
334  run_number = pEventInfo->event_ID()->run_number();
335  event_number = pEventInfo->event_ID()->event_number();
336  lumi_block = pEventInfo->event_ID()->lumi_block();
337  time_stamp = pEventInfo->event_ID()->time_stamp();
338  bunch_crossing_id = pEventInfo->event_ID()->bunch_crossing_id();
339  mu_val = pEventInfo->averageInteractionsPerCrossing();
340 #else
341  run_number = pEventInfo->runNumber();
342  event_number = pEventInfo->eventNumber();
343  lumi_block = pEventInfo->lumiBlock();
344  time_stamp = pEventInfo->timeStamp();
345  bunch_crossing_id = pEventInfo->bcid();
346  mu_val = pEventInfo->averageInteractionsPerCrossing();
347 #endif
348  }
349 
350  if(m_provider->msg().level() <= MSG::VERBOSE){
351  m_provider->msg(MSG::VERBOSE) << "run " << run_number
352  << "\tevent " << event_number
353  << "\tlb " << lumi_block << endmsg;
354  }
355 
356  // m_provider->msg(MSG::INFO) << "run " << run_number
357  // << "\tevent " << event_number
358  // << "\tlb " << lumi_block << endmsg;
359 
360  // std::cout << "run " << run_number << "\tevent " << event_number << "\tlb " << lumi_block << std::endl;
361 
362 
363  // clear the ntuple TIDA::Event class
364  m_event->clear();
365 
366  m_event->run_number(run_number);
367  m_event->event_number(event_number);
368  m_event->lumi_block(lumi_block);
369  m_event->time_stamp(time_stamp);
370  m_event->bunch_crossing_id(bunch_crossing_id);
371  m_event->mu(mu_val);
372 
375 
376  bool analyse = false;
377 
378  // Check HLTResult
379 
380  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
381 
382  const std::string& chainname = m_chainNames[ichain].head();
383 
384  if ( chainname == "" ) analyse = true;
385  else {
386 
387  //Only for trigger chains
388  if ( chainname.find("L2") == std::string::npos &&
389  chainname.find("EF") == std::string::npos &&
390  chainname.find("HLT") == std::string::npos ) continue;
391 
392  if ( m_provider->msg().level() <= MSG::DEBUG ) {
393  m_provider->msg(MSG::DEBUG) << "Chain " << chainname
394  << "\tpass " << (*m_tdt)->isPassed(chainname)
395  << "\tpres " << (*m_tdt)->getPrescale(chainname) << endmsg;
396  }
397 
398  // std::cout << "Chain " << chainname << "\tpass " << (*m_tdt)->isPassed(chainname)
399  // << "\tpres " << (*m_tdt)->getPrescale(chainname) << std::endl;
400 
401  if ( (*(m_tdt))->isPassed(chainname) || (*(m_tdt))->getPrescale(chainname) ) analyse = true;
402 
403  }
404  }
405 
406  // Remove this code to skip on truncated HLT results
407  // Need to leave the code here for the time being however, since we will
408  // still need in the future a more robust test to achieve this same
409  // functionality
410  //
411  // if ( (*m_tdt)->ExperimentalAndExpertMethods().isHLTTruncated() ) {
412  // m_provider->msg(MSG::WARNING) << "HLTResult truncated, skipping event" << endmsg;
413  // return;
414  // }
415 
416  if ( !this->m_keepAllEvents && !analyse ) {
417  // m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
418  if(m_provider->msg().level() <= MSG::VERBOSE)
419  m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
420  return;
421  }
422 
424 
425  selectorTruth.clear();
426 
427  if(m_provider->msg().level() <= MSG::VERBOSE)
428  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
429 
430  const TrigInDetTrackTruthMap* truthMap = 0;
431 
432  if ( m_mcTruth ) {
433  if(m_provider->msg().level() <= MSG::VERBOSE ) m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
434 
435  if ( this->template retrieve(truthMap, "TrigInDetTrackTruthMap").isFailure()) {
436  if(m_provider->msg().level() <= MSG::VERBOSE)
437  m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap not found" << endmsg;
438  m_hasTruthMap = false;
439  }
440  else {
441  if(m_provider->msg().level() <= MSG::VERBOSE)
442  m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap found" << endmsg;
443  m_hasTruthMap = true;
444  }
445  }
446 
447 
449 
450  std::vector<TIDA::Vertex> vertices;
451  std::vector<TIDA::Vertex> vertices_rec;
452 
453  std::vector<double> refbeamspot;
454  std::vector<double> testbeamspot;
455 
456 
457 
458 #ifndef XAODTRACKING_TRACKPARTICLE_H
459 
460  const VxContainer* primaryVtxCollection;
461 
462  if ( m_doOffline ) {
463  if ( m_provider->evtStore()->template contains<VxContainer>("VxPrimaryCandidate") ) {
464  if ( this->template retrieve(primaryVtxCollection, "VxPrimaryCandidate").isFailure()) {
465  if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "Primary vertex container not found" << endmsg;
466  }
467  else {
468  VxContainer::const_iterator vtxitr = primaryVtxCollection->begin();
469  for ( ; vtxitr != primaryVtxCollection->end(); ++vtxitr) {
470  if ( (*vtxitr)->vxTrackAtVertex()->size()>0 ) {
471  vertices.push_back( TIDA::Vertex( (*vtxitr)->recVertex().position().x(),
472  (*vtxitr)->recVertex().position().y(),
473  (*vtxitr)->recVertex().position().z(),
474  0,0,0,
475  (*vtxitr)->vxTrackAtVertex()->size() ) );
476  }
477  }
478  }
479 
480  // filter_vertex.setVertex(vertices);
481  }
482  }
483 
484 #else
485 
486  //std::vector<TIDA::Vertex> vertices;
487 
488  m_provider->msg(MSG::VERBOSE) << "fetching AOD Primary vertex container" << endmsg;
489 
490  const xAOD::VertexContainer* xaodVtxCollection = 0;
491 
492  if ( this->template retrieve( xaodVtxCollection, "PrimaryVertices" ).isFailure()) {
493  if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD Primary vertex container not found with key " << "PrimaryVertices" << endmsg;
494  }
495 
496  if ( xaodVtxCollection!=0 ) {
497 
498  m_provider->msg(MSG::VERBOSE) << "xAOD Primary vertex container " << xaodVtxCollection->size() << " entries" << endmsg;
499 
500  xAOD::VertexContainer::const_iterator vtxitr = xaodVtxCollection->begin();
501  for ( ; vtxitr != xaodVtxCollection->end(); ++vtxitr ) {
502  if ( (*vtxitr)->nTrackParticles()>0 && (*vtxitr)->vertexType()!=0 ) {
503  vertices.push_back( TIDA::Vertex( (*vtxitr)->x(),
504  (*vtxitr)->y(),
505  (*vtxitr)->z(),
507  (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
508  (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
509  (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
510  (*vtxitr)->nTrackParticles(),
512  (*vtxitr)->chiSquared(),
513  (*vtxitr)->numberDoF() ) );
514  }
515  }
516  }
517 
518 
519 #endif
520 
521 
523 
524  if ( m_mcTruth ) {
525  m_event->addChain( "Truth" );
526  m_event->back().addRoi(TIDARoiDescriptor());
527  m_event->back().back().addTracks(selectorTruth.tracks());
528  }
529 
531 
532  if ( m_doOffline ) {
533  for ( unsigned i=0 ; i<vertices.size() ; i++ ) {
534  if(m_provider->msg().level() <= MSG::VERBOSE)
535  m_provider->msg(MSG::VERBOSE) << "vertex " << i << " " << vertices[i] << endmsg;
536  m_event->addVertex(vertices[i]);
537  }
538  }
539 
541 
542  // int Noff = 0;
543  std::vector<TIDA::Track*> offline_tracks;
544  std::vector<TIDA::Track*> electron_tracks;
545  std::vector<TIDA::Track*> muon_tracks;
546 
547  std::vector<TIDA::Track*> ref_tracks;
548  std::vector<TIDA::Track*> test_tracks;
549 
550  offline_tracks.clear();
551  electron_tracks.clear();
552  muon_tracks.clear();
553 
554  ref_tracks.clear();
555  test_tracks.clear();
556 
558  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
559 
560  test_tracks.clear();
561 
563 
564  // std::string& chainname = chains[ichain];
565  const std::string& chainname = m_chainNames[ichain].head();
566  const std::string& key = m_chainNames[ichain].tail();
567  const std::string& vtx_name = m_chainNames[ichain].vtx();
568  //no currently used but retained in case
569  //const std::string& roi_name = m_chainNames[ichain].roi();
570  //const std::string& te_name = m_chainNames[ichain].element();
571 
572  m_pTthreshold = 0;
573 
574  if ( m_chainNames[ichain].postcount() ) {
575  std::string ptvalue = m_chainNames[ichain].postvalue("pt");
576  if ( ptvalue!="" ) m_pTthreshold = std::stod(ptvalue);
577  }
578 
579  // std::cout << "\tchain " << m_chainNames[ichain] << "\tchainname " << chainname << "\tvtx " << vtx_name << "\troi " << roi_name << std::endl;
580 
581  unsigned _decisiontype = TrigDefs::Physics;
582  unsigned decisiontype;
583 
584  if ( this->requireDecision() ) _decisiontype = TrigDefs::requireDecision;
585 
586 
587  if ( m_chainNames[ichain].passed() ) decisiontype = _decisiontype;
588  else decisiontype = TrigDefs::alsoDeactivateTEs;
589 
590  // if ( decisiontype==TrigDefs::requireDecision ) std::cout << "\tSUTT TrigDefs::requireDecision " << decisiontype << std::endl;
591  // if ( decisiontype==TrigDefs::Physics ) std::cout << "\tSUTT TrigDefs::Physics " << decisiontype << std::endl;
592 
593 
595  const std::string& key_index_string = m_chainNames[ichain].extra();
596  unsigned key_index = 0;
597  if ( key_index_string!="" ) key_index = std::atoi( key_index_string.c_str() );
598 
599  if ( chainname!="" && m_provider->msg().level() <= MSG::VERBOSE ) {
600 
601  m_provider->msg(MSG::VERBOSE) << "status for chain " << chainname
602  << "\tpass " << (*m_tdt)->isPassed(chainname)
603  << "\tprescale " << (*m_tdt)->getPrescale(chainname) << endmsg;
604 
605  m_provider->msg(MSG::VERBOSE) << "fetching features for chain " << chainname << endmsg;
606 
607  m_provider->msg(MSG::VERBOSE) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << endmsg;
608  }
609 
610  // std::cout << "\tstatus for chain " << chainname
611  // << "\tpass " << (*m_tdt)->isPassed( chainname )
612  // << "\tpassdt " << (*m_tdt)->isPassed( chainname, decisiontype )
613  // << "\tprescale " << (*m_tdt)->getPrescale( chainname ) << std::endl;
614 
615 
616  // m_provider->msg(MSG::INFO) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << "\t" << m_chainNames[ichain] << "\trun " << run_number << "\tevent " << event_number << endmsg;
617 
618 
619  if ( chainname!="" && !this->m_keepAllEvents && !(*m_tdt)->isPassed( chainname, decisiontype ) ) continue;
620 
623  // Trig::FeatureContainer f = (*m_tdt)->features( chainname, TrigDefs::alsoDeactivateTEs);
624 
627 
628  ChainString& chainConfig = m_chainNames[ichain];
629 
630  std::string chainName = chainConfig.head();
631 
632  m_event->addChain( chainConfig );
633 
634  TIDA::Chain& chain = m_event->back();
635 
636  if ( chainName == "" ) {
637 
638  m_selectorTest->clear();
639 
641 
642  TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor(true);
643 
644  chain.addRoi( *roiInfo );
645 
646 
647 # ifdef XAODTRACKING_TRACKPARTICLE_H
648  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>(key) ) {
649  this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, key );
650  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( key );
651  }
652 # endif
653 
654  const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
655 
656  chain.back().addTracks(testtracks);
657 
658  delete roiInfo;
659 
660  }
661  else {
662 
663  Trig::FeatureContainer f = (*m_tdt)->features( chainname, decisiontype );
664  Trig::FeatureContainer::combination_const_iterator c(f.getCombinations().begin());
665  Trig::FeatureContainer::combination_const_iterator cEnd(f.getCombinations().end());
666 
667 
668  if ( c==cEnd ) {
669  if(m_provider->msg().level() <= MSG::VERBOSE){
670  m_provider->msg(MSG::VERBOSE) << "No combinations: skipping this chain " << chainname << endmsg;
671  }
672  continue;
673  }
674 
675  if(m_provider->msg().level() <= MSG::VERBOSE) {
676  m_provider->msg(MSG::VERBOSE) << "combinations for chain " << chainname << " " << (cEnd-c) << endmsg;
677  }
678 
679  unsigned icomb = 0;
680 
681  for( ; c!=cEnd ; ++c ) {
682 
683  icomb++;
684 
685  // now add rois to this ntuple chain
686 
687  // Get seeding RoI
688  // std::vector< Trig::Feature<TrigRoiDescriptor> > initRois = c->get<TrigRoiDescriptor>("initialRoI", TrigDefs::alsoDeactivateTEs);
689  // std::vector< Trig::Feature<TrigRoiDescriptor> > initRois = c->get<TrigRoiDescriptor>("forID", TrigDefs::alsoDeactivateTEs);
690 
691  std::vector< Trig::Feature<TrigRoiDescriptor> > initRois;
692 
693  std::string roi_key = m_chainNames[ichain].roi();
694 
695  if ( roi_key=="SuperRoi" && icomb>1 ) continue;
696 
697  if ( roi_key!="" ) {
698  initRois = c->get<TrigRoiDescriptor>(roi_key, decisiontype );
699  }
700  else {
701  initRois = c->get<TrigRoiDescriptor>("forID", decisiontype );
702  if ( initRois.empty() ) initRois = c->get<TrigRoiDescriptor>("", decisiontype );
703  if ( initRois.empty() ) initRois = c->get<TrigRoiDescriptor>("initialRoI", decisiontype );
704  }
705 
706  // std::cout << "initRois.size() " << initRois.size() << std::endl;
707 
708  if ( initRois.empty() ) continue;
709 
710 
711  // for ( unsigned ir=0 ; ir<initRois.size() ; ir++ ) {
712  // std::cout << "\t" << ir << "\t" << *initRois[ir].cptr() << std::endl;
713  // }
714 
715  // Skip chains seeded by multiple RoIs: not yet implemented
716  if(initRois.size()>1 && roi_key!="SuperRoi" ) {
717  if(m_provider->msg().level() <= MSG::VERBOSE)
718  m_provider->msg(MSG::VERBOSE) << " More than one initial RoI found for seeded chain " << chainname << ": not yet supported" << endmsg;
719  continue;
720  }
721 
722  TIDARoiDescriptor* roiInfo = 0;
723 
724  if( !initRois.empty() ) {
725  const TrigRoiDescriptor* roid = initRois[0].cptr();
726 
727  if(m_provider->msg().level() <= MSG::VERBOSE)
728  m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainname << " " << *roid << endmsg;
729 
730  roiInfo = new TIDARoiDescriptor(TIDARoiDescriptorBuilder(*roid));
731  // roiInfo->etaHalfWidth(m_roiInfo->etaHalfWidth());
732  // roiInfo->phiHalfWidth(m_roiInfo->phiHalfWidth());
733  // roiInfo->etaHalfWidth(roid->etaHalfWidth());
734  // roiInfo->phiHalfWidth(roid->phiHalfWidth());
735  // roiInfo->zedHalfWidth(roid->zedHalfWidth());
736 
737  if(m_provider->msg().level() <= MSG::VERBOSE)
738  m_provider->msg(MSG::VERBOSE) << "using chain roi " << *roid << endmsg;
739 
740  }
741  else {
742  roiInfo = new TIDARoiDescriptor();
743  // roiInfo->etaHalfWidth(5);
744  // roiInfo->phiHalfWidth(M_PI);
745  // roiInfo->zedHalfWidth(m_roiInfo->zedHalfWidth());
746 
747  if(m_provider->msg().level() <= MSG::WARNING)
748  m_provider->msg(MSG::WARNING) << "roi not found" << endmsg;
749 
750  }
751 
752  if(m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::VERBOSE) << *roiInfo << endmsg;
753 
754  m_selectorTest->clear();
755 
756  m_provider->msg(MSG::VERBOSE) << "Searching for collection " << key << endmsg;
757  // std::cout << "Searching for collection " << key << std::endl;
758 
760  if ( key.find("InDetTrigParticleCreation")!=std::string::npos ||
761  key.find("_IDTrig")!=std::string::npos ||
762  key.find("_EFID")!=std::string::npos ||
763  chainName.find("EF_")!=std::string::npos ||
764  chainName.find("HLT_")!=std::string::npos ) {
765 # ifdef XAODTRACKING_TRACKPARTICLE_H
766  if ( this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, c, key ) ) testbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( c, key );
767  else if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
768 # else
769  if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
770 # endif
771  else if ( this->template selectTracks<TrackCollection>( m_selectorTest, c, key ) );
772  else if ( this->template selectTracks<TrigInDetTrackCollection>( m_selectorTest, c, truthMap, key, key_index ) );
773  else {
774  //m_provider->msg(MSG::WARNING) << "No track collection " << key << " found" << endmsg;
775  }
776  }
777  else {
779  if ( chainName.find("L2_")!=std::string::npos ) {
780  if ( this->template selectTracks<TrigInDetTrackCollection>( m_selectorTest, c, truthMap, key, key_index ) );
781  else if ( this->template selectTracks<Rec::TrackParticleContainer>( m_selectorTest, c, key ) );
782  else if ( this->template selectTracks<TrackCollection>( m_selectorTest, c, key ) );
783 # ifdef XAODTRACKING_TRACKPARTICLE_H
784  else if ( this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, c, key ) ) testbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( c, key );
785 # endif
786  else m_provider->msg(MSG::WARNING) << "No track collection " << key << " found" << endmsg;
787  }
788  }
789 
790 
791  const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
792 
793  m_provider->msg(MSG::VERBOSE) << "test tracks.size() " << testtracks.size() << endmsg;
794  // std::cout << "test tracks.size() " << testtracks.size() << std::endl;
795 
796  // std::cout << "\ttest tracks.size() " << testtracks.size() << std::endl;
797 
798  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
799  m_provider->msg(MSG::VERBOSE) << "test tracks.size() " << testtracks.size() << endmsg;
800  for ( int ii=testtracks.size() ; ii-- ; ) {
801  m_provider->msg(MSG::VERBOSE) << " test track " << ii << " " << *testtracks[ii] << endmsg;
802  //test_tracks.push_back(testtracks.at(ii));
803  }
804  }
805 
806  chain.addRoi( *roiInfo );
807 
808  chain.back().addTracks(testtracks);
809 
810  delete roiInfo;
811 
813 
815 
816  // std::cout << "vertex " << vtx_name << "\tchain " << chainName << "\tconfig " << chainConfig << std::endl;
817 
818  if ( vtx_name!="" ) {
819 
820  m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer for chain " << chainConfig << " with key " << vtx_name << endmsg;
821 
822  std::vector< Trig::Feature<xAOD::VertexContainer> > xaodtrigvertices = c->get<xAOD::VertexContainer>(vtx_name);
823 
824  if ( xaodtrigvertices.empty() ) {
825  if ( m_provider->msg().level() <= MSG::DEBUG ) {
826  m_provider->msg(MSG::WARNING) << "\tNo xAOD::VertexContainer for chain " << chainConfig << " for key " << vtx_name << endmsg;
827  }
828  }
829  else {
830 
831  m_provider->msg(MSG::VERBOSE) << "\txAOD::VertexContainer found with size " << xaodtrigvertices.size() << "\t" << vtx_name << endmsg;
832 
833  for ( unsigned iv=0 ; iv<xaodtrigvertices.size() ; iv++ ) {
834 
835  const xAOD::VertexContainer* vert = xaodtrigvertices[iv].cptr();
836 
837  m_provider->msg(MSG::VERBOSE) << "\t" << iv << " xAOD VxContainer for " << chainConfig << " " << vert << " key " << vtx_name << endmsg;
838 
839  xAOD::VertexContainer::const_iterator vtxitr = vert->begin();
840 
841  for ( ; vtxitr != vert->end(); ++vtxitr) {
844  // if ( ( (*vtxitr)->nTrackParticles()>0 && (*vtxitr)->vertexType()!=0 ) || vtx_name=="EFHistoPrmVtx" ) {
845  if ( (*vtxitr)->vertexType()!=0 || vtx_name=="EFHistoPrmVtx" ) {
846  chain.back().addVertex( TIDA::Vertex( (*vtxitr)->x(),
847  (*vtxitr)->y(),
848  (*vtxitr)->z(),
850  (*vtxitr)->covariancePosition()(Trk::x,Trk::x),
851  (*vtxitr)->covariancePosition()(Trk::y,Trk::y),
852  (*vtxitr)->covariancePosition()(Trk::z,Trk::z),
853  (*vtxitr)->nTrackParticles(),
855  (*vtxitr)->chiSquared(),
856  (*vtxitr)->numberDoF() ) );
857 
858  }
859  }
860  }
861 
862  }
863 
864  }
865 
866  }
867 
868  }
869 
870 
871  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
872  m_provider->msg(MSG::VERBOSE) << "event: " << *m_event << endmsg;
873  }
874 
876 
877  for ( unsigned iroi=0 ; iroi<chain.size() ; iroi++ ) {
878 
879  m_selectorRef->clear();
880 
881  if ( this->filterOnRoi() ) {
882  filterRef.setRoi( &chain.rois().at(iroi).roi() );
883  filterRef.containtracks( m_containTracks );
884  }
885  else filterRef.setRoi( 0 );
886 
887  test_tracks.clear();
888 
889 
903 
904  if ( m_provider->msg().level() <= MSG::VERBOSE )
905  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
906 
907  bool foundTruth = false;
908 
909  if ( !m_doOffline && m_mcTruth ) {
910 
911  if ( this->filterOnRoi() ) filter_truth.setRoi( &chain.rois().at(iroi).roi() );
912  else filter_truth.setRoi( 0 ); // don't filter on RoI unless needed
913 
914  selectorTruth.clear();
915 
916  if ( m_provider->msg().level() <= MSG::VERBOSE )
917  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
918 
919  if ( m_provider->evtStore()->template contains<TruthParticleContainer>("INav4MomTruthEvent") ) {
920  //ESD
921  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
922  foundTruth = true;
923  }
924  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("SpclMC") ) {
926  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
927  foundTruth = true;
928  }
929  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("") ) {
931  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "");
932  foundTruth = true;
933  }
934  else
935  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
936  m_provider->msg(MSG::VERBOSE) << "Truth not found - none whatsoever!" << endmsg;
937  }
938  }
939 
940 
941  if ( !m_doOffline && m_mcTruth && !foundTruth ) {
942 
943  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
944  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
945  }
946 
948 
949  const DataHandle<McEventCollection> mcevent;
950 
952 
953  std::string keys[4] = { "GEN_AOD", "TruthEvent", "", "G4Truth" };
954 
955  std::string key = "";
956 
957  bool foundcollection = false;
958 
959  for ( int ik=0 ; ik<4 ; ik++ ) {
960 
961  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
962  m_provider->msg(MSG::VERBOSE) << "Try McEventCollection: " << keys[ik] << endmsg;
963  }
964 
965  if ( !m_provider->evtStore()->template contains<McEventCollection>(keys[ik]) ) {
966  if( m_provider->msg().level() <= MSG::VERBOSE )
967  m_provider->msg(MSG::VERBOSE) << "No McEventCollection: " << keys[ik] << endmsg;
968  continue;
969  }
970 
971  if ( m_provider->msg().level() <= MSG::VERBOSE )
972  m_provider->msg(MSG::VERBOSE) << "evtStore()->retrieve( mcevent, " << keys[ik] << " )" << endmsg;
973 
974  if ( this->template retrieve( mcevent, keys[ik] ).isFailure() ) {
975  if ( m_provider->msg().level() <= MSG::VERBOSE )
976  m_provider->msg(MSG::VERBOSE) << "Failed to get McEventCollection: " << keys[ik] << endmsg;
977  }
978  else {
980  key = keys[ik];
981  if(m_provider->msg().level() <= MSG::VERBOSE)
982  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << endmsg;
983  foundcollection = true;
984  break;
985  }
986  }
987 
989  if ( !foundcollection ) {
990  if(m_provider->msg().level() <= MSG::VERBOSE)
991  m_provider->msg(MSG::WARNING) << "No MC Truth Collections of any sort, whatsoever!!!" << endmsg;
992 
993  // m_tree->Fill();
994  // return StatusCode::FAILURE;
995 
996  return;
997  }
998 
999  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
1000  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << "\tNevents " << mcevent->size() << endmsg;
1001  }
1002 
1003  McEventCollection::const_iterator evitr = mcevent->begin();
1004  McEventCollection::const_iterator evend = mcevent->end();
1005 
1006  unsigned ie = 0;
1007  unsigned ip = 0;
1008 
1009  unsigned ie_ip = 0;
1010 
1011  while ( evitr!=evend ) {
1012 
1013  int _ip = 0;
1014 
1015  int pid = HepMC::signal_process_id((*evitr));
1016 
1017  //The logic should be clarified here
1018  if ( pid!=0 ) {
1019 
1020  for (auto pitr: *(*evitr)) {
1021 
1022  selectorTruth.selectTrack( pitr );
1023 
1024  ++_ip;
1025 
1026  }
1027 
1028  }
1029  ++ie;
1030  ++evitr;
1031 
1032  if ( _ip>0 ) {
1034  // m_provider->msg(MSG::VERBOSE) << "Found " << ie << "\tpid " << pid << "\t with " << ip << " TruthParticles (GenParticles)" << endmsg;
1035  ++ie_ip;
1036  ip += _ip;
1037  }
1038  }
1039 
1040  if(m_provider->msg().level() <= MSG::VERBOSE){
1041  m_provider->msg(MSG::VERBOSE) << "Found " << ip << " TruthParticles (GenParticles) in " << ie_ip << " GenEvents out of " << ie << endmsg;
1042  m_provider->msg(MSG::VERBOSE) << "selected " << selectorTruth.size() << " TruthParticles (GenParticles)" << endmsg;
1043  }
1044 
1045  if(selectorTruth.size() > 0) foundTruth = true;
1046 
1047  if ( !(ip>0) ) {
1048  if (m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::WARNING) << "NO TRUTH PARTICLES - returning" << endmsg;
1049  return;
1050  }
1051 
1052  }
1053 
1055 
1056  // m_provider->msg(MSG::VERBOSE) << " Offline tracks " << endmsg;
1057 
1058  if ( m_doOffline ) {
1059 
1060 # ifdef XAODTRACKING_TRACKPARTICLE_H
1061  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>("InDetTrackParticles") ) {
1062  this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorRef, "InDetTrackParticles" );
1063  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( "InDetTrackParticles" );
1064  }
1065  else if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
1066  this->template selectTracks<Rec::TrackParticleContainer>( m_selectorRef, "TrackParticleCandidate" );
1067  }
1068 # else
1069  if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
1070  this->template selectTracks<Rec::TrackParticleContainer>( m_selectorRef, "TrackParticleCandidate" );
1071  }
1072 # endif
1073  else if ( m_provider->msg().level() <= MSG::WARNING ) {
1074  m_provider->msg(MSG::WARNING) << " Offline tracks not found " << endmsg;
1075  }
1076 
1077  ref_tracks = m_selectorRef->tracks();
1078 
1079  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
1080  m_provider->msg(MSG::VERBOSE) << "ref tracks.size() " << m_selectorRef->tracks().size() << endmsg;
1081  for ( int ii=m_selectorRef->tracks().size() ; ii-- ; ) {
1082  m_provider->msg(MSG::VERBOSE) << " ref track " << ii << " " << *m_selectorRef->tracks()[ii] << endmsg;
1083  }
1084  }
1085 
1086  }
1087  else {
1089  if ( m_mcTruth && foundTruth ){
1090  ref_tracks=selectorTruth.tracks();
1091  }
1092  }
1093 
1094 
1095 
1096  test_tracks.clear();
1097 
1098  for ( unsigned itrk=0 ; itrk<chain.rois().at(iroi).tracks().size() ; itrk++ ) {
1099  test_tracks.push_back(&(chain.rois().at(iroi).tracks().at(itrk)));
1100  }
1101 
1102 
1103  // std::cout << "sutt track multiplicities: offline " << offline_tracks.size() << "\ttest " << test_tracks.size() << std::endl;
1104 
1105  _analysis->setvertices( vertices.size() );
1106 
1107  if ( refbeamspot.size()>0 ) _analysis->setBeamRef( refbeamspot );
1108  if ( testbeamspot.size()>0 ) _analysis->setBeamTest( testbeamspot );
1109 
1112 
1113  if ( m_runPurity ) {
1114 
1115  if ( this->getUseHighestPT() ) HighestPTOnly( test_tracks );
1116 
1117  if ( m_pTthreshold>0 ) FilterPT( test_tracks, m_pTthreshold );
1118 
1120  m_NRois++;
1121  m_NRefTracks += test_tracks.size();
1122  m_NTestTracks += ref_tracks.size();
1123 
1125  m_associator->match( test_tracks, ref_tracks );
1126 
1127  _analysis->execute( test_tracks, ref_tracks, m_associator );
1128 
1129  }
1130  else {
1131 
1133 
1134  if ( this->getUseHighestPT() ) HighestPTOnly( ref_tracks );
1135 
1137 
1138  if ( m_pTthreshold>0 ) FilterPT( ref_tracks, m_pTthreshold );
1139 
1141  m_NRois++;
1142  m_NRefTracks += ref_tracks.size();
1143  m_NTestTracks += test_tracks.size();
1144 
1146  m_associator->match( ref_tracks, test_tracks );
1147 
1148  // std::cout << "SUTT: execute : N tracks " << ref_tracks.size() << " " << test_tracks.size() << std::endl;
1149 
1150  _analysis->setroi( &chain.rois().at(iroi).roi() );
1151  _analysis->execute( ref_tracks, test_tracks, m_associator );
1152 
1153  // std::cout << "chain " << m_chainNames[ichain] << " " << "\tvtx name " << vtx_name << std::endl;
1154 
1155  if ( vtx_name!="" ) {
1157  std::vector<TIDA::Vertex> vr = chain.rois().at(iroi).vertices();
1158  std::vector<TIDA::Vertex*> vtx_rec;
1159  for ( unsigned iv=0 ; iv<vr.size() ; iv++ ) vtx_rec.push_back( &vr[iv] );
1160 
1161  std::vector<TIDA::Vertex*> vtx;
1162  if ( this->getVtxIndex()<0 ) {
1163  for ( unsigned iv=0 ; iv<vertices.size() ; iv++ ) vtx.push_back( &vertices[iv] );
1164  }
1165  else {
1166  if ( vertices.size()>unsigned(this->getVtxIndex()) ) vtx.push_back( &vertices[this->getVtxIndex()] );
1167  }
1168 
1169  _analysis->execute_vtx( vtx, vtx_rec, m_event );
1170  }
1171 
1172  }
1173 
1174  if ( _analysis->debug() ) {
1175  m_provider->msg(MSG::INFO) << "Missing track for " << m_chainNames[ichain]
1176  << "\trun " << run_number
1177  << "\tevent " << event_number
1178  << "\tlb " << lumi_block << endmsg;
1179  }
1180 
1181  }
1182 
1183  }
1184 
1185  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
1186  m_provider->msg(MSG::VERBOSE) << "\n\nEvent " << *m_event << endmsg;
1187  }
1188  }

◆ mcTruth()

bool T_AnalysisConfig< T >::mcTruth
inlineinherited

Definition at line 261 of file T_AnalysisConfig.h.

261 { return m_mcTruth; }

◆ name()

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

Definition at line 235 of file T_AnalysisConfig.h.

235 {return m_analysisInstanceName;}

◆ processElectrons()

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

select offline electrons

Definition at line 703 of file T_AnalysisConfig.h.

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

◆ processMuons()

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

select offlinqe muons

Definition at line 789 of file T_AnalysisConfig.h.

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

◆ processTaus()

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

select offline taus

Definition at line 846 of file T_AnalysisConfig.h.

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

◆ referenceChains()

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

Definition at line 244 of file T_AnalysisConfig.h.

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

◆ releaseData() [1/2]

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

Definition at line 273 of file T_AnalysisConfig.h.

273 { return m_releaseData; }

◆ releaseData() [2/2]

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

Definition at line 274 of file T_AnalysisConfig.h.

274 { m_releaseData = s; }

◆ requireDecision()

bool T_AnalysisConfig< T >::requireDecision
inlineinherited

Definition at line 288 of file T_AnalysisConfig.h.

288 { return m_requireDecision; }

◆ retrieve()

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

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

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

Definition at line 573 of file T_AnalysisConfig.h.

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

◆ select() [1/3]

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

Definition at line 371 of file T_AnalysisConfig.h.

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

◆ select() [2/3]

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

Definition at line 394 of file T_AnalysisConfig.h.

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

◆ select() [3/3]

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

variances

quality

Definition at line 342 of file T_AnalysisConfig.h.

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

◆ selectionChains()

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

Definition at line 251 of file T_AnalysisConfig.h.

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

◆ selectTracks() [1/4]

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

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

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

Definition at line 441 of file T_AnalysisConfig.h.

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

◆ selectTracks() [2/4]

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

commented code intentionally left for development purposes ...

Definition at line 591 of file T_AnalysisConfig.h.

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

◆ selectTracks() [3/4]

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

lagacy run 2 access

Definition at line 487 of file T_AnalysisConfig.h.

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

◆ selectTracks() [4/4]

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

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

get the correspondiong TE

get all the named collections attached to the TE

now got the collectionVector, can navigate through this

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

useful for debug

Definition at line 523 of file T_AnalysisConfig.h.

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

◆ selectTracksNotEmpty()

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

Definition at line 608 of file T_AnalysisConfig.h.

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

◆ setBeamX()

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

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamX=d; }

◆ setBeamY()

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

Definition at line 264 of file T_AnalysisConfig.h.

264 { m_beamY=d; }

◆ setBeamZ()

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

Definition at line 265 of file T_AnalysisConfig.h.

265 { m_beamZ=d; }

◆ setFilterOnRoi()

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

Definition at line 285 of file T_AnalysisConfig.h.

285 { return m_filterOnRoi=b; }

◆ setGenericFlag()

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

Definition at line 271 of file T_AnalysisConfig.h.

271 { m_genericFlag=b; }

◆ setMCTruth()

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

Definition at line 260 of file T_AnalysisConfig.h.

260 { m_mcTruth=b; }

◆ setRequireDecision()

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

Definition at line 287 of file T_AnalysisConfig.h.

287 { m_requireDecision=b; }

◆ setRunPurity()

template<typename T >
void T_AnalysisConfig_Tier0< T >::setRunPurity ( bool  b)
inline

Definition at line 153 of file T_AnalysisConfig_Tier0.h.

153 { m_runPurity=b; }

◆ setShifter()

template<typename T >
void T_AnalysisConfig_Tier0< T >::setShifter ( bool  b)
inline

Definition at line 155 of file T_AnalysisConfig_Tier0.h.

155 { m_shifter=b; }

◆ setUseHighestPT()

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

Definition at line 278 of file T_AnalysisConfig.h.

278 { m_useHighestPT=b; }

◆ setVtxIndex()

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

Definition at line 281 of file T_AnalysisConfig.h.

281 { m_vtxIndex=i; }

◆ testChains()

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

Definition at line 237 of file T_AnalysisConfig.h.

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

◆ useBeamCondSvc()

template<typename T >
void T_AnalysisConfig_Tier0< T >::useBeamCondSvc ( bool  b)
inline

Definition at line 157 of file T_AnalysisConfig_Tier0.h.

157 { m_useBeamCondSvc = b; }

Member Data Documentation

◆ _analysis

template<typename T >
Analysis_Tier0* T_AnalysisConfig_Tier0< T >::_analysis

Definition at line 163 of file T_AnalysisConfig_Tier0.h.

◆ m_analyses

template<typename T >
std::vector<Analysis_Tier0*> T_AnalysisConfig_Tier0< T >::m_analyses
protected

Definition at line 1225 of file T_AnalysisConfig_Tier0.h.

◆ m_analysis

TrackAnalysis* T_AnalysisConfig< T >::m_analysis
protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

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

Definition at line 965 of file T_AnalysisConfig.h.

◆ m_associator

TrackAssociator* T_AnalysisConfig< T >::m_associator
protectedinherited

Definition at line 985 of file T_AnalysisConfig.h.

◆ m_beamX

double T_AnalysisConfig< T >::m_beamX
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_beamY

double T_AnalysisConfig< T >::m_beamY
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_beamZ

double T_AnalysisConfig< T >::m_beamZ
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_chainNames

template<typename T >
std::vector<ChainString> T_AnalysisConfig_Tier0< T >::m_chainNames
protected

Definition at line 1224 of file T_AnalysisConfig_Tier0.h.

◆ m_containTracks

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_containTracks
protected

Definition at line 1252 of file T_AnalysisConfig_Tier0.h.

◆ m_doBjets

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doBjets
protected

Definition at line 1232 of file T_AnalysisConfig_Tier0.h.

◆ m_doElectrons

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doElectrons
protected

Definition at line 1230 of file T_AnalysisConfig_Tier0.h.

◆ m_doMuons

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doMuons
protected

Definition at line 1229 of file T_AnalysisConfig_Tier0.h.

◆ m_doOffline

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doOffline
protected

Definition at line 1228 of file T_AnalysisConfig_Tier0.h.

◆ m_doTaus

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doTaus
protected

Definition at line 1231 of file T_AnalysisConfig_Tier0.h.

◆ m_doTauThreeProng

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_doTauThreeProng
protected

Definition at line 1234 of file T_AnalysisConfig_Tier0.h.

◆ m_event

template<typename T >
TIDA::Event* T_AnalysisConfig_Tier0< T >::m_event
protected

Definition at line 1222 of file T_AnalysisConfig_Tier0.h.

◆ m_filterOnRoi

bool T_AnalysisConfig< T >::m_filterOnRoi
protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

◆ m_filters

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

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_first

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_first
protected

Definition at line 1250 of file T_AnalysisConfig_Tier0.h.

◆ m_genericFlag

int T_AnalysisConfig< T >::m_genericFlag
protectedinherited

Definition at line 992 of file T_AnalysisConfig.h.

◆ m_hasTruthMap

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_hasTruthMap
protected

Definition at line 1233 of file T_AnalysisConfig_Tier0.h.

◆ m_keepAllEvents

bool T_AnalysisConfig< T >::m_keepAllEvents
protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_keys

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

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_mcTruth

bool T_AnalysisConfig< T >::m_mcTruth
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_NRefTracks

template<typename T >
int T_AnalysisConfig_Tier0< T >::m_NRefTracks
protected

Definition at line 1241 of file T_AnalysisConfig_Tier0.h.

◆ m_NRois

template<typename T >
int T_AnalysisConfig_Tier0< T >::m_NRois
protected

output stats

Definition at line 1240 of file T_AnalysisConfig_Tier0.h.

◆ m_NTestTracks

template<typename T >
int T_AnalysisConfig_Tier0< T >::m_NTestTracks
protected

Definition at line 1242 of file T_AnalysisConfig_Tier0.h.

◆ m_outputFileName

template<typename T >
std::string T_AnalysisConfig_Tier0< T >::m_outputFileName
protected

Definition at line 1237 of file T_AnalysisConfig_Tier0.h.

◆ m_provider

T * T_AnalysisConfig< T >::m_provider
protectedinherited

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_pTthreshold

template<typename T >
double T_AnalysisConfig_Tier0< T >::m_pTthreshold
protected

Definition at line 1248 of file T_AnalysisConfig_Tier0.h.

◆ m_refChainKey

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

Definition at line 973 of file T_AnalysisConfig.h.

◆ m_refChainName

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

Definition at line 972 of file T_AnalysisConfig.h.

◆ m_releaseData

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

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_requireDecision

bool T_AnalysisConfig< T >::m_requireDecision
protectedinherited

Definition at line 1003 of file T_AnalysisConfig.h.

◆ m_runPurity

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_runPurity
protected

Definition at line 1244 of file T_AnalysisConfig_Tier0.h.

◆ m_selectorRef

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorRef
protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorSel

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorSel
protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_selectorTest

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorTest
protectedinherited

Definition at line 982 of file T_AnalysisConfig.h.

◆ m_shifter

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_shifter
protected

Definition at line 1246 of file T_AnalysisConfig_Tier0.h.

◆ m_tauEtCutOffline

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_tauEtCutOffline
protected

Definition at line 1235 of file T_AnalysisConfig_Tier0.h.

◆ m_tdt

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

Definition at line 959 of file T_AnalysisConfig.h.

◆ m_testChainKey

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

Definition at line 976 of file T_AnalysisConfig.h.

◆ m_testChainName

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

Definition at line 975 of file T_AnalysisConfig.h.

◆ m_testType

template<typename T >
std::string T_AnalysisConfig_Tier0< T >::m_testType
protected

Definition at line 1226 of file T_AnalysisConfig_Tier0.h.

◆ m_types

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

Definition at line 969 of file T_AnalysisConfig.h.

◆ m_useBeamCondSvc

template<typename T >
bool T_AnalysisConfig_Tier0< T >::m_useBeamCondSvc
protected

Definition at line 1220 of file T_AnalysisConfig_Tier0.h.

◆ m_useHighestPT

bool T_AnalysisConfig< T >::m_useHighestPT
protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

◆ m_vtxIndex

int T_AnalysisConfig< T >::m_vtxIndex
protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

The documentation for this class was generated from the following file:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
T_AnalysisConfig< T >::m_selectorRef
TrigTrackSelector * m_selectorRef
Definition: T_AnalysisConfig.h:981
Trig::FeatureContainer::combination_const_iterator
std::vector< Combination >::const_iterator combination_const_iterator
Definition: FeatureContainer.h:69
TrackAnalysis::setBeamTest
void setBeamTest(double x, double y, double z=0)
Definition: TrackAnalysis.h:110
Trk::y
@ y
Definition: ParamDefs.h:56
TrackAnalysis::initialise
virtual void initialise()=0
standard operation interface
T_AnalysisConfig< T >::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:969
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
T_AnalysisConfig< T >::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:988
Trig::Feature
Definition: Feature.h:112
Analysis_Tier0::setvertices
void setvertices(int numvtx)
Definition: Analysis_Tier0.h:52
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TIDA::isGoodOffline
bool isGoodOffline(const Analysis::Electron &elec)
Definition: OfflineObjectSelection.cxx:122
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
T_AnalysisConfig< T >::m_filterOnRoi
bool m_filterOnRoi
Definition: T_AnalysisConfig.h:1001
T_AnalysisConfig_Tier0::m_containTracks
bool m_containTracks
Definition: T_AnalysisConfig_Tier0.h:1252
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:57
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
T_AnalysisConfig< T >::m_provider
T * m_provider
Definition: T_AnalysisConfig.h:957
TrigTrackSelector::clear
virtual void clear() override
Definition: TrigTrackSelector.h:102
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
TrackAnalysis::finalise
virtual void finalise()=0
TIDA::Roi::addTracks
void addTracks(const std::vector< TIDA::Track > &tracks)
accessors for the track vector
Definition: TIDARoi.h:46
T_AnalysisConfig< T >::m_tdt
ToolHandle< Trig::TrigDecisionTool > * m_tdt
Definition: T_AnalysisConfig.h:959
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition: DataVector.h:837
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
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
T_AnalysisConfig_Tier0::m_chainNames
std::vector< ChainString > m_chainNames
Definition: T_AnalysisConfig_Tier0.h:1224
JiveXML::Event
struct Event_t Event
Definition: ONCRPCServer.h:65
T_AnalysisConfig< T >::analysis
const TrackAnalysis * analysis() const
Definition: T_AnalysisConfig.h:258
Analysis_Tier0::execute_vtx
virtual void execute_vtx(const std::vector< TIDA::Vertex * > &vtx0, const std::vector< TIDA::Vertex * > &vtx1, const TIDA::Event *tevt=0)
Definition: Analysis_Tier0.cxx:755
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:121
Analysis_Tier0::debug
bool debug() const
Definition: Analysis_Tier0.h:66
TIDARoiDescriptor
Describes the Region of Ineterest geometry It has basically 8 parameters.
Definition: TIDARoiDescriptor.h:42
T_AnalysisConfig_Tier0::m_doTaus
bool m_doTaus
Definition: T_AnalysisConfig_Tier0.h:1231
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
T_AnalysisConfig_Tier0::m_runPurity
bool m_runPurity
Definition: T_AnalysisConfig_Tier0.h:1244
T_AnalysisConfig< T >::getUseHighestPT
bool getUseHighestPT() const
Definition: T_AnalysisConfig.h:279
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:620
TIDA::Event::lumi_block
void lumi_block(unsigned lb)
Definition: TIDAEvent.h:44
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.
T_AnalysisConfig_Tier0::m_doBjets
bool m_doBjets
Definition: T_AnalysisConfig_Tier0.h:1232
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
TIDA::Chain::addRoi
void addRoi(TIDA::Roi &roi)
add and roi by root dictionary class
Definition: TIDAChain.h:44
T_AnalysisConfig_Tier0::m_doTauThreeProng
bool m_doTauThreeProng
Definition: T_AnalysisConfig_Tier0.h:1234
T_AnalysisConfig< T >::m_analysisInstanceName
std::string m_analysisInstanceName
Definition: T_AnalysisConfig.h:965
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
Container
storage of the time histories of all the cells
covarianceTool.filter
filter
Definition: covarianceTool.py:514
T_AnalysisConfig< T >::m_keys
std::vector< std::vector< std::string > > m_keys
Definition: T_AnalysisConfig.h:970
Trig::FeatureContainer
Definition: FeatureContainer.h:54
Analysis_Tier0::execute
virtual void execute(const std::vector< TIDA::Track * > &referenceTracks, const std::vector< TIDA::Track * > &testTracks, TrackAssociator *associator)
Definition: Analysis_Tier0.cxx:553
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
T_AnalysisConfig_Tier0::m_NRois
int m_NRois
output stats
Definition: T_AnalysisConfig_Tier0.h:1240
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
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_Tier0::m_pTthreshold
double m_pTthreshold
Definition: T_AnalysisConfig_Tier0.h:1248
T_AnalysisConfig< T >::m_beamY
double m_beamY
Definition: T_AnalysisConfig.h:990
T_AnalysisConfig< T >::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:990
TIDA::Event::back
TIDA::Chain & back()
get the last chain from the vector
Definition: TIDAEvent.h:89
lumiFormat.i
int i
Definition: lumiFormat.py:85
TIDA::Event::event_number
void event_number(unsigned long long e)
Definition: TIDAEvent.h:43
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
T_AnalysisConfig< T >::m_analysis
TrackAnalysis * m_analysis
Definition: T_AnalysisConfig.h:986
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
T_AnalysisConfig< T >::getVtxIndex
int getVtxIndex() const
Definition: T_AnalysisConfig.h:282
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfig< T >::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1003
TrigInDetTrackTruthMap
Definition: TrigInDetTrackTruthMap.h:38
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
HighestPTOnly
void HighestPTOnly(std::vector< T * > &tracks)
Definition: TIDATools.h:20
hist_file_dump.f
f
Definition: hist_file_dump.py:135
T_AnalysisConfig< T >::m_keepAllEvents
bool m_keepAllEvents
Definition: T_AnalysisConfig.h:995
T_AnalysisConfig_Tier0::m_doElectrons
bool m_doElectrons
Definition: T_AnalysisConfig_Tier0.h:1230
VxContainer
Definition: VxContainer.h:28
Analysis::MuonContainer
definition of StoreGate container holding a vector of Analysis::Muon
Definition: Reconstruction/MuonIdentification/muonEvent/muonEvent/MuonContainer.h:38
TrackAnalysis::setBeamRef
void setBeamRef(double x, double y, double z=0)
set the beamline positions
Definition: TrackAnalysis.h:109
Filter_True
default simple filter which accepts all tracks
Definition: Filters.h:26
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
T_AnalysisConfig_Tier0::m_event
TIDA::Event * m_event
Definition: T_AnalysisConfig_Tier0.h:1222
T_AnalysisConfig_Tier0::m_doOffline
bool m_doOffline
Definition: T_AnalysisConfig_Tier0.h:1228
T_AnalysisConfig_Tier0::m_testType
std::string m_testType
Definition: T_AnalysisConfig_Tier0.h:1226
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
selection
const std::string selection
Definition: fbtTestBasics.cxx:74
T_AnalysisConfig< T >::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:573
T_AnalysisConfig< T >::m_associator
TrackAssociator * m_associator
Definition: T_AnalysisConfig.h:985
TrackSelector::tracks
const std::vector< TIDA::Track * > & tracks() const
Definition: Trigger/TrigAnalysis/TrigInDetAnalysis/TrigInDetAnalysis/TrackSelector.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
T_AnalysisConfig_Tier0::m_shifter
bool m_shifter
Definition: T_AnalysisConfig_Tier0.h:1246
EventInfo
This class provides general information about an event. Event information is provided by the accessor...
Definition: EventInfo/EventInfo/EventInfo.h:43
Filter_Combined
Definition: Filters.h:225
TIDA::Chain
Definition: TIDAChain.h:28
DataHandle
an iterator over instances of a given type in StoreGateSvc. It d-casts and caches locally the pointed...
Definition: DataHandle.h:42
TIDARoiDescriptorBuilder
Definition: TIDARoiDescriptorBuilder.h:21
xAOD::Electron_v1
Definition: Electron_v1.h:34
T_AnalysisConfig< T >::loop
virtual void loop()=0
T_AnalysisConfig< T >::m_useHighestPT
bool m_useHighestPT
Definition: T_AnalysisConfig.h:997
TIDA::Event::addVertex
void addVertex(const TIDA::Vertex &v)
Definition: TIDAEvent.h:71
TIDA::Event::clear
void clear()
clear the event
Definition: TIDAEvent.h:86
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
T_AnalysisConfig_Tier0::m_first
bool m_first
Definition: T_AnalysisConfig_Tier0.h:1250
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TrackAnalysis::setroi
void setroi(TIDARoiDescriptor *r)
Definition: TrackAnalysis.h:139
TIDA::Event::mu
void mu(double m)
Definition: TIDAEvent.h:47
python.copyTCTOutput.chains
chains
Definition: copyTCTOutput.py:81
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
ChainString::head
const std::string & head() const
Definition: ChainString.h:33
T_AnalysisConfig_Tier0::m_NTestTracks
int m_NTestTracks
Definition: T_AnalysisConfig_Tier0.h:1242
TrackTrigObject
Definition: TrackTrigObject.h:21
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
T_AnalysisConfig_Tier0::m_tauEtCutOffline
bool m_tauEtCutOffline
Definition: T_AnalysisConfig_Tier0.h:1235
T_AnalysisConfig_Tier0::m_NRefTracks
int m_NRefTracks
Definition: T_AnalysisConfig_Tier0.h:1241
T_AnalysisConfig_Tier0::m_hasTruthMap
bool m_hasTruthMap
Definition: T_AnalysisConfig_Tier0.h:1233
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
TrigTrackSelector::setBeamline
void setBeamline(double x, double y, double z=0)
Definition: TrigTrackSelector.h:94
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_Tier0::m_useBeamCondSvc
bool m_useBeamCondSvc
Definition: T_AnalysisConfig_Tier0.h:1220
T_AnalysisConfig< T >::m_vtxIndex
int m_vtxIndex
Definition: T_AnalysisConfig.h:999
xAOD::EgammaHelpers::getOriginalTrackParticle
const xAOD::TrackParticle * getOriginalTrackParticle(const xAOD::Electron *el)
Helper function for getting the "Original" Track Particle (i.e before GSF) via the electron.
Definition: ElectronxAODHelpers.cxx:11
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
T_AnalysisConfig< T >::filterOnRoi
bool filterOnRoi() const
Definition: T_AnalysisConfig.h:284
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TIDA::Associator::match
virtual void match(const std::vector< T * > &s1, const std::vector< S * > &s2)=0
python.StandardJetMods.vr
vr
Definition: StandardJetMods.py:305
T_AnalysisConfig< T >::m_genericFlag
int m_genericFlag
Definition: T_AnalysisConfig.h:992
TIDA::Event::bunch_crossing_id
void bunch_crossing_id(unsigned b)
Definition: TIDAEvent.h:46
Trk::x
@ x
Definition: ParamDefs.h:55
T_AnalysisConfig< T >::m_beamZ
double m_beamZ
Definition: T_AnalysisConfig.h:990
T_AnalysisConfig< T >::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:979
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
TIDA::Event::run_number
void run_number(unsigned r)
accessors
Definition: TIDAEvent.h:42
T_AnalysisConfig< T >::m_selectorTest
TrigTrackSelector * m_selectorTest
Definition: T_AnalysisConfig.h:982
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
T_AnalysisConfig< T >::name
const std::string & name() const
Definition: T_AnalysisConfig.h:235
T_AnalysisConfig_Tier0::m_doMuons
bool m_doMuons
Definition: T_AnalysisConfig_Tier0.h:1229
T_AnalysisConfig_Tier0::_analysis
Analysis_Tier0 * _analysis
Definition: T_AnalysisConfig_Tier0.h:163
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
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< T >::requireDecision
bool requireDecision() const
Definition: T_AnalysisConfig.h:288
T_AnalysisConfig< T >::select
bool select(std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
Definition: T_AnalysisConfig.h:342
T_AnalysisConfig< T >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig< T >::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:993
T_AnalysisConfig< T >::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:968
Generated on Sun Dec 22 2024 21:44:56 for ATLAS Offline Software by   doxygen 1.8.18