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

#include <T_AnalysisConfigMT_Tier0.h>

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

Public Member Functions

 T_AnalysisConfigMT_Tier0 (const std::string &analysisInstanceName, const std::string &testChainName, const std::string &testType, const std::string &testKey, const std::string &referenceChainName, const std::string &referenceType, const std::string &referenceKey, TrackFilter *testFilter, TrackFilter *referenceFilter, TrackAssociator *associator, TrackAnalysis *analysis, TagNProbe *TnP_tool=0)
 
virtual ~T_AnalysisConfigMT_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)
 
std::string releaseData () const
 
void releaseData (const std::string &s)
 
void keepAllEvents (bool b)
 
void setUseHighestPT (bool b)
 
bool getUseHighestPT () const
 
void setVtxIndex (int i)
 
int getVtxIndex () const
 
bool filterOnRoi () const
 
bool setFilterOnRoi (bool b)
 
void setRequireDecision (bool b)
 
bool requireDecision () const
 

Public Attributes

A * _analysis
 

Protected Member Functions

virtual void loop ()
 
virtual void book ()
 
virtual void finalize ()
 
void set_monTool (ToolHandle< GenericMonitoringTool > *m)
 
ToolHandle< GenericMonitoringTool > * monTool ()
 
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< A * > 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
 
TagNProbe * m_TnP_tool
 
TH1F * m_invmass
 
TH1F * m_invmass_obj
 
ToolHandle< GenericMonitoringTool > * m_monTool
 
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, typename A = Analysis_Tier0>
class T_AnalysisConfigMT_Tier0< T, A >

Definition at line 93 of file T_AnalysisConfigMT_Tier0.h.

Constructor & Destructor Documentation

◆ T_AnalysisConfigMT_Tier0()

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

FIXME: the m_event should not be needed, we need to make this a local variable

Definition at line 103 of file T_AnalysisConfigMT_Tier0.h.

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

◆ ~T_AnalysisConfigMT_Tier0()

template<typename T , typename A = Analysis_Tier0>
virtual T_AnalysisConfigMT_Tier0< T, A >::~T_AnalysisConfigMT_Tier0 ( )
inlinevirtual

Definition at line 159 of file T_AnalysisConfigMT_Tier0.h.

159  {
160  delete m_event;
161  if ( m_TnP_tool != 0 ) delete m_TnP_tool ;
162  }

Member Function Documentation

◆ addReferenceChain()

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

Definition at line 201 of file T_AnalysisConfig.h.

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

◆ addReferenceFilter()

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

Definition at line 210 of file T_AnalysisConfig.h.

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

◆ addSelectionChain()

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

Definition at line 205 of file T_AnalysisConfig.h.

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

◆ addSelectionFilter()

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

Definition at line 211 of file T_AnalysisConfig.h.

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

◆ addTestChain()

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

Definition at line 197 of file T_AnalysisConfig.h.

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

◆ addTestFilter()

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

Definition at line 209 of file T_AnalysisConfig.h.

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

◆ analysis()

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

Definition at line 256 of file T_AnalysisConfig.h.

256 {return m_analysis;}

◆ beamX()

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

Definition at line 264 of file T_AnalysisConfig.h.

264 { return m_beamX; }

◆ beamY()

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

Definition at line 265 of file T_AnalysisConfig.h.

265 { return m_beamY; }

◆ beamZ()

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

Definition at line 266 of file T_AnalysisConfig.h.

266 { return m_beamZ; }

◆ book()

template<typename T , typename A = Analysis_Tier0>
virtual void T_AnalysisConfigMT_Tier0< T, A >::book ( )
inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1079 of file T_AnalysisConfigMT_Tier0.h.

1079  {
1080 
1081  if(m_provider->msg().level() <= MSG::VERBOSE)
1082  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigMT_Tier0::book() " << name() << endmsg;
1083 
1084  m_provider->msg(MSG::ERROR) << "AnalysisConfigMT_Tier0::book() should no longer be called: " << name() << endmsg;
1085 
1086 
1087  }

◆ containTracks()

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

Definition at line 170 of file T_AnalysisConfigMT_Tier0.h.

170 { m_containTracks = b; }

◆ execute()

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

Definition at line 223 of file T_AnalysisConfig.h.

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

◆ filterOnRoi()

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

Definition at line 282 of file T_AnalysisConfig.h.

282 { return m_filterOnRoi; }

◆ finalize()

template<typename T , typename A = Analysis_Tier0>
virtual void T_AnalysisConfigMT_Tier0< T, A >::finalize ( )
inlineprotectedvirtual

Reimplemented from T_AnalysisConfig< T >.

Definition at line 1091 of file T_AnalysisConfigMT_Tier0.h.

1091  {
1092 
1093  if(m_provider->msg().level() <= MSG::VERBOSE){
1094  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigMT_Tier0::finalise() " << m_provider->name() << endmsg;
1095  }
1096 
1097  m_analysis->finalise();
1098 
1099  // deleting instance of TnP_tool and setting pointer to null
1100  if ( m_TnP_tool != 0 ) {
1101  delete m_TnP_tool ;
1102  m_TnP_tool = 0 ;
1103  }
1104 
1105  m_provider->msg(MSG::INFO) << m_provider->name() << " " << m_chainNames[0] << " \tNRois processed: " << m_NRois << "\tRef tracks: " << m_NRefTracks << "\tTestTracks: " << m_NTestTracks << endmsg;
1106 
1107  if(m_provider->msg().level() <= MSG::VERBOSE) {
1108  m_provider->msg(MSG::VERBOSE) << m_provider->name() << " finalised" << endmsg;
1109  }
1110  }

◆ genericFlag()

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

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_genericFlag; }

◆ getBeamspot() [1/2]

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

Definition at line 632 of file T_AnalysisConfig.h.

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

◆ getBeamspot() [2/2]

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

Definition at line 661 of file T_AnalysisConfig.h.

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

◆ getCollection()

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

new MT feature access

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

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

Definition at line 297 of file T_AnalysisConfig.h.

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

◆ getUseHighestPT()

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

Definition at line 277 of file T_AnalysisConfig.h.

277 { return m_useHighestPT; }

◆ getVtxIndex()

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

Definition at line 280 of file T_AnalysisConfig.h.

280 { return m_vtxIndex; }

◆ initialize()

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

Definition at line 214 of file T_AnalysisConfig.h.

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

◆ keepAllEvents()

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

Definition at line 274 of file T_AnalysisConfig.h.

274 { m_keepAllEvents = b; }

◆ loop()

template<typename T , typename A = Analysis_Tier0>
virtual void T_AnalysisConfigMT_Tier0< T, A >::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

fetch offline vertices ...

add the truth particles if needed

now add the vertices

now add the offline tracks and reco objects

AOD

xAOD::TruthParticles

anything else?

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

now as a check go through the GenEvent collection

found this key

not found any truth collection

count of "events" - or interactions

count of particles

count of "events with some particles"

count of particles in this interaction

hooray! actually found a sensible event

if there were some particles in this interaction ...

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

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

create chains for ntpl

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

useful debug information to be kept in for the time being

useful debug information to be kept in

Get chain combinations and loop on them

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

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

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

dummy full scan chain

MT Vertex access

new Roi based feature access

new FeatureRequestDescriptor with leg access

count of how many rois processed so far

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

check this is not a spurious TDT match

get the tracks

create analysis chain

get tracks

now get the vertices

retrieve online vertices

"offline" of "roi" type chains

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

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

will leave as it is for the time being

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 191 of file T_AnalysisConfigMT_Tier0.h.

191  {
192 
193  bool TnP_flag = (m_TnP_tool != 0) ; // flag for tag and probe analysis
194 
195  if( m_provider->msg().level() <= MSG::VERBOSE) {
196  m_provider->msg(MSG::VERBOSE) << "AnalysisConfigMT_Tier0::loop() for " << T_AnalysisConfig<T>::m_analysisInstanceName << endmsg;
197  }
198 
199  // get (offline) beam position
200  double xbeam = 0;
201  double ybeam = 0;
202 
203  if ( m_first ) {
204 
205  m_first = false;
206 
207  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
208  m_provider->msg(MSG::VERBOSE) << " using beam position\tx=" << xbeam << "\ty=" << ybeam << endmsg;
209 
210  std::vector<std::string> configuredChains = (*(m_tdt))->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
211 
212  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
213  // std::cout << "Configured chain " << configuredChains[i] << std::endl;
214  m_provider->msg(MSG::VERBOSE) << "Chain " << configuredChains[i] << endmsg;
215  }
216  }
217 
218  // std::cout << "\tloop() analyse chains " << m_chainNames.size() << std::endl;
219 
220  std::vector<ChainString>::iterator chainitr = m_chainNames.begin();
221 
222  std::vector<ChainString> chains;
223 
227  while ( chainitr!=m_chainNames.end() ) {
228 
230  ChainString& chainName = (*chainitr);
231 
232  if (m_provider->msg().level() <= MSG::VERBOSE) {
233  m_provider->msg(MSG::VERBOSE) << "process chain " << chainName << endmsg;
234  }
235 
236  if ( chainName.head() == "" ) {
237 
238  std::string selectChain = chainName.raw();
239 
240  chains.push_back( ChainString(selectChain) );
241 
242  }
243  else {
244 
246  std::vector<std::string> selectChains = (*(m_tdt))->getListOfTriggers( chainName.head() );
247 
248  for ( unsigned iselected=0 ; iselected<selectChains.size() ; iselected++ ) {
249 
250  selectChains[iselected] = chainName.subs( selectChains[iselected] );
251 
252 #if 0
253  std::cout << "sorting:: chain specification: " << chainName << "\traw:" << chainName.raw() << std::endl;
254  std::cout << "\tchain: " << chainName.head() << std::endl;
255  std::cout << "\tkey: " << chainName.tail() << std::endl;
256  std::cout << "\tind: " << chainName.extra() << std::endl;
257  std::cout << "\troi: " << chainName.roi() << std::endl;
258  std::cout << "\tvtx: " << chainName.vtx() << std::endl;
259  std::cout << "\tte: " << chainName.element() << std::endl;
260 #endif
261 
263  chains.push_back( ChainString(selectChains[iselected]) );
264 
265  if(m_provider->msg().level() <= MSG::VERBOSE) {
266  m_provider->msg(MSG::VERBOSE) << "Matching chain " << selectChains[iselected] << " (" << chainName.head() << ")" << endmsg;
267  }
268 
269  // std::cout<< "\tMatching chain " << sc << " (" << chainName.head() << ")" << std::endl;
270 
271  }
272  }
273 
274  chainitr++;
275  }
276 
277  // m_chainNames.insert( m_chainNames.end(), chains.begin(), chains.end() );
278  m_chainNames = chains;
279 
280  if(m_provider->msg().level() <= MSG::VERBOSE) {
281  for ( size_t ic=m_chainNames.size() ; ic-- ; ) m_provider->msg(MSG::VERBOSE) << "Analyse chain " << m_chainNames[ic] << endmsg;
282  }
283 
284  }
285 
286  // std::cout << "\tloop() event analysis ..." << std::endl;
287 
289  Filter_True filter;
290 
291  Filter_etaPT filter_etaPT(5,200);
292  Filter_Combined filter_truth( &filter_etaPT, &filter_etaPT);
293 
295  // Filter_Combined filterRef (&filter_offline, &filter_vertex);
296 
297  int iRefFilter = 1;
298  int iTestFilter = 0;
299 
300  if ( m_runPurity ) {
301  iRefFilter = 0;
302  iTestFilter = 1;
303  }
304 
305  Filter_Combined filterRef( m_filters[iRefFilter][0], &filter );
306  Filter_Combined filterTest( m_filters[iTestFilter][0], &filter );
307 
308 
309  TrigTrackSelector selectorTruth( &filter_truth );
310  TrigTrackSelector selectorRef( &filterRef );
311  m_selectorRef = &selectorRef;
312  TrigTrackSelector selectorTest( &filterTest );
313  m_selectorTest = &selectorTest;
314 
315  if ( xbeam!=0 || ybeam!=0 ) {
316  m_selectorRef->setBeamline( xbeam, ybeam );
317  }
318 
320 
321  // clear the ntuple TIDA::Event class
322  m_event->clear();
323 
325 
326  const xAOD::EventInfo* pEventInfo;
327 
328  unsigned run_number = 0;
329  unsigned long long event_number = 0;
330  unsigned lumi_block = 0;
331  unsigned bunch_crossing_id = 0;
332  unsigned time_stamp = 0;
333  double mu_val = 0;
334 
335  // std::cout << "\tloop() get EventInfo" << std::endl;
336 
337  if ( this->template retrieve(pEventInfo, "EventInfo").isFailure() ) {
338  m_provider->msg(MSG::WARNING) << "Failed to get EventInfo " << endmsg;
339  } else {
340 
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  }
348 
349  if(m_provider->msg().level() <= MSG::VERBOSE){
350  m_provider->msg(MSG::VERBOSE) << "run " << run_number
351  << "\tevent " << event_number
352  << "\tlb " << lumi_block << endmsg;
353  }
354 
355  // m_provider->msg(MSG::INFO) << "run " << run_number
356  // << "\tevent " << event_number
357  // << "\tlb " << lumi_block << endmsg;
358 
359  // std::cout << "\trun " << run_number << "\tevent " << event_number << "\tlb " << lumi_block << std::endl;
360 
361 
362  // clear the ntuple TIDA::Event class
363  m_event->clear();
364 
365  m_event->run_number(run_number);
366  m_event->event_number(event_number);
367  m_event->lumi_block(lumi_block);
368  m_event->time_stamp(time_stamp);
369  m_event->bunch_crossing_id(bunch_crossing_id);
370  m_event->mu(mu_val);
371 
374 
375  bool analyse = false;
376 
377  // Check HLTResult
378 
379  // std::cout << "\tloop() loop over trigger chains to determine whether to process this event ..." << std::endl;
380 
381  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
382 
383  const std::string& chainname = m_chainNames[ichain].head();
384 
385  if ( chainname == "" ) analyse = true;
386  else {
387 
388  //Only for trigger chains
389  if ( chainname.find("L2") == std::string::npos &&
390  chainname.find("EF") == std::string::npos &&
391  chainname.find("HLT") == std::string::npos ) continue;
392 
393  if ( m_provider->msg().level() <= MSG::DEBUG ) {
394  m_provider->msg(MSG::DEBUG) << "Chain " << chainname
395  << "\tpass " << (*m_tdt)->isPassed(chainname)
396  << "\tpres " << (*m_tdt)->getPrescale(chainname) << endmsg;
397  }
398 
399  // std::cout << "\tChain " << chainname << "\tpass " << (*m_tdt)->isPassed(chainname)
400  // << "\tpres " << (*m_tdt)->getPrescale(chainname) << std::endl;
401 
402  if ( (*(m_tdt))->isPassed(chainname) || (*(m_tdt))->getPrescale(chainname) ) analyse = true;
403 
404  }
405  }
406 
407 
408  // if ( (*m_tdt)->ExperimentalAndExpertMethods().isHLTTruncated() ) {
409  // m_provider->msg(MSG::WARNING) << "HLTResult truncated, skipping event" << endmsg;
410  // return;
411  // }
412 
413  if ( !this->m_keepAllEvents && !analyse ) {
414  // m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
415  if(m_provider->msg().level() <= MSG::VERBOSE) {
416  m_provider->msg(MSG::VERBOSE) << "No chains passed unprescaled - not processing this event" << endmsg;
417  }
418  // std::cout << "\tNo chains passed unprescaled - not processing this event" << std::endl;
419  return;
420  }
421 
422 
423 
425 
426  selectorTruth.clear();
427 
428 
429 
430  if(m_provider->msg().level() <= MSG::VERBOSE)
431  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
432 
433  const TrigInDetTrackTruthMap* truthMap = 0;
434 
435  if ( m_mcTruth ) {
436  if(m_provider->msg().level() <= MSG::VERBOSE ) m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
437 
438  if ( this->template retrieve(truthMap, "TrigInDetTrackTruthMap").isFailure()) {
439  if(m_provider->msg().level() <= MSG::VERBOSE)
440  m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap not found" << endmsg;
441  m_hasTruthMap = false;
442  }
443  else {
444  if(m_provider->msg().level() <= MSG::VERBOSE)
445  m_provider->msg(MSG::VERBOSE) << "TrigInDetTrackTruthMap found" << endmsg;
446  m_hasTruthMap = true;
447  }
448  }
449 
450 
452 
453  std::vector<TIDA::Vertex> vertices;
454  std::vector<TIDA::Vertex> vertices_rec;
455 
456  std::vector<double> refbeamspot;
457  std::vector<double> testbeamspot;
458 
460 
461  m_provider->msg(MSG::VERBOSE) << "fetching AOD Primary vertex container" << endmsg;
462 
463  if ( !this->select( vertices, "PrimaryVertices" ) ) {
464  m_provider->msg(MSG::VERBOSE) << "could not retrieve vertex collection " "PrimaryVertices" << std::endl;
465  }
466 
468 
469  if ( m_mcTruth ) {
470  m_event->addChain( "Truth" );
471  m_event->back().addRoi(TIDARoiDescriptor());
472  m_event->back().back().addTracks(selectorTruth.tracks());
473  }
474 
476 
477  if ( m_doOffline ) {
478  for ( unsigned i=0 ; i<vertices.size() ; i++ ) {
479  if(m_provider->msg().level() <= MSG::VERBOSE)
480  m_provider->msg(MSG::VERBOSE) << "vertex " << i << " " << vertices[i] << endmsg;
481  m_event->addVertex(vertices[i]);
482  }
483  }
484 
486 
487  // int Noff = 0;
488  std::vector<TIDA::Track*> offline_tracks;
489  std::vector<TIDA::Track*> electron_tracks;
490  std::vector<TIDA::Track*> muon_tracks;
491 
492  std::vector<TIDA::Track*> ref_tracks;
493  std::vector<TIDA::Track*> test_tracks;
494 
495  offline_tracks.clear();
496  electron_tracks.clear();
497  muon_tracks.clear();
498 
499  ref_tracks.clear();
500  test_tracks.clear();
501 
502  // offline track retrieval now done once for each chain rather than each roi
503  if ( m_provider->msg().level() <= MSG::VERBOSE )
504  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
505 
506  bool foundTruth = false;
507 
508  if ( !m_doOffline && m_mcTruth ) {
509 
510  filter_truth.setRoi( 0 ); // don't filter on RoI yet (or until needed)
511 
512  selectorTruth.clear();
513 
514  if ( m_provider->msg().level() <= MSG::VERBOSE )
515  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
516 
517  if ( m_provider->evtStore()->template contains<TruthParticleContainer>("INav4MomTruthEvent") ) {
518  //ESD
519  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
520  foundTruth = true;
521  }
522  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("SpclMC") ) {
524  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
525  foundTruth = true;
526  }
527  else if ( m_provider->evtStore()->template contains<xAOD::TruthParticleContainer>("TruthParticles") ) {
529  this->template selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "TruthParticles");
530  foundTruth = true;
531  }
532  else if ( m_provider->evtStore()->template contains<TruthParticleContainer>("") ) {
534  this->template selectTracks<TruthParticleContainer>( &selectorTruth, "");
535  foundTruth = true;
536  }
537  else
538  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
539  m_provider->msg(MSG::VERBOSE) << "Truth not found - none whatsoever!" << endmsg;
540  }
541  }
542 
543  if ( !m_doOffline && m_mcTruth && !foundTruth ) {
544 
545  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
546  m_provider->msg(MSG::VERBOSE) << "getting Truth" << endmsg;
547  }
548 
550 
551  const DataHandle<McEventCollection> mcevent;
552 
554 
555  std::string keys[4] = { "GEN_AOD", "TruthEvent", "", "G4Truth" };
556 
557  std::string key = "";
558 
559  bool foundcollection = false;
560 
561  for ( int ik=0 ; ik<4 ; ik++ ) {
562 
563  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
564  m_provider->msg(MSG::VERBOSE) << "Try McEventCollection: " << keys[ik] << endmsg;
565  }
566 
567  if ( !m_provider->evtStore()->template contains<McEventCollection>(keys[ik]) ) {
568  if( m_provider->msg().level() <= MSG::VERBOSE )
569  m_provider->msg(MSG::VERBOSE) << "No McEventCollection: " << keys[ik] << endmsg;
570  continue;
571  }
572 
573  if ( m_provider->msg().level() <= MSG::VERBOSE )
574  m_provider->msg(MSG::VERBOSE) << "evtStore()->retrieve( mcevent, " << keys[ik] << " )" << endmsg;
575 
576  if ( this->template retrieve( mcevent, keys[ik] ).isFailure() ) {
577  if ( m_provider->msg().level() <= MSG::VERBOSE )
578  m_provider->msg(MSG::VERBOSE) << "Failed to get McEventCollection: " << keys[ik] << endmsg;
579  }
580  else {
582  key = keys[ik];
583  if(m_provider->msg().level() <= MSG::VERBOSE)
584  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << endmsg;
585  foundcollection = true;
586  break;
587  }
588  }
589 
591  if ( !foundcollection ) {
592  if(m_provider->msg().level() <= MSG::VERBOSE)
593  m_provider->msg(MSG::WARNING) << "No MC Truth Collections of any sort, whatsoever!!!" << endmsg;
594 
595  // m_tree->Fill();
596  // return StatusCode::FAILURE;
597 
598  return;
599  }
600 
601  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
602  m_provider->msg(MSG::VERBOSE) << "Found McEventCollection: " << key << "\tNevents " << mcevent->size() << endmsg;
603  }
604 
605  McEventCollection::const_iterator evitr = mcevent->begin();
606  McEventCollection::const_iterator evend = mcevent->end();
607 
608  unsigned ie = 0;
609  unsigned ip = 0;
610 
611  unsigned ie_ip = 0;
612 
613  while ( evitr!=evend ) {
614 
615  int _ip = 0;
616 
617  int pid = HepMC::signal_process_id((*evitr));
618 
619  //The logic should be clarified here
620  if ( pid!=0 ) {
621 
622  for (auto pitr: *(*evitr) ) {
623 
624  selectorTruth.selectTrack( pitr );
625 
626  ++_ip;
627 
628  }
629 
630  }
631  ++ie;
632  ++evitr;
633 
634  if ( _ip>0 ) {
636  // m_provider->msg(MSG::VERBOSE) << "Found " << ie << "\tpid " << pid << "\t with " << ip << " TruthParticles (GenParticles)" << endmsg;
637  ++ie_ip;
638  ip += _ip;
639  }
640  }
641 
642  if(m_provider->msg().level() <= MSG::VERBOSE){
643  m_provider->msg(MSG::VERBOSE) << "Found " << ip << " TruthParticles (GenParticles) in " << ie_ip << " GenEvents out of " << ie << endmsg;
644  m_provider->msg(MSG::VERBOSE) << "selected " << selectorTruth.size() << " TruthParticles (GenParticles)" << endmsg;
645  }
646 
647  if(selectorTruth.size() > 0) foundTruth = true;
648 
649  if ( !(ip>0) ) {
650  if (m_provider->msg().level() <= MSG::VERBOSE) m_provider->msg(MSG::WARNING) << "NO TRUTH PARTICLES - returning" << endmsg;
651  return;
652  }
653 
654  }
655 
656  // m_provider->msg(MSG::VERBOSE) << " Offline tracks " << endmsg;
657 
658  if ( m_doOffline ) {
659 
660  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>("InDetTrackParticles") ) {
661  this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorRef, "InDetTrackParticles" );
662  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( "InDetTrackParticles" );
663  }
664  else if (m_provider->evtStore()->template contains<Rec::TrackParticleContainer>("TrackParticleCandidate") ) {
665  this->template selectTracks<Rec::TrackParticleContainer>( m_selectorRef, "TrackParticleCandidate" );
666  }
667  else if ( m_provider->msg().level() <= MSG::WARNING ) {
668  m_provider->msg(MSG::WARNING) << " Offline tracks not found " << endmsg;
669  }
670 
671  }
672 
673 
674  // std::cout << "\tloop() loop over chains proper ..." << std::endl;
675 
677  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
678 
680 
681  // std::string& chainname = chains[ichain];
682  const std::string& chainname = m_chainNames[ichain].head();
683  const std::string& key = m_chainNames[ichain].tail();
684  const std::string& vtx_name = m_chainNames[ichain].vtx();
685  //Not used left just in case
686  //const std::string& roi_name = m_chainNames[ichain].roi();
687  //const std::string& te_name = m_chainNames[ichain].element();
688  m_pTthreshold = 0;
689 
690  if ( m_chainNames[ichain].postcount() ) {
691  std::string ptvalue = m_chainNames[ichain].postvalue("pt");
692  if ( ptvalue!="" ) m_pTthreshold = std::stod(ptvalue);
693  }
694 
695 
696  unsigned _decisiontype = TrigDefs::Physics;
697  unsigned decisiontype;
698 
699  if ( this->requireDecision() ) _decisiontype = TrigDefs::requireDecision;
700 
701 
702  if ( m_chainNames[ichain].passed() ) decisiontype = _decisiontype;
703  else decisiontype = TrigDefs::alsoDeactivateTEs;
704 
706  // if ( decisiontype==TrigDefs::requireDecision ) std::cout << "\tSUTT TrigDefs::requireDecision " << decisiontype << std::endl;
707  // if ( decisiontype==TrigDefs::Physics ) std::cout << "\tSUTT TrigDefs::Physics " << decisiontype << std::endl;
708 
709  if ( chainname!="" && m_provider->msg().level() <= MSG::VERBOSE ) {
710 
711  m_provider->msg(MSG::VERBOSE) << "status for chain " << chainname
712  << "\tpass " << (*m_tdt)->isPassed(chainname)
713  << "\tprescale " << (*m_tdt)->getPrescale(chainname) << endmsg;
714 
715  m_provider->msg(MSG::VERBOSE) << "fetching features for chain " << chainname << endmsg;
716 
717  m_provider->msg(MSG::VERBOSE) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << endmsg;
718  }
719 
721  // std::cout << "\tstatus for chain " << chainname
722  // << "\tpass " << (*m_tdt)->isPassed( chainname )
723  // << "\tpassdt " << (*m_tdt)->isPassed( chainname, decisiontype )
724  // << "\tprescale " << (*m_tdt)->getPrescale( chainname ) << std::endl;
725 
726 
727  // m_provider->msg(MSG::INFO) << chainname << "\tpassed: " << (*m_tdt)->isPassed( chainname ) << "\t" << m_chainNames[ichain] << "\trun " << run_number << "\tevent " << event_number << endmsg;
728 
729 
730  if ( chainname!="" && !this->m_keepAllEvents && !(*m_tdt)->isPassed( chainname, decisiontype ) ) continue;
731 
732 
735  // Trig::FeatureContainer f = (*m_tdt)->features( chainname, TrigDefs::alsoDeactivateTEs);
736 
739 
740  // tag and probe analysis processes multiple chains passed in the tag and probe tool at once so loop over vector of chains
741  std::vector<std::string> chainNames ;
742 
743  if ( !TnP_flag ) {
744  chainNames.push_back(m_chainNames[ichain].raw()) ;
745  }
746  else {
747  chainNames.push_back(m_TnP_tool->tag()) ;
748  chainNames.push_back(m_TnP_tool->probe()) ;
749  }
750 
751  // loop over new chainNames vector but doing the same stuff
752  for ( unsigned i = 0 ; i < chainNames.size() ; ++i ) {
753 
754  ChainString chainConfig = chainNames[i] ;
755  std::string chainName = chainConfig.head();
756 
757  m_event->addChain( chainNames[i] );
758 
759  TIDA::Chain& chain = m_event->back();
760 
761  if ( chainName == "" ) {
762 
764 
765  m_selectorTest->clear();
766 
768 
769  TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor(true);
770 
771  chain.addRoi( *roiInfo );
772 
773  if ( m_provider->evtStore()->template contains<xAOD::TrackParticleContainer>(key) ) {
774  this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, key );
775  refbeamspot = this->template getBeamspot<xAOD::TrackParticleContainer>( key );
776  }
777 
778  const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
779 
780  chain.back().addTracks(testtracks);
781 
782  if ( vtx_name!="" ) {
783 
785 
786  m_provider->msg(MSG::VERBOSE) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
787 
788  std::vector<TIDA::Vertex> tidavertices;
789 
790  if ( this->select( tidavertices, vtx_name ) ) chain.back().addVertices( tidavertices );
791  }
792 
793 
794  if ( roiInfo ) delete roiInfo;
795 
796  }
797  else {
798 
800 
801  //std::string roi_key = m_chainNames[ichain].roi();
802 
803  std::string roi_key = chainConfig.roi();
804 
805  unsigned feature_type =TrigDefs::lastFeatureOfType;
806 
807  if ( roi_key!="" ) feature_type= TrigDefs::allFeaturesOfType;
808 
810 
811  int leg = -1;
812 
813  if ( chainConfig.element()!="" ) {
814  leg = std::atoi(chainConfig.element().c_str());
815  }
816 
817  std::vector< TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection> > rois =
818  (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,
819  decisiontype,
820  roi_key,
821  feature_type,
822  "roi",
823  leg ) );
824 
825  // const unsigned int featureCollectionMode = const std::string& navElementLinkKey = "roi") const;
826 
827  int iroi = 0;
828 
829  for ( const TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>& roi_info : rois ) {
830 
831  iroi++;
832 
836 
837  if ( roi_key=="SuperRoi" && iroi>1 ) continue;
838 
839  // std::cout << "\troi: get link " << roi_key << " ..." << std::endl;
840 
841  const ElementLink<TrigRoiDescriptorCollection> roi_link = roi_info.link;
842 
844  if ( roi_key!="" && roi_link.dataID()!=roi_key ) continue;
845 
846  const TrigRoiDescriptor* const* roiptr = roi_link.cptr();
847 
848  if ( roiptr == 0 ) {
849  continue;
850  }
851 
852  // std::cout << "\troi: link deref ..." << *roiptr << std::endl;
853 
854  if (m_provider->msg().level() <= MSG::VERBOSE) {
855  m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainname << " " << **roiptr << endmsg;
856  }
857 
858  TIDARoiDescriptor* roiInfo = new TIDARoiDescriptor( TIDARoiDescriptorBuilder(**roiptr) );
859 
860  // if ( dbg ) std::cout << "\troi " << iroi << " " << *roiInfo << std::endl;
861 
863 
864  m_selectorTest->clear();
865 
866  if ( this->template selectTracks<xAOD::TrackParticleContainer>( m_selectorTest, roi_link, key ) ) { }
867 
868  // beamspot stuff not needed for xAOD::TrackParticles
869 
871 
872  chain.addRoi( *roiInfo );
873 
875 
876  const std::vector<TIDA::Track*>& testtracks = m_selectorTest->tracks();
877 
878  chain.back().addTracks(testtracks);
879 
880 
882 
883  if ( vtx_name!="" ) {
884 
885  std::vector<TIDA::Vertex> tidavertices;
886 
887  this->select( tidavertices, roi_link, vtx_name );
888 
889  chain.back().addVertices( tidavertices );
890 
891  }
892 
893 
894 #if 0
895  if ( dbg ) {
896  std::cout << "\tTIDA analysis for chain: " << chainname << "\t key: " << key << "\t" << **roiptr << std::endl;
897  std::cout << "\tcollections: " << chain.back() << std::endl;
898  }
899 #endif
900 
901  if ( roiInfo ) delete roiInfo;
902 
903  }
904 
905 
906  }
907 
908  } // end of loop chainNames vector loop
909 
910 
911  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
912  m_provider->msg(MSG::VERBOSE) << "event: " << *m_event << endmsg;
913  }
914 
915  }
916 
917  // close previous loop over chains and open new one
918 
919  for ( unsigned ichain=0 ; ichain<m_event->size() ; ichain++ ) {
920 
921  TIDA::Chain& chain = (*m_event)[ichain];
922  ChainString chainConfig(chain.name());
923  const std::string& vtx_name = chainConfig.vtx();
924 
925  // skip tag chains to avoid performing standard analysis on them (done for tnp at the same time as probes)
926  if ( TnP_flag && chainConfig.extra().find("_tag")!=std::string::npos ) continue ;
927 
928  std::vector<TIDA::Roi*> rois ;
929 
930  if (TnP_flag) {
931  rois = m_TnP_tool->GetRois( m_event->chains(), m_selectorRef, &filterRef, m_invmass, m_invmass_obj );
932  // needs to be done AFTER retrieving offline tracks as m_selectorRef passed as arguement, hence restructuring
933  }
934  else {
935  rois.reserve( chain.size() );
936  for ( size_t ir=0 ; ir<chain.size() ; ir++ ) {
937  rois.push_back( &(chain.rois()[ir]) );
938  }
939  }
940 
941  // now loop over the rois (again)
942 
943  for ( unsigned iroi=0 ; iroi<rois.size() ; iroi++ ) {
944 
945  if ( this->filterOnRoi() ) {
946  filterRef.setRoi( &(rois.at(iroi)->roi() ) );
947  filterRef.containtracks( m_containTracks );
948  }
949  else filterRef.setRoi( 0 );
950 
951  test_tracks.clear();
952 
953  // this block is before the track retrieval in the original, is it working the same here?
954 
968 
969  if ( m_provider->msg().level() <= MSG::VERBOSE )
970  m_provider->msg(MSG::VERBOSE) << "MC Truth flag " << m_mcTruth << endmsg;
971 
972  if ( !m_doOffline && m_mcTruth ) {
973  if ( this->filterOnRoi() ) filter_truth.setRoi( &(rois.at(iroi)->roi() ) );
974  ref_tracks = m_selectorRef->tracks(&filter_truth);
975  }
976  else { // ie. if ( m_doOffline )
977  ref_tracks = m_selectorRef->tracks(&filterRef) ;
978  }
979 
980  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
981  m_provider->msg(MSG::VERBOSE) << "ref tracks.size() " << m_selectorRef->tracks().size() << endmsg;
982  for ( int ii=m_selectorRef->tracks().size() ; ii-- ; ) {
983  m_provider->msg(MSG::VERBOSE) << " ref track " << ii << " " << *m_selectorRef->tracks()[ii] << endmsg;
984  }
985  }
986 
987  test_tracks.clear();
988 
989 
990  for ( unsigned itrk=0 ; itrk<rois.at(iroi)->tracks().size() ; itrk++ ) {
991  test_tracks.push_back(&(rois.at(iroi)->tracks().at(itrk)));
992  }
993 
994  // std::cout << "sutt track multiplicities: offline " << offline_tracks.size() << "\ttest " << test_tracks.size() << std::endl;
995 
996  _analysis->setvertices( vertices.size() );
997 
998  if ( refbeamspot.size()>0 ) _analysis->setBeamRef( refbeamspot );
999  if ( testbeamspot.size()>0 ) _analysis->setBeamTest( testbeamspot );
1000 
1003 
1004  if ( m_runPurity ) {
1005 
1006  if ( this->getUseHighestPT() ) HighestPTOnly( test_tracks );
1007 
1008  if ( m_pTthreshold>0 ) FilterPT( test_tracks, m_pTthreshold );
1009 
1011  m_NRois++;
1012  m_NRefTracks += test_tracks.size();
1013  m_NTestTracks += ref_tracks.size();
1014 
1015 
1017  m_associator->match( test_tracks, ref_tracks );
1018 
1019  _analysis->execute( test_tracks, ref_tracks, m_associator );
1020 
1021  }
1022  else {
1023 
1025  if ( this->getUseHighestPT() ) HighestPTOnly( ref_tracks );
1026 
1028 
1029  if ( m_pTthreshold>0 ) FilterPT( ref_tracks, m_pTthreshold );
1030 
1032  m_NRois++;
1033  m_NRefTracks += ref_tracks.size();
1034  m_NTestTracks += test_tracks.size();
1035 
1037  m_associator->match( ref_tracks, test_tracks );
1038 
1039  _analysis->setroi( &rois.at(iroi)->roi() );
1040  _analysis->execute( ref_tracks, test_tracks, m_associator );
1041 
1042  if ( vtx_name!="" ) {
1044  std::vector<TIDA::Vertex> vr = rois.at(iroi)->vertices();
1045  std::vector<TIDA::Vertex*> vtx_rec;
1046  for ( unsigned iv=0 ; iv<vr.size() ; iv++ ) vtx_rec.push_back( &vr[iv] );
1047 
1048  std::vector<TIDA::Vertex*> vtx;
1049  if ( this->getVtxIndex()<0 ) {
1050  for ( unsigned iv=0 ; iv<vertices.size() ; iv++ ) vtx.push_back( &vertices[iv] );
1051  }
1052  else {
1053  if ( vertices.size()>unsigned(this->getVtxIndex()) ) vtx.push_back( &vertices[this->getVtxIndex()] );
1054  }
1055 
1056  _analysis->execute_vtx( vtx, vtx_rec, m_event );
1057  }
1058 
1059  }
1060 
1061  if ( _analysis->debug() ) {
1062  m_provider->msg(MSG::INFO) << "Missing track for " << m_chainNames[ichain]
1063  << "\trun " << run_number
1064  << "\tevent " << event_number
1065  << "\tlb " << lumi_block << endmsg;
1066  }
1067 
1068  }
1069 
1070  }
1071 
1072  if ( m_provider->msg().level() <= MSG::VERBOSE ) {
1073  m_provider->msg(MSG::VERBOSE) << "\n\nEvent " << *m_event << endmsg;
1074  }
1075  }

◆ mcTruth()

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

Definition at line 259 of file T_AnalysisConfig.h.

259 { return m_mcTruth; }

◆ monTool()

template<typename T , typename A = Analysis_Tier0>
ToolHandle<GenericMonitoringTool>* T_AnalysisConfigMT_Tier0< T, A >::monTool ( )
inlineprotected

Definition at line 1114 of file T_AnalysisConfigMT_Tier0.h.

1114 { return m_monTool; }

◆ name()

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

Definition at line 233 of file T_AnalysisConfig.h.

233 {return m_analysisInstanceName;}

◆ processElectrons()

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

select offline electrons

Definition at line 701 of file T_AnalysisConfig.h.

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

◆ processMuons()

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

select offlinqe muons

Definition at line 787 of file T_AnalysisConfig.h.

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

◆ processTaus()

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

select offline taus

Definition at line 844 of file T_AnalysisConfig.h.

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

◆ referenceChains()

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

Definition at line 242 of file T_AnalysisConfig.h.

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

◆ releaseData() [1/2]

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

Definition at line 271 of file T_AnalysisConfig.h.

271 { return m_releaseData; }

◆ releaseData() [2/2]

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

Definition at line 272 of file T_AnalysisConfig.h.

272 { m_releaseData = s; }

◆ requireDecision()

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

Definition at line 286 of file T_AnalysisConfig.h.

286 { return m_requireDecision; }

◆ retrieve()

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

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

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

Definition at line 571 of file T_AnalysisConfig.h.

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

◆ select() [1/3]

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

Definition at line 369 of file T_AnalysisConfig.h.

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

◆ select() [2/3]

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

Definition at line 392 of file T_AnalysisConfig.h.

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

◆ select() [3/3]

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

variances

quality

Definition at line 340 of file T_AnalysisConfig.h.

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

◆ selectionChains()

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

Definition at line 249 of file T_AnalysisConfig.h.

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

◆ selectTracks() [1/4]

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

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

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

Definition at line 439 of file T_AnalysisConfig.h.

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

◆ selectTracks() [2/4]

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

commented code intentionally left for development purposes ...

Definition at line 589 of file T_AnalysisConfig.h.

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

◆ selectTracks() [3/4]

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

lagacy run 2 access

Definition at line 485 of file T_AnalysisConfig.h.

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

◆ selectTracks() [4/4]

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

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

get the correspondiong TE

get all the named collections attached to the TE

now got the collectionVector, can navigate through this

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

useful for debug

Definition at line 521 of file T_AnalysisConfig.h.

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

◆ selectTracksNotEmpty()

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

Definition at line 606 of file T_AnalysisConfig.h.

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

◆ set_monTool()

template<typename T , typename A = Analysis_Tier0>
void T_AnalysisConfigMT_Tier0< T, A >::set_monTool ( ToolHandle< GenericMonitoringTool > *  m)
inlineprotected

Definition at line 1112 of file T_AnalysisConfigMT_Tier0.h.

1112 { m_monTool=m; }

◆ setBeamX()

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

Definition at line 261 of file T_AnalysisConfig.h.

261 { m_beamX=d; }

◆ setBeamY()

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

Definition at line 262 of file T_AnalysisConfig.h.

262 { m_beamY=d; }

◆ setBeamZ()

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

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamZ=d; }

◆ setFilterOnRoi()

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

Definition at line 283 of file T_AnalysisConfig.h.

283 { return m_filterOnRoi=b; }

◆ setGenericFlag()

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

Definition at line 269 of file T_AnalysisConfig.h.

269 { m_genericFlag=b; }

◆ setMCTruth()

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

Definition at line 258 of file T_AnalysisConfig.h.

258 { m_mcTruth=b; }

◆ setRequireDecision()

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

Definition at line 285 of file T_AnalysisConfig.h.

285 { m_requireDecision=b; }

◆ setRunPurity()

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

Definition at line 164 of file T_AnalysisConfigMT_Tier0.h.

164 { m_runPurity=b; }

◆ setShifter()

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

Definition at line 166 of file T_AnalysisConfigMT_Tier0.h.

166 { m_shifter=b; }

◆ setUseHighestPT()

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

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_useHighestPT=b; }

◆ setVtxIndex()

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

Definition at line 279 of file T_AnalysisConfig.h.

279 { m_vtxIndex=i; }

◆ testChains()

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

Definition at line 235 of file T_AnalysisConfig.h.

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

◆ useBeamCondSvc()

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

Definition at line 168 of file T_AnalysisConfigMT_Tier0.h.

168 { m_useBeamCondSvc = b; }

Member Data Documentation

◆ _analysis

template<typename T , typename A = Analysis_Tier0>
A* T_AnalysisConfigMT_Tier0< T, A >::_analysis

Definition at line 174 of file T_AnalysisConfigMT_Tier0.h.

◆ m_analyses

template<typename T , typename A = Analysis_Tier0>
std::vector<A*> T_AnalysisConfigMT_Tier0< T, A >::m_analyses
protected

Definition at line 1123 of file T_AnalysisConfigMT_Tier0.h.

◆ m_analysis

TrackAnalysis* T_AnalysisConfig< T >::m_analysis
protectedinherited

Definition at line 984 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

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

Definition at line 963 of file T_AnalysisConfig.h.

◆ m_associator

TrackAssociator* T_AnalysisConfig< T >::m_associator
protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_beamX

double T_AnalysisConfig< T >::m_beamX
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamY

double T_AnalysisConfig< T >::m_beamY
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamZ

double T_AnalysisConfig< T >::m_beamZ
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_chainNames

template<typename T , typename A = Analysis_Tier0>
std::vector<ChainString> T_AnalysisConfigMT_Tier0< T, A >::m_chainNames
protected

Definition at line 1122 of file T_AnalysisConfigMT_Tier0.h.

◆ m_containTracks

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_containTracks
protected

Definition at line 1150 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doBjets

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doBjets
protected

Definition at line 1130 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doElectrons

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doElectrons
protected

Definition at line 1128 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doMuons

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doMuons
protected

Definition at line 1127 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doOffline

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doOffline
protected

Definition at line 1126 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doTaus

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doTaus
protected

Definition at line 1129 of file T_AnalysisConfigMT_Tier0.h.

◆ m_doTauThreeProng

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_doTauThreeProng
protected

Definition at line 1132 of file T_AnalysisConfigMT_Tier0.h.

◆ m_event

template<typename T , typename A = Analysis_Tier0>
TIDA::Event* T_AnalysisConfigMT_Tier0< T, A >::m_event
protected

Definition at line 1120 of file T_AnalysisConfigMT_Tier0.h.

◆ m_filterOnRoi

bool T_AnalysisConfig< T >::m_filterOnRoi
protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

◆ m_filters

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

Definition at line 977 of file T_AnalysisConfig.h.

◆ m_first

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_first
protected

Definition at line 1148 of file T_AnalysisConfigMT_Tier0.h.

◆ m_genericFlag

int T_AnalysisConfig< T >::m_genericFlag
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_hasTruthMap

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_hasTruthMap
protected

Definition at line 1131 of file T_AnalysisConfigMT_Tier0.h.

◆ m_invmass

template<typename T , typename A = Analysis_Tier0>
TH1F* T_AnalysisConfigMT_Tier0< T, A >::m_invmass
protected

Definition at line 1154 of file T_AnalysisConfigMT_Tier0.h.

◆ m_invmass_obj

template<typename T , typename A = Analysis_Tier0>
TH1F* T_AnalysisConfigMT_Tier0< T, A >::m_invmass_obj
protected

Definition at line 1155 of file T_AnalysisConfigMT_Tier0.h.

◆ m_keepAllEvents

bool T_AnalysisConfig< T >::m_keepAllEvents
protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_keys

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

Definition at line 968 of file T_AnalysisConfig.h.

◆ m_mcTruth

bool T_AnalysisConfig< T >::m_mcTruth
protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

◆ m_monTool

template<typename T , typename A = Analysis_Tier0>
ToolHandle<GenericMonitoringTool>* T_AnalysisConfigMT_Tier0< T, A >::m_monTool
protected

Definition at line 1157 of file T_AnalysisConfigMT_Tier0.h.

◆ m_NRefTracks

template<typename T , typename A = Analysis_Tier0>
int T_AnalysisConfigMT_Tier0< T, A >::m_NRefTracks
protected

Definition at line 1139 of file T_AnalysisConfigMT_Tier0.h.

◆ m_NRois

template<typename T , typename A = Analysis_Tier0>
int T_AnalysisConfigMT_Tier0< T, A >::m_NRois
protected

output stats

Definition at line 1138 of file T_AnalysisConfigMT_Tier0.h.

◆ m_NTestTracks

template<typename T , typename A = Analysis_Tier0>
int T_AnalysisConfigMT_Tier0< T, A >::m_NTestTracks
protected

Definition at line 1140 of file T_AnalysisConfigMT_Tier0.h.

◆ m_outputFileName

template<typename T , typename A = Analysis_Tier0>
std::string T_AnalysisConfigMT_Tier0< T, A >::m_outputFileName
protected

Definition at line 1135 of file T_AnalysisConfigMT_Tier0.h.

◆ m_provider

T * T_AnalysisConfig< T >::m_provider
protectedinherited

Definition at line 955 of file T_AnalysisConfig.h.

◆ m_pTthreshold

template<typename T , typename A = Analysis_Tier0>
double T_AnalysisConfigMT_Tier0< T, A >::m_pTthreshold
protected

Definition at line 1146 of file T_AnalysisConfigMT_Tier0.h.

◆ m_refChainKey

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

Definition at line 971 of file T_AnalysisConfig.h.

◆ m_refChainName

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

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_releaseData

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

Definition at line 991 of file T_AnalysisConfig.h.

◆ m_requireDecision

bool T_AnalysisConfig< T >::m_requireDecision
protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

◆ m_runPurity

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_runPurity
protected

Definition at line 1142 of file T_AnalysisConfigMT_Tier0.h.

◆ m_selectorRef

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorRef
protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_selectorSel

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorSel
protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorTest

TrigTrackSelector* T_AnalysisConfig< T >::m_selectorTest
protectedinherited

Definition at line 980 of file T_AnalysisConfig.h.

◆ m_shifter

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_shifter
protected

Definition at line 1144 of file T_AnalysisConfigMT_Tier0.h.

◆ m_tauEtCutOffline

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_tauEtCutOffline
protected

Definition at line 1133 of file T_AnalysisConfigMT_Tier0.h.

◆ m_tdt

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

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_testChainKey

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

Definition at line 974 of file T_AnalysisConfig.h.

◆ m_testChainName

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

Definition at line 973 of file T_AnalysisConfig.h.

◆ m_testType

template<typename T , typename A = Analysis_Tier0>
std::string T_AnalysisConfigMT_Tier0< T, A >::m_testType
protected

Definition at line 1124 of file T_AnalysisConfigMT_Tier0.h.

◆ m_TnP_tool

template<typename T , typename A = Analysis_Tier0>
TagNProbe* T_AnalysisConfigMT_Tier0< T, A >::m_TnP_tool
protected

Definition at line 1152 of file T_AnalysisConfigMT_Tier0.h.

◆ m_types

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

Definition at line 967 of file T_AnalysisConfig.h.

◆ m_useBeamCondSvc

template<typename T , typename A = Analysis_Tier0>
bool T_AnalysisConfigMT_Tier0< T, A >::m_useBeamCondSvc
protected

Definition at line 1118 of file T_AnalysisConfigMT_Tier0.h.

◆ m_useHighestPT

bool T_AnalysisConfig< T >::m_useHighestPT
protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_vtxIndex

int T_AnalysisConfig< T >::m_vtxIndex
protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

The documentation for this class was generated from the following file:
T_AnalysisConfigMT_Tier0::m_containTracks
bool m_containTracks
Definition: T_AnalysisConfigMT_Tier0.h:1150
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
T_AnalysisConfig< T >::m_selectorRef
TrigTrackSelector * m_selectorRef
Definition: T_AnalysisConfig.h:979
Trk::y
@ y
Definition: ParamDefs.h:62
TrackAnalysis::initialise
virtual void initialise()=0
standard operation interface
Trig::FeatureRequestDescriptor
Definition: FeatureRequestDescriptor.h:37
T_AnalysisConfig< T >::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:967
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
T_AnalysisConfig< T >::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:986
Trig::Feature
Definition: Feature.h:112
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TIDA::isGoodOffline
bool isGoodOffline(const Analysis::Electron &elec)
Definition: OfflineObjectSelection.cxx:122
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
T_AnalysisConfig< T >::m_filterOnRoi
bool m_filterOnRoi
Definition: T_AnalysisConfig.h:999
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
T_AnalysisConfigMT_Tier0::m_doTaus
bool m_doTaus
Definition: T_AnalysisConfigMT_Tier0.h:1129
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:63
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
T_AnalysisConfig< T >::m_provider
T * m_provider
Definition: T_AnalysisConfig.h:955
TrigTrackSelector::clear
virtual void clear() override
Definition: TrigTrackSelector.h:102
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
T_AnalysisConfigMT_Tier0::m_NTestTracks
int m_NTestTracks
Definition: T_AnalysisConfigMT_Tier0.h:1140
TrackAnalysis::finalise
virtual void finalise()=0
TIDA::Roi::addTracks
void addTracks(const std::vector< TIDA::Track > &tracks)
accessors for the track vector
Definition: TIDARoi.h:46
T_AnalysisConfig< T >::m_tdt
ToolHandle< Trig::TrigDecisionTool > * m_tdt
Definition: T_AnalysisConfig.h:957
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition: DataVector.h:837
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
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:513
T_AnalysisConfigMT_Tier0::m_runPurity
bool m_runPurity
Definition: T_AnalysisConfigMT_Tier0.h:1142
Filter_etaPT
Definition: Filter_etaPT.h:27
TIDA::Event::size
unsigned size() const
vertex multiplicity ?
Definition: TIDAEvent.h:64
ChainString::head
std::string head() const
Definition: ChainString.h:33
JiveXML::Event
struct Event_t Event
Definition: ONCRPCServer.h:65
T_AnalysisConfigMT_Tier0::m_first
bool m_first
Definition: T_AnalysisConfigMT_Tier0.h:1148
T_AnalysisConfig< T >::analysis
const TrackAnalysis * analysis() const
Definition: T_AnalysisConfig.h:256
T_AnalysisConfigMT_Tier0::m_pTthreshold
double m_pTthreshold
Definition: T_AnalysisConfigMT_Tier0.h:1146
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:121
TIDARoiDescriptor
Describes the Region of Ineterest geometry It has basically 8 parameters.
Definition: TIDARoiDescriptor.h:42
T_AnalysisConfigMT_Tier0::m_NRois
int m_NRois
output stats
Definition: T_AnalysisConfigMT_Tier0.h:1138
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
T_AnalysisConfigMT_Tier0::m_hasTruthMap
bool m_hasTruthMap
Definition: T_AnalysisConfigMT_Tier0.h:1131
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
TrigTrackSelector
L2 tracks.
Definition: TrigTrackSelector.h:58
T_AnalysisConfigMT_Tier0::m_doElectrons
bool m_doElectrons
Definition: T_AnalysisConfigMT_Tier0.h:1128
T_AnalysisConfigMT_Tier0::m_TnP_tool
TagNProbe * m_TnP_tool
Definition: T_AnalysisConfigMT_Tier0.h:1152
T_AnalysisConfig< T >::getUseHighestPT
bool getUseHighestPT() const
Definition: T_AnalysisConfig.h:277
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:214
TIDA::Event::lumi_block
void lumi_block(unsigned lb)
Definition: TIDAEvent.h:44
ChainString::roi
std::string roi() const
Definition: ChainString.h:35
Trig::Feature::empty
bool empty() const
test method to check if the object is truly there
Definition: Feature.h:196
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TIDA::Event::chains
const std::vector< TIDA::Chain > & chains() const
Definition: TIDAEvent.h:76
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
TIDA::Chain::addRoi
void addRoi(TIDA::Roi &roi)
add and roi by root dictionary class
Definition: TIDAChain.h:44
T_AnalysisConfig< T >::m_analysisInstanceName
std::string m_analysisInstanceName
Definition: T_AnalysisConfig.h:963
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
dbg
bool dbg
Definition: listroot.cxx:36
Container
storage of the time histories of all the cells
covarianceTool.filter
filter
Definition: covarianceTool.py:514
T_AnalysisConfig< T >::m_keys
std::vector< std::vector< std::string > > m_keys
Definition: T_AnalysisConfig.h:968
ChainString::extra
std::string extra() const
Definition: ChainString.h:38
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
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
TIDA::Event::addChain
void addChain(const std::string &chainname)
methods to add and access chains
Definition: TIDAEvent.h:67
TIDA::Event::time_stamp
void time_stamp(unsigned t)
Definition: TIDAEvent.h:45
T_AnalysisConfig< T >::m_beamY
double m_beamY
Definition: T_AnalysisConfig.h:988
T_AnalysisConfigMT_Tier0::m_invmass_obj
TH1F * m_invmass_obj
Definition: T_AnalysisConfigMT_Tier0.h:1155
T_AnalysisConfig< T >::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:988
TIDA::Event::back
TIDA::Chain & back()
get the last chain from the vector
Definition: TIDAEvent.h:89
lumiFormat.i
int i
Definition: lumiFormat.py:92
TIDA::Event::event_number
void event_number(unsigned long long e)
Definition: TIDAEvent.h:43
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TagNProbe::tag
void tag(const std::string &chainName)
getters and setters
Definition: TagNProbe.h:45
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
T_AnalysisConfig< T >::m_analysis
TrackAnalysis * m_analysis
Definition: T_AnalysisConfig.h:984
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
T_AnalysisConfig< T >::getVtxIndex
int getVtxIndex() const
Definition: T_AnalysisConfig.h:280
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfig< T >::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1001
TrigInDetTrackTruthMap
Definition: TrigInDetTrackTruthMap.h:38
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
T_AnalysisConfigMT_Tier0::m_monTool
ToolHandle< GenericMonitoringTool > * m_monTool
Definition: T_AnalysisConfigMT_Tier0.h:1157
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
compute_lumi.leg
leg
Definition: compute_lumi.py:95
HighestPTOnly
void HighestPTOnly(std::vector< T * > &tracks)
Definition: TIDATools.h:20
T_AnalysisConfig< T >::m_keepAllEvents
bool m_keepAllEvents
Definition: T_AnalysisConfig.h:993
T_AnalysisConfigMT_Tier0::m_event
TIDA::Event * m_event
Definition: T_AnalysisConfigMT_Tier0.h:1120
T_AnalysisConfigMT_Tier0::m_NRefTracks
int m_NRefTracks
Definition: T_AnalysisConfigMT_Tier0.h:1139
Analysis::MuonContainer
definition of StoreGate container holding a vector of Analysis::Muon
Definition: Reconstruction/MuonIdentification/muonEvent/muonEvent/MuonContainer.h:38
selection
std::string selection
Definition: fbtTestBasics.cxx:73
Filter_True
default simple filter which accepts all tracks
Definition: Filters.h:26
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
T_AnalysisConfigMT_Tier0::m_doMuons
bool m_doMuons
Definition: T_AnalysisConfigMT_Tier0.h:1127
TIDA::Vertex
Definition: TIDAVertex.h:23
T_AnalysisConfigMT_Tier0::m_useBeamCondSvc
bool m_useBeamCondSvc
Definition: T_AnalysisConfigMT_Tier0.h:1118
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
T_AnalysisConfigMT_Tier0::m_doBjets
bool m_doBjets
Definition: T_AnalysisConfigMT_Tier0.h:1130
ChainString::element
std::string element() const
Definition: ChainString.h:37
T_AnalysisConfig< T >::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:571
T_AnalysisConfig< T >::m_associator
TrackAssociator * m_associator
Definition: T_AnalysisConfig.h:983
TrackSelector::tracks
const std::vector< TIDA::Track * > & tracks() const
Definition: Trigger/TrigAnalysis/TrigInDetAnalysis/TrigInDetAnalysis/TrackSelector.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Filter_Combined
Definition: Filters.h:225
TIDA::Chain
Definition: TIDAChain.h:28
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:995
TIDA::Event::addVertex
void addVertex(const TIDA::Vertex &v)
Definition: TIDAEvent.h:71
TIDA::Event::clear
void clear()
clear the event
Definition: TIDAEvent.h:86
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TIDA::Event::mu
void mu(double m)
Definition: TIDAEvent.h:47
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.
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
python.PyAthena.v
v
Definition: PyAthena.py:157
T_AnalysisConfigMT_Tier0::_analysis
A * _analysis
Definition: T_AnalysisConfigMT_Tier0.h:174
TagNProbe::GetRois
std::vector< TIDA::Roi * > GetRois(std::vector< TIDA::Chain > &chains, const TrackSelector *selector, TrackFilter *filter, T *hmass, T *hmass_obj, TrigObjectMatcher *tom=0) const
Definition: TagNProbe.h:60
TrigCompositeUtils::LinkInfo
Helper to keep a Decision object, ElementLink and ActiveState (with respect to some requested ChainGr...
Definition: LinkInfo.h:28
TrackTrigObject
Definition: TrackTrigObject.h:21
python.selector.AtlRunQuerySelectorLhcOlc.selector
selector
Definition: AtlRunQuerySelectorLhcOlc.py:611
ChainString::vtx
std::string vtx() const
Definition: ChainString.h:36
T_AnalysisConfigMT_Tier0::m_chainNames
std::vector< ChainString > m_chainNames
Definition: T_AnalysisConfigMT_Tier0.h:1122
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:353
TriggerTest.rois
rois
Definition: TriggerTest.py:23
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< T >::m_vtxIndex
int m_vtxIndex
Definition: T_AnalysisConfig.h:997
xAOD::EgammaHelpers::getOriginalTrackParticle
const xAOD::TrackParticle * getOriginalTrackParticle(const xAOD::Electron *el)
Helper function for getting the "Original" Track Particle (i.e before GSF) via the electron.
Definition: ElectronxAODHelpers.cxx:11
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
T_AnalysisConfig< T >::filterOnRoi
bool filterOnRoi() const
Definition: T_AnalysisConfig.h:282
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
T_AnalysisConfigMT_Tier0::m_invmass
TH1F * m_invmass
Definition: T_AnalysisConfigMT_Tier0.h:1154
T_AnalysisConfig< T >::name
const std::string name() const
Definition: T_AnalysisConfig.h:233
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TIDA::Associator::match
virtual void match(const std::vector< T * > &s1, const std::vector< S * > &s2)=0
python.StandardJetMods.vr
vr
Definition: StandardJetMods.py:276
T_AnalysisConfig< T >::m_genericFlag
int m_genericFlag
Definition: T_AnalysisConfig.h:990
TIDA::Event::bunch_crossing_id
void bunch_crossing_id(unsigned b)
Definition: TIDAEvent.h:46
Trk::x
@ x
Definition: ParamDefs.h:61
T_AnalysisConfig< T >::m_beamZ
double m_beamZ
Definition: T_AnalysisConfig.h:988
T_AnalysisConfig< T >::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:977
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
TIDA::Event::run_number
void run_number(unsigned r)
accessors
Definition: TIDAEvent.h:42
T_AnalysisConfig< T >::m_selectorTest
TrigTrackSelector * m_selectorTest
Definition: T_AnalysisConfig.h:980
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
TagNProbe::probe
void probe(const std::string &chainName)
Definition: TagNProbe.h:46
Trig::Feature::cptr
const T * cptr() const
explicit conversion to object
Definition: Feature.h:171
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
T_AnalysisConfig< T >::requireDecision
bool requireDecision() const
Definition: T_AnalysisConfig.h:286
T_AnalysisConfigMT_Tier0::m_shifter
bool m_shifter
Definition: T_AnalysisConfigMT_Tier0.h:1144
T_AnalysisConfig< T >::select
bool select(std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
Definition: T_AnalysisConfig.h:340
T_AnalysisConfig< T >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig< T >::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:991
T_AnalysisConfigMT_Tier0::m_testType
std::string m_testType
Definition: T_AnalysisConfigMT_Tier0.h:1124
T_AnalysisConfig< T >::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:966
T_AnalysisConfigMT_Tier0::m_doOffline
bool m_doOffline
Definition: T_AnalysisConfigMT_Tier0.h:1126
Generated on Fri Jul 5 2024 21:58:49 for ATLAS Offline Software by   doxygen 1.8.18