ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
AnalysisConfigMT_Ntuple Class Reference

#include <AnalysisConfigMT_Ntuple.h>

Inheritance diagram for AnalysisConfigMT_Ntuple:
Collaboration diagram for AnalysisConfigMT_Ntuple:

Public Member Functions

 AnalysisConfigMT_Ntuple (const std::vector< std::string > &chainNames, std::string outputFileName="TrkNtuple.root", double tauEtCutOffline=0.0, int TruthPdgId=0, bool keepAllEvents_=false, int parentTruthId=0)
 
virtual ~AnalysisConfigMT_Ntuple ()
 
void set_fiducial_radius (double d)
 
void set_ptmin (double d)
 
size_t get_jets (Trig::FeatureContainer::combination_const_iterator citr, std::vector< TrackTrigObject > &objects, const std::string &key="")
 retrieve the jets from the Roi More...
 
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 (AthReentrantAlgorithm *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
 

Protected Member Functions

virtual void loop ()
 
virtual void book ()
 setup the analysis the analysis, retrieve the tools etc More...
 
virtual void finalize ()
 finalise the analysis - take ratios for efficiencies etc More...
 
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
 
TFile * m_File
 
TTree * m_Tree
 
TDirectory * m_Dir
 
std::vector< ChainString > m_chainNames
 
bool m_doOffline
 
bool m_doVertices
 
bool m_doMuons
 
bool m_doMuonsSP
 
std::vector< std::string > m_muonType
 
std::vector< bool > m_muonIsLRT
 
std::vector< std::string > m_electronType
 
std::vector< std::string > m_rawElectrons
 
std::vector< bool > m_electronIsLRT
 
std::vector< std::string > m_tauType
 
std::vector< std::string > m_tauProngs
 
std::vector< std::string > m_vertexType
 
bool m_doBjets
 
bool m_hasTruthMap
 
bool m_tauEtCutOffline
 
std::string m_outputFileName
 
int m_TruthPdgId
 
bool m_finalised
 
bool m_printInfo
 
int m_parentTruthPdgId
 
AthReentrantAlgorithm * 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
 

Private Member Functions

std::set< std::string > get_configured_chains ()
 

Private Attributes

double m_fiducial_radius
 
double m_ptmin
 

Detailed Description

Definition at line 24 of file AnalysisConfigMT_Ntuple.h.

Constructor & Destructor Documentation

◆ AnalysisConfigMT_Ntuple()

AnalysisConfigMT_Ntuple::AnalysisConfigMT_Ntuple ( const std::vector< std::string > &  chainNames,
std::string  outputFileName = "TrkNtuple.root",
double  tauEtCutOffline = 0.0,
int  TruthPdgId = 0,
bool  keepAllEvents_ = false,
int  parentTruthId = 0 
)
inline

Definition at line 35 of file AnalysisConfigMT_Ntuple.h.

36  :
37  AnalysisConfig_Ntuple( chainNames, outputFileName, tauEtCutOffline, TruthPdgId, keepAllEvents_ , parentTruthId),
38  m_fiducial_radius(47),
39  m_ptmin(1000)
40  { }

◆ ~AnalysisConfigMT_Ntuple()

virtual AnalysisConfigMT_Ntuple::~AnalysisConfigMT_Ntuple ( )
inlinevirtual

Definition at line 42 of file AnalysisConfigMT_Ntuple.h.

42 { }

Member Function Documentation

◆ addReferenceChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::addReferenceFilter ( TrackFilter *  filter)
inlineinherited

Definition at line 210 of file T_AnalysisConfig.h.

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

◆ addSelectionChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::addSelectionFilter ( TrackFilter *  filter)
inlineinherited

Definition at line 211 of file T_AnalysisConfig.h.

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

◆ addTestChain()

void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::analysis ( ) const
inlineinherited

Definition at line 256 of file T_AnalysisConfig.h.

256 {return m_analysis;}

◆ beamX()

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

Definition at line 264 of file T_AnalysisConfig.h.

264 { return m_beamX; }

◆ beamY()

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

Definition at line 265 of file T_AnalysisConfig.h.

265 { return m_beamY; }

◆ beamZ()

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

Definition at line 266 of file T_AnalysisConfig.h.

266 { return m_beamZ; }

◆ book()

void AnalysisConfig_Ntuple::book ( )
protectedvirtualinherited

setup the analysis the analysis, retrieve the tools etc

flag should be called m_fileIsNotOpen really, so is if m_fileIsNotOpen open file, if !m_fileIsNotOpen, then close file etc

save the current directory so we can return there after

create a brand new ntple

update the ntple from the file

go back to original directory

Reimplemented from T_AnalysisConfig< AthReentrantAlgorithm >.

Definition at line 188 of file AnalysisConfig_Ntuple.cxx.

188  {
189 
190  m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() name " << name() << endmsg;
191 
195  if ( !m_finalised ) {
196  m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() not booking " << name() << endmsg;
197  return;
198  }
199 
200 
201 
202  // get the TriggerDecisionTool
203 
204  if( m_tdt->retrieve().isFailure() ) {
205  m_provider->msg(MSG::FATAL) << " Unable to retrieve the TrigDecisionTool: Please check job options file" << endmsg;
206  // return StatusCode::FAILURE;
207  return;
208  }
209 
210  m_provider->msg(MSG::INFO) << "" << " Successfully retrived the TrigDecisionTool" << "" << endmsg;
211  m_provider->msg(MSG::INFO) << "" << " booking ntuple" << "" << endmsg;
212  m_provider->msg(MSG::INFO) << "" << " trying to create new ntple file" << "" << endmsg;
213 
215  TDirectory* dir = gDirectory;
216 
217  static std::atomic<bool> first_open = true;
218 
219  std::string outputFileName = m_outputFileName;
220 
221  if ( genericFlag() ) {
222  static std::atomic<int> file_index = 0;
223  std::string::size_type pos = outputFileName.find(".root");
224  if ( pos != std::string::npos ) outputFileName.erase(pos, outputFileName.size());
225  char file_label[64];
226  sprintf( file_label, "-%04d.root", file_index++ );
227  outputFileName += file_label;
228  }
229 
230  m_provider->msg(MSG::INFO) << "book() Writing to file " << outputFileName << endmsg;
231 
232  if ( first_open || genericFlag() ) {
234  m_File = new TFile( outputFileName.c_str(), "recreate");
235 
236  TTree* dataTree = new TTree("dataTree", "dataTree");
237  TString releaseData(m_releaseData.c_str());
238  dataTree->Branch( "ReleaseMetaData", "TString", &releaseData);
239  dataTree->Fill();
240  dataTree->Write("", TObject::kOverwrite);
241  delete dataTree;
242 
243 
244  m_Tree = new TTree("tree", "tree");
245  m_Tree->Branch( "TIDA::Event", "TIDA::Event", m_event, 6400, 1 );
246 
247 
248  }
249  else {
251  m_File = new TFile( outputFileName.c_str(), "update");
252  m_Tree = (TTree *)m_File->Get("tree");
253  m_Tree->SetBranchAddress( "TIDA::Event", &m_event );
254  }
255 
256  m_Dir = gDirectory;
257 
258  first_open = false;
259 
260 
261  m_provider->msg(MSG::DEBUG) << "change directory " << name() << " " << dir->GetName() << endmsg;
262 
263  // std::cout << "change directory " << name() << " " << dir->GetName() << std::endl;
265  dir->cd();
266 
267  // gDirectory->pwd();
268 
269  m_finalised = false; // flag we have an open file that is not yet finalised
270 
271  m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::book() exiting" << endmsg;
272 
273 }

◆ execute()

virtual void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::filterOnRoi ( ) const
inlineinherited

Definition at line 282 of file T_AnalysisConfig.h.

282 { return m_filterOnRoi; }

◆ finalize()

void AnalysisConfig_Ntuple::finalize ( )
protectedvirtualinherited

finalise the analysis - take ratios for efficiencies etc

NB: flag this round the other way for multiple files

flag that we have finalised and closed this file

Reimplemented from T_AnalysisConfig< AthReentrantAlgorithm >.

Definition at line 279 of file AnalysisConfig_Ntuple.cxx.

279  {
280 
281  // gDirectory->pwd();
282 
283 
285  if ( m_finalised ) {
286  m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::finalise() flagged, not finalising " << m_provider->name() << "\t" << m_Tree->GetEntries() << " entries" << endmsg;
287  return;
288  }
289 
290  m_provider->msg(MSG::INFO) << "AnalysisConfig_Ntuple::finalise() writing " << m_provider->name() << "\t" << m_Tree->GetEntries() << " entries" << endmsg;
291 
292  TDirectory* directory = gDirectory;
293 
294  // std::cout << "change directory " << name() << " " << m_Dir->GetName() << std::endl;
295 
296  m_provider->msg(MSG::DEBUG) << "change directory " << name() << " " << m_Dir->GetName() << endmsg;
297 
298 
299  m_Dir->cd();
300 
301  // gDirectory->pwd();
302 
303  if ( m_Tree ) m_Tree->Write("", TObject::kOverwrite);
304 
305  // m_File->Write();
306  if ( m_File ) m_File->Close();
307 
308 
309  m_finalised = true;
310 
311  // m_Tree "belongs" to the m_File so was (possibly) deleted on the m_File->Close();
312  // so don't delete it !
313  // delete m_Tree;
314  delete m_File;
315 
316  m_Tree = 0;
317  m_File = 0;
318 
319  // f.Write();
320  // f.Close();
321 
322  // std::cout << "change directory " << name() << " " << directory->GetName() << std::endl;
323 
324  directory->cd();
325 
326  // gDirectory->pwd();
327 
328 }

◆ genericFlag()

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

Definition at line 268 of file T_AnalysisConfig.h.

268 { return m_genericFlag; }

◆ get_configured_chains()

std::set< std::string > AnalysisConfigMT_Ntuple::get_configured_chains ( )
private

handle wildcard chain selection - but only the first time

get chain

get matching chains

replace wildcard with actual matching chains ...

if this has a cosmic chain, set the fiducial radius to be very large to allow the production vertex of the cosmic to be included

Definition at line 43 of file AnalysisConfigMT_Ntuple.cxx.

43  {
44  std::set<std::string> chains;
45  const std::vector<std::string> configuredChains = (*m_tdt)->getListOfTriggers("L2_.*, EF_.*, HLT_.*");
46 
47  if (m_provider->msg().level() <= MSG::VERBOSE) {
48  m_provider->msg(MSG::VERBOSE) << "" << configuredChains.size() << " Configured Chains" << "" << endmsg;
49  }
50 
51  for ( unsigned i=0 ; i<configuredChains.size() ; i++ ) {
52  if (m_provider->msg().level() <= MSG::VERBOSE) {
53  m_provider->msg(MSG::VERBOSE) << "" << "Chain " << configuredChains[i] << " (ACN)" << endmsg;
54  }
55  chains.insert( configuredChains[i] );
56  }
57 
58  std::vector<ChainString> chainNames;
59  std::vector<ChainString>::iterator chainitr = m_chainNames.begin();
60 
62  while ( chainitr!=m_chainNames.end() ) {
63 
65  ChainString& chainName = (*chainitr);
66 
68 
69  std::vector<std::string> selectChains;
70  selectChains.clear();
71  if ( chainitr->head()=="" ) selectChains.push_back("");
72  else selectChains = (*m_tdt)->getListOfTriggers( chainName.head() );
73 
74  for ( unsigned iselected=0 ; iselected<selectChains.size() ; iselected++ ) {
75 
76  selectChains[iselected] = chainName.subs( selectChains[iselected] );
77 
79  chainNames.push_back( ChainString(selectChains[iselected]) );
80 
81  m_provider->msg(MSG::INFO) << "" << "Matching chain " << selectChains[iselected] << "" << endmsg;
82 
85  if ( selectChains[iselected].find("cosmic")!=std::string::npos ) m_fiducial_radius = 1e10;
86 
87  }
88 
89  ++chainitr;
90  }
91 
92  m_chainNames = chainNames;
93  return chains;
94 }

◆ get_jets()

size_t AnalysisConfig_Ntuple::get_jets ( Trig::FeatureContainer::combination_const_iterator  citr,
std::vector< TrackTrigObject > &  objects,
const std::string &  key = "" 
)
inherited

retrieve the jets from the Roi

Definition at line 134 of file AnalysisConfig_Ntuple.cxx.

135  {
136 
137  objects.clear();
138 
139  const std::vector< Trig::Feature<xAOD::JetContainer> > jetfeatures = citr->get<xAOD::JetContainer>( key, TrigDefs::alsoDeactivateTEs );
140 
141  if ( jetfeatures.empty() ) return 0;
142 
143  for ( size_t ifeature=0 ; ifeature<jetfeatures.size() ; ifeature++ ) {
144  Trig::Feature<xAOD::JetContainer> jetfeature = jetfeatures.at(ifeature);
145 
146  if ( jetfeature.empty() ) continue;
147 
148  const xAOD::JetContainer* jets = jetfeature.cptr();
149 
150  if ( jets == 0 ) continue;
151 
152  xAOD::JetContainer::const_iterator jitr = jets->begin();
153 
154  for ( int j=0 ; jitr!=jets->end() ; ++jitr, j++ ) {
155 
156  const xAOD::Jet* ajet = (*jitr);
157 
158  long unsigned jetid = (unsigned long)ajet;
159 
160  TrackTrigObject jet = TrackTrigObject( ajet->eta(), ajet->phi(), ajet->pt(), 0, ajet->type(), jetid );
161 
162  objects.push_back( jet );
163 
164  }
165  }
166 
167  return objects.size();
168 
169 }

◆ getBeamspot() [1/2]

std::vector<double> T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::getUseHighestPT ( ) const
inlineinherited

Definition at line 277 of file T_AnalysisConfig.h.

277 { return m_useHighestPT; }

◆ getVtxIndex()

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

Definition at line 280 of file T_AnalysisConfig.h.

280 { return m_vtxIndex; }

◆ initialize()

virtual void T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::keepAllEvents ( bool  b)
inlineinherited

Definition at line 274 of file T_AnalysisConfig.h.

274 { m_keepAllEvents = b; }

◆ loop()

void AnalysisConfigMT_Ntuple::loop ( )
protectedvirtual

list the configured chains once

FIXME: should really have hardcoded limits encoded as const variables

use wide |eta|<5 range to allow for ITk studies also

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

bomb out if no chains passed and not told to keep all events

finished loop over chains

bomb out if no chains passed and not told to keep all events and found no offline objects

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

AOD

anything else?

anything else?

anything else?

get (offline) reference tracks

get offline tracks

get the offline vertices into our structure

add offline Vertices to the Offline chain

add the truth particles if needed

offline object counters // std::vector<TrackTrigObject> tidaVertexTracks;

now add the offline tracks

navigate through the requested storegate TEST chains

keep this printout here, but commented for usefull debug purposes ...

get the chain, collection and TE names and track index

here we only want collections with no specified chain name, then we look in storegate for the collections directly

now retrieve any verttices for the analysis

MT Vertex access

new electron selection

hmm, if we stored the types as a map it would be more straightforward than having to stick all this in a loop

get muons

get muons

new tau selection

hmm, if we stored the types as a map it would be more straightforward than having to stick all this in a loop

use same threshold for 1 and 3 prong ??

only add a tau collection if there are actually the relevant tausCH

get the chain name

and the name of the collection (if any)

now decide whether we want all the TEs for this chain, or just those that are still active

if the chain did not pass, skip this chain completely

new MT TDT feature access

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

count of how many rois processed so far

if no rois for this chain then move along

create the analysis chain

I really, really hate range based loops ...

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

useful diagnostic - leave in place ... m_provider->msg(MSG::INFO) << "TIDARoi " << *roi_tmp << "\tcollectionName: " << collectionName << endmsg;

this should never be the case, and we should only run this bit of code once the first time round the loop anyhow

fetch vertices if available ...

MT Vertex access

Reimplemented from AnalysisConfig_Ntuple.

Definition at line 97 of file AnalysisConfigMT_Ntuple.cxx.

97  {
98 
99  m_provider->msg(MSG::DEBUG) << "" << "AnalysisConfigMT_Ntuple::loop() for " << m_analysisInstanceName
100  << " compiled " << __DATE__ << " " << __TIME__ << "\t: " << date() << "" << endmsg;
101 
102 
103  bool foundOffline = false;
104 
105  // get (offline) beam position
106  double xbeam = 0;
107  double ybeam = 0;
108  double zbeam = 0;
109  std::vector<double> beamline;
110 
111 
112  // get (online) beam position
113  double xbeam_online = 0;
114  double ybeam_online = 0;
115  double zbeam_online = 0;
116 
117  std::vector<double> beamline_online;
118 
119  // m_provider->msg(MSG::INFO) << " offline beam position\tx=" << xbeam << "\ty=" << ybeam << "\tz=" << zbeam << endmsg;
120  // m_provider->msg(MSG::INFO) << " online beam position\tx=" << xbeam_online << "\ty=" << ybeam_online << "\tz=" << zbeam_online << endmsg;
121 
123  static const std::set<std::string> configuredHLTChains = get_configured_chains();
124 
125  Filter_AcceptAll filter;
128  Filter_etaPT filterRef(5,500);
130  Filter_etaPT filter_etaPT(5.0,m_ptmin);
131  Filter_pdgIdpTeta filter_pdgIdpTeta(m_TruthPdgId,5.0,m_ptmin); // |eta|<5, pt>m_ptmin
132 
133  TrackFilter* truthFilter = &filter_etaPT;
134 
135  TrigTrackSelector selectorTruth( truthFilter, m_fiducial_radius, m_TruthPdgId, m_parentTruthPdgId);
136 
137  TrigTrackSelector selectorRef( &filter_etaPT );
138  TrigTrackSelector selectorTest( &filter );
139 
140  TIDAVertexBuilder vertexBuilder;
141 
142  if ( xbeam!=0 || ybeam!=0 ) {
143  selectorTruth.setBeamline( xbeam, ybeam, zbeam );
144  selectorRef.setBeamline( xbeam, ybeam, zbeam );
145  }
146 
147  if ( xbeam_online!=0 || ybeam_online!=0 ) {
148  selectorTest.setBeamline( xbeam_online, ybeam_online, zbeam_online );
149  }
150 
151  selectorTruth.correctTracks( true );
152  selectorRef.correctTracks( true );
153  selectorTest.correctTracks( true );
154 
155 
156  // clear the ntuple TIDA::Event class
157  m_event->clear();
158 
159  const xAOD::EventInfo* pEventInfo = 0;
160 
161  unsigned run_number = 0;
162  unsigned long long event_number = 0;
163  unsigned lumi_block = 0;
164  unsigned bunch_crossing_id = 0;
165  unsigned time_stamp = 0;
166  double mu_val = 0;
167 
168  if ( retrieve(pEventInfo, "EventInfo").isFailure() ) {
169  m_provider->msg(MSG::DEBUG) << "Failed to get EventInfo " << endmsg;
170  }
171  else {
172  run_number = pEventInfo->runNumber();
173  event_number = pEventInfo->eventNumber();
174  lumi_block = pEventInfo->lumiBlock();
175  time_stamp = pEventInfo->timeStamp();
176  bunch_crossing_id = pEventInfo->bcid();
177  mu_val = pEventInfo->averageInteractionsPerCrossing();
178  }
179 
180  m_provider->msg(MSG::DEBUG) << "run " << run_number
181  << "\tevent " << event_number
182  << "\tlb " << lumi_block << endmsg;
183 
184  m_event->run_number(run_number);
185  m_event->event_number(event_number);
186  m_event->lumi_block(lumi_block);
187  m_event->time_stamp(time_stamp);
188  m_event->bunch_crossing_id(bunch_crossing_id);
189  m_event->mu(mu_val);
190 
191  // build a chain group on the fly and use the reference
192  const Trig::ChainGroup* L2chain=(*m_tdt)->getChainGroup("L2_.*");
193  const Trig::ChainGroup* EFchain=(*m_tdt)->getChainGroup("EF_.*");
194  const Trig::ChainGroup* HLTchain=(*m_tdt)->getChainGroup("HLT_.*");
195 
196  m_provider->msg(MSG::DEBUG) << ""
197  << "L2 pass " << L2chain->isPassed() << "\t"
198  << "EF pass " << EFchain->isPassed() << "\t"
199  << "HLT pass " << HLTchain->isPassed() << ""
200  << endmsg;
201 
204 
205  bool analyse = false;
206 
207  unsigned decisiontype = TrigDefs::Physics;
208 
210 
211  int passed_chains = 0;
212 
213  m_provider->msg(MSG::DEBUG) << "Checking " << m_chainNames.size() << " chains" << endmsg;
214 
215  if ( m_chainNames.empty() ) {
216  m_provider->msg(MSG::WARNING) << "No chains to check" << endmsg;
217  return;
218  }
219 
220  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
221 
222  std::string chainName = m_chainNames[ichain].head();
223 
224  // Only for trigger chains
225 
226  if (chainName.find("L2") == std::string::npos &&
227  chainName.find("EF") == std::string::npos &&
228  chainName.find("HLT") == std::string::npos ) continue;
229 
230  if ( configuredHLTChains.find(chainName)==configuredHLTChains.end() ) {
231  m_provider->msg(MSG::WARNING) << "" << "Chain " << chainName
232  << " is not configured for this event" << ""
233  << endmsg;
234  continue;
235  }
236 
237  if ( m_chainNames[ichain].passed() ) decisiontype = TrigDefs::Physics;
238  else decisiontype = TrigDefs::includeFailedDecisions;
239 
240  std::string roistring = "";
241  if ( m_chainNames[ichain].roi()!="" ) roistring += "\troi " + m_chainNames[ichain].roi();
242 
243  bool passPhysics = (*m_tdt)->isPassed(chainName);
244 
245  m_provider->msg(MSG::DEBUG) << "Chain " << chainName << "\troi " << roistring
246  << "\tpres " << (*m_tdt)->getPrescale(chainName)
247  << ( passPhysics ? "" : "" ) << "\tpass physics " << passPhysics << ( passPhysics ? "" : "" )
248  << "\t: ( pass " << (*m_tdt)->isPassed(chainName, decisiontype ) << "\tdec type " << decisiontype << " ) " << endmsg;
249 
250  if ( (*m_tdt)->isPassed(chainName, decisiontype ) || !m_chainNames[ichain].passed() ) {
251  analyse = true;
252  passed_chains++;
253  }
254 
255  }
256 
257 
258 
261  if ( !analyse && !m_keepAllEvents && !foundOffline ) {
262  m_provider->msg(MSG::DEBUG) << "No chains passed unprescaled - not processing this event: " << run_number << " " << event_number << " " << lumi_block << endmsg;
263  return;
264  }
265 
266 
267  m_provider->msg(MSG::DEBUG) << "Chains passed " << passed_chains << endmsg;
268 
269 
271 
272  // const TruthParticleContainer* mcpartTES = 0;
273 
274  selectorTruth.clear();
275 
276  m_provider->msg(MSG::DEBUG) << "MC Truth flag " << m_mcTruth << endmsg;
277  const TrigInDetTrackTruthMap* truthMap = 0;
278 
279  if ( m_mcTruth) {
280  m_provider->msg(MSG::DEBUG) << "getting Truth" << endmsg;
281  if ( retrieve(truthMap, "TrigInDetTrackTruthMap").isFailure()) {
282  m_hasTruthMap = false;
283  }
284  else {
285  m_hasTruthMap = true;
286  }
287  if (m_provider->evtStore()->contains<TruthParticleContainer>("INav4MomTruthEvent")) {
288  //ESD
289  selectTracks<TruthParticleContainer>( &selectorTruth, "INav4MomTruthEvent" );
290  }
291  else if (m_provider->evtStore()->contains<TruthParticleContainer>("SpclMC")) {
293  selectTracks<TruthParticleContainer>( &selectorTruth, "SpclMC");
294  }
295  else if (m_provider->evtStore()->contains<TruthParticleContainer>("")) {
297  selectTracks<TruthParticleContainer>( &selectorTruth, "");
298  }
299  else if (m_provider->evtStore()->contains<xAOD::TruthParticleContainer>("TruthParticles")) {
301  selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "TruthParticles" );
302  }
303  else if (m_provider->evtStore()->contains<xAOD::TruthParticleContainer>("")) {
305  selectTracks<xAOD::TruthParticleContainer>( &selectorTruth, "" );
306  }
307  else {
308  m_provider->msg(MSG::WARNING) << "Truth not found - none whatsoever!" << endmsg;
309  }
310  }
311 
312 
313  // clear the ntuple TIDA::Event class
314  m_event->clear();
315 
317 
319 
320  m_provider->msg(MSG::DEBUG) << " Offline tracks " << endmsg;
321 
322  selectorRef.clear();
323 
324  if (m_provider->evtStore()->contains<xAOD::TrackParticleContainer>("InDetTrackParticles")) {
325  selectTracks<xAOD::TrackParticleContainer>( &selectorRef, "InDetTrackParticles" );
326  }
327  else if (m_provider->evtStore()->contains<Rec::TrackParticleContainer>("TrackParticleCandidate")) {
328  selectTracks<Rec::TrackParticleContainer>( &selectorRef, "TrackParticleCandidate" );
329  }
330  else {
331  m_provider->msg(MSG::WARNING) << " Offline tracks not found " << endmsg;
332  }
333 
334 
336  for ( size_t iv=0; iv<m_vertexType.size(); iv++ ) {
337 
338  std::vector<TIDA::Vertex> vertices;
339 
340  std::string vertexType = "PrimaryVertices";
341  std::string vertexChainname = "Vertex";
342  if ( m_vertexType[iv]!="" ) {
343  vertexType = m_vertexType[iv];
344  vertexChainname += ":" + vertexType;
345  }
346 
347  m_provider->msg(MSG::VERBOSE) << "fetching offline AOD vertex container with key " << vertexType << endmsg;
348 
349  const xAOD::VertexContainer* xaodVtxCollection = 0;
350 
351  if ( retrieve( xaodVtxCollection, vertexType ).isFailure()) {
352  if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD vertex container not found with key " << vertexType << endmsg;
353  }
354 
355  if ( xaodVtxCollection!=0 ) {
356 
357  m_provider->msg(MSG::DEBUG) << "xAOD vertex container " << vertexType << " found with " << xaodVtxCollection->size() << " entries" << endmsg;
358 
359  // Vertex types in some secondary vertex collections are not properly set and are all 0,
360  // allow these vertices if primary vertices are not used
361  if ( vertexType.find("SecVtx") != std::string::npos ) {
362  vertices = vertexBuilder.select( xaodVtxCollection, &selectorRef.tracks(), true );
363  }
364  else {
365  vertices = vertexBuilder.select( xaodVtxCollection, &selectorRef.tracks() );
366  }
367  }
368 
369  // now add the offline vertices
370  if ( m_doOffline || m_doVertices ) {
371  m_event->addChain( vertexChainname );
372  m_event->back().addRoi(TIDARoiDescriptor(true));
373  m_event->back().back().addVertices( vertices );
374  }
375  }
376 
378 
380 
381  if ( m_mcTruth ) {
382  m_event->addChain( "Truth" );
383  m_event->back().addRoi(TIDARoiDescriptor(true));
384  m_event->back().back().addTracks(selectorTruth.tracks());
385  }
386 
387 #if 0
388  for ( unsigned i=0 ; i<vertices.size() ; i++ ) {
390  m_provider->msg(MSG::DEBUG) << "vertex " << i << " " << vertices[i] << endmsg;
391  m_event->addVertex(vertices[i]);
392  }
393 #endif
394 
396 
397  int Noff = 0;
398  int Nmu = 0;
399  int Nel = 0;
400  int Ntau = 0;
401 
403 
404  if ( m_doOffline ) {
405 
406  m_event->addChain( "Offline" );
407  m_event->back().addRoi(TIDARoiDescriptor(true));
408  m_event->back().back().addTracks(selectorRef.tracks());
409 
410  if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) {
411  std::vector<double> beamline_;
412  beamline_.push_back( selectorRef.getBeamX() );
413  beamline_.push_back( selectorRef.getBeamY() );
414  beamline_.push_back( selectorRef.getBeamZ() );
415  m_event->back().back().addUserData(beamline_);
416  }
417 
418 
419  Noff = selectorRef.tracks().size();
420 
421  m_provider->msg(MSG::DEBUG) << "ref tracks.size() " << selectorRef.tracks().size() << endmsg;
422  for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << " ref track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;
423 
424  }
425 
427  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
428 
430  // m_provider->msg(MSG::INFO)<< "chain:\t" << m_chainNames[ichain] << endmsg;
431 
433  std::string chainname = m_chainNames[ichain].head();
434  std::string collectionname = m_chainNames[ichain].tail();
435  std::string vtx_name = m_chainNames[ichain].vtx();
436 
437 
438  if ( chainname!="" ) continue;
439  if ( collectionname=="" ) continue;
440 
441  chainname = collectionname;
442  if ( vtx_name!="" ) chainname += ":" + vtx_name;
443 
444  // useful debug information - leave this here
445 
448 
449  selectorTest.clear();
450 
451  bool found = false;
452 
453  std::string collection_test = collectionname;
454  size_t pos = collectionname.find("/");
455  if ( pos!=std::string::npos ) collection_test = collectionname.substr( pos+1, collectionname.size()-pos );
456 
457  if (m_provider->evtStore()->contains<Rec::TrackParticleContainer>(collection_test)) {
458  found = selectTracks<Rec::TrackParticleContainer>( &selectorTest, collectionname );
459  }
460  else if (m_provider->evtStore()->contains<xAOD::TrackParticleContainer>(collection_test)) {
461  found = selectTracks<xAOD::TrackParticleContainer>( &selectorTest, collectionname );
462  }
463  else if (m_provider->evtStore()->contains<TrigInDetTrackCollection>(collection_test)) {
464  found = selectTracks<TrigInDetTrackCollection>( &selectorTest, collectionname );
465  }
466  else if (m_provider->evtStore()->contains<TrackCollection>(collection_test)) {
467  found = selectTracks<TrackCollection>( &selectorTest, collectionname );
468  }
469  else {
470  m_provider->msg(MSG::WARNING) << "\tcollection " << collectionname << " not found" << endmsg;
471  }
472 
473 
475 
476  std::vector<TIDA::Vertex> tidavertices;
477 
478  m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
479 
480  if ( vtx_name!="" ) {
481 
482  m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer with key " << vtx_name << endmsg;
483 
485 
486  const xAOD::VertexContainer* xaodVtxCollection = 0;
487 
488  if ( retrieve( xaodVtxCollection, vtx_name ).isFailure() ) {
489  if (m_provider->msg().level() <= MSG::WARNING) m_provider->msg(MSG::WARNING) << "xAOD vertex container not found with key " << vtx_name << endmsg;
490  }
491 
492  if ( xaodVtxCollection!=0 ) {
493 
494  m_provider->msg(MSG::DEBUG) << "\txAOD::VertexContainer found with size " << xaodVtxCollection->size()
495  << "\t" << vtx_name << endmsg;
496 
497  // Vertex types in some secondary vertex collections are not properly set and are all 0,
498  // allow these vertices if primary vertices are not used
499  if ( vtx_name.find("SecVtx") != std::string::npos ) {
500  tidavertices = vertexBuilder.select( xaodVtxCollection, 0, true );
501  }
502  else {
503  tidavertices = vertexBuilder.select( xaodVtxCollection );
504  }
505  }
506 
507  }
508 
509 
510  if ( found ) {
511 
512  m_event->addChain( chainname );
513  m_event->back().addRoi(TIDARoiDescriptor(true));
514  if ( vtx_name!="" ) m_event->back().back().addVertices( tidavertices );
515  m_event->back().back().addTracks(selectorTest.tracks());
516 
517  if ( selectorTest.getBeamX()!=0 || selectorTest.getBeamY()!=0 || selectorTest.getBeamZ()!=0 ) {
518  std::vector<double> beamline_;
519  beamline_.push_back( selectorTest.getBeamX() );
520  beamline_.push_back( selectorTest.getBeamY() );
521  beamline_.push_back( selectorTest.getBeamZ() );
522  m_event->back().back().addUserData(beamline_);
523  }
524 
525  int Ntest = selectorTest.tracks().size();
526 
527  m_provider->msg(MSG::DEBUG) << "collection " << collectionname << "\ttest tracks.size() " << Ntest << endmsg;
528  for ( int ii=Ntest ; ii-- ; ) m_provider->msg(MSG::DEBUG) << " test track " << ii << " " << *selectorTest.tracks()[ii] << endmsg;
529  }
530  }
531 
532 
533  std::string ElectronRef[7] = {
534  "",
535  "TightCB", "MediumCB", "LooseCB",
536  "TightLH", "MediumLH", "LooseLH" };
537 
538 
540 
541  for ( size_t ielec=0 ; ielec<m_electronType.size() ; ielec++ ) {
544 
545  int itype = -1;
546  for ( int it=0 ; it<7 ; it++ ) if ( m_electronType[ielec]==ElectronRef[it] ) itype = it;
547  if ( itype<0 ) continue;
548 
549  std::vector<TrackTrigObject> elevec;
550 
551  std::string echain = std::string("Electrons");
552  if (m_electronIsLRT[ielec]) echain = std::string("LRTElectrons");
553 
554  int Nel_ = processElectrons( selectorRef, &elevec, itype, ( m_rawElectrons[ielec]=="raw" ? true : false ), 0.0, echain );
555 
556  if ( Nel_ < 1 ) continue;
557 
558  Nel += Nel_;
559 
560  if ( m_electronType[ielec]!="" ) echain += "_" + m_electronType[ielec];
561  if ( m_rawElectrons[ielec]=="raw" ) echain += "_raw";
562 
563  m_event->addChain( echain );
564  m_event->back().addRoi(TIDARoiDescriptor(true));
565  m_event->back().back().addTracks(selectorRef.tracks());
566  m_event->back().back().addObjects( elevec );
567 
568  if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) {
569  std::vector<double> beamline_;
570  beamline_.push_back( selectorRef.getBeamX() );
571  beamline_.push_back( selectorRef.getBeamY() );
572  beamline_.push_back( selectorRef.getBeamZ() );
573  m_event->back().back().addUserData(beamline_);
574  }
575 
576  }
577 
578 
579  std::string MuonRef[5] = { "", "Tight", "Medium", "Loose", "VeryLoose" };
580 
582  for ( size_t imuon=0 ; imuon<m_muonType.size() ; imuon++ ) {
583 
584  m_provider->msg(MSG::DEBUG) << "fetching offline muons " << endmsg;
585 
586  int muonType = -1;
587  for ( int it=0 ; it<5 ; it++ ) if ( m_muonType[imuon] == MuonRef[it] ) muonType=it;
588  if ( muonType<0 ) continue;
589 
590  std::string mchain = "Muons";
591  if (m_muonIsLRT[imuon]) mchain = "MuonsLRT";
592 
593  int Nmu_ = processMuons( selectorRef, muonType, 0, mchain );
594 
595  if ( Nmu_ < 1 ) continue;
596 
597  Nmu += Nmu_;
598 
599  m_provider->msg(MSG::DEBUG) << "found " << Nmu << " offline muons " << endmsg;
600 
601  if ( m_muonType[imuon]!="" ) mchain += "_" + m_muonType[imuon];
602 
603  m_event->addChain(mchain);
604  m_event->back().addRoi(TIDARoiDescriptor(true));
605  m_event->back().back().addTracks(selectorRef.tracks());
606 
607  if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) {
608  std::vector<double> beamline_;
609  beamline_.push_back( selectorRef.getBeamX() );
610  beamline_.push_back( selectorRef.getBeamY() );
611  beamline_.push_back( selectorRef.getBeamZ() );
612  m_event->back().back().addUserData(beamline_);
613  }
614 
615  m_provider->msg(MSG::DEBUG) << "ref muon tracks.size() " << selectorRef.tracks().size() << endmsg;
616  for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << " ref muon track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;
617  }
618 
619 
621  if ( m_doMuonsSP ) {
622 
623  m_provider->msg(MSG::DEBUG) << "fetching offline muons " << endmsg;
624 
625  int muonType = 0;
626 
627  Nmu += processMuons( selectorRef, muonType );
628 
629  m_provider->msg(MSG::DEBUG) << "found " << Nmu << " offline muons " << endmsg;
630 
631  m_event->addChain("MuonsSP");
632  m_event->back().addRoi(TIDARoiDescriptor(true));
633  m_event->back().back().addTracks(selectorRef.tracks());
634 
635  m_provider->msg(MSG::DEBUG) << "ref muon tracks.size() " << selectorRef.tracks().size() << endmsg;
636  for ( int ii=selectorRef.tracks().size() ; ii-- ; ) m_provider->msg(MSG::DEBUG) << " ref muon track " << ii << " " << *selectorRef.tracks()[ii] << endmsg;
637  }
638 
639 
640 
642  std::string TauRef[4] = { "", "Tight", "Medium", "Loose" };
643 
644 
645  for ( size_t itau=0 ; itau<m_tauType.size() ; itau++ ) {
648 
649  int itype = -1;
650  for ( int it=0 ; it<4 ; it++ ) if ( m_tauType[itau]==TauRef[it] ) itype = it;
651  if ( itype<0 ) continue;
652 
654  int requireNtracks = 0;
655  if ( m_tauProngs[itau]=="3Prong" ) requireNtracks = 3;
656  if ( m_tauProngs[itau]=="1Prong" ) requireNtracks = 1;
657 
658  std::vector<TrackTrigObject> tauvec;
659 
660  int Ntau_ = processTaus( selectorRef, &tauvec, itype, requireNtracks, 20000 );
661 
662  Ntau += Ntau_;
663 
664  if ( Ntau_ > 0 ) {
667 
668  std::string tchain = std::string("Taus");
669  if ( m_tauType[itau] != "" ) tchain += "_" + m_tauType[itau];
670  if ( m_tauProngs[itau] != "" ) tchain += "_" + m_tauProngs[itau];
671 
672  m_event->addChain( tchain );
673  m_event->back().addRoi(TIDARoiDescriptor(true));
674  m_event->back().back().addTracks(selectorRef.tracks());
675  m_event->back().back().addObjects( tauvec ) ;
676 
677  if ( selectorRef.getBeamX()!=0 || selectorRef.getBeamY()!=0 || selectorRef.getBeamZ()!=0 ) {
678  std::vector<double> beamline_;
679  beamline_.push_back( selectorRef.getBeamX() );
680  beamline_.push_back( selectorRef.getBeamY() );
681  beamline_.push_back( selectorRef.getBeamZ() );
682  m_event->back().back().addUserData(beamline_);
683  }
684 
685  }
686  }
687 
688  if ( Nmu==0 && Noff==0 && Nel==0 && Ntau==0 ) m_provider->msg(MSG::DEBUG) << "No offline objects found " << endmsg;
689  else foundOffline = true;
690 
691 
692  // now loop over all relevant chains to get the trigger tracks...
693 
694  for ( unsigned ichain=0 ; ichain<m_chainNames.size() ; ichain++ ) {
695 
696  // create chains for ntpl
697 
699  const std::string& chainName = m_chainNames[ichain].head();
700 
702  const std::string& collectionName = m_chainNames[ichain].tail();
703 
704  if( chainName.find("L2_")==std::string::npos &&
705  chainName.find("EF_")==std::string::npos &&
706  chainName.find("HLT_")==std::string::npos ) continue;
707 
708  if ( m_chainNames[ichain].passed() ) decisiontype = TrigDefs::Physics;
709  else decisiontype = TrigDefs::includeFailedDecisions;
710 
711 
712  m_provider->msg(MSG::DEBUG) << "chain " << chainName
713  << "\tprescale " << (*m_tdt)->getPrescale(chainName)
714  << "\tpass " << (*m_tdt)->isPassed(chainName) << " physics "
715  << " (req dec " << (*m_tdt)->isPassed(chainName, decisiontype ) << " dec type " << decisiontype << ")"
716  << endmsg;
717 
720 
722  if ( !(*m_tdt)->isPassed( chainName, decisiontype ) ) continue;
723 
725 
726 
727  std::string roi_key = m_chainNames[ichain].roi();
728  std::string vtx_name = m_chainNames[ichain].vtx();
729 
730 
731 #if 0
732 
737 
738  if ( roi_name!="" ) {
739 
740  std::string roi_name_tmp = roi_name;
741  std::string roi_tename = "";
742 
743  if ( roi_name.find("/")!=std::string::npos ) {
744  roi_name_tmp = roi_name.substr( roi_name.find("/")+1, roi_name.size()-roi_name.find("/") );
745  roi_tename = roi_name.substr( 0, roi_name.find("/") );
746  }
747 
748  roist = comb->get<TrigRoiDescriptor>( roi_name_tmp, decisiontype, roi_tename );
749 
750  if ( roist.size()>0 ) {
751  for ( unsigned ir=0 ; ir<roist.size() ; ir++ ) m_provider->msg(MSG::DEBUG) << "\t\tRetrieved roi " << roi_name << "\t" << *roist[ir].cptr() << endmsg;
752  }
753  else {
754  m_provider->msg(MSG::WARNING) << "\t\tRequested roi " << roi_name << " not found" << endmsg;
755  }
756 
757  }
758  else {
759  roist = comb->get<TrigRoiDescriptor>("forID1");
760  if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>("forID");
761  if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>("");
762  if ( roist.empty() ) roist = comb->get<TrigRoiDescriptor>("initialRoI");
763  }
764 #endif
765 
766 
767  unsigned feature_type = TrigDefs::lastFeatureOfType;
768 
769  if ( roi_key!="" ) feature_type = TrigDefs::allFeaturesOfType;
770 
771  int leg = -1;
772 
773  if ( m_chainNames[ichain].element()!="" ) {
774  leg = std::atoi(m_chainNames[ichain].element().c_str());
775  }
776 
777 
778  std::string rgex = roi_key;
779 
780  std::vector< TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection> > rois =
781  (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,
782  decisiontype,
783  rgex,
784  feature_type,
785  "roi",
786  leg ) );
787 
790  if ( rois.empty() ) {
791  if ( !rgex.empty() ) {
792  rgex += "_probe";
793  rois = (*m_tdt)->template features<TrigRoiDescriptorCollection>( Trig::FeatureRequestDescriptor( chainName,
794  decisiontype,
795  rgex,
796  feature_type,
797  "roi",
798  leg ) );
799  }
800  }
801 
802  int iroi = 0;
803 
805 
806  if ( rois.size()==0 ) continue;
807 
809 
810  m_event->addChain( m_chainNames[ichain] );
811 
812  TIDA::Chain& chain = m_event->back();
813 
815  for ( const TrigCompositeUtils::LinkInfo<TrigRoiDescriptorCollection>& roi_info : rois ) {
816 
817  iroi++;
818 
822 
823  if ( roi_key=="SuperRoi" && iroi>1 ) continue;
824 
825  if ( roi_key.find("JetSuper")!=std::string::npos && iroi>1 ) continue;
826 
827  const ElementLink<TrigRoiDescriptorCollection> roi_link = roi_info.link;
828 
830  if ( roi_key!="" && roi_link.dataID()!=rgex ) continue;
831 
832  const TrigRoiDescriptor* const* roiptr = roi_link.cptr();
833 
834  if ( roiptr == 0 ) {
835  // std::cerr << "\treadback link is null DAMMIT !!!" << std::endl;
836  continue;
837  }
838 
839  if (m_provider->msg().level() <= MSG::VERBOSE) {
840  m_provider->msg(MSG::VERBOSE) << " RoI descriptor for seeded chain " << chainName << " " << **roiptr << endmsg;
841  }
842 
843  TIDARoiDescriptor* roi_tmp = new TIDARoiDescriptor( TIDARoiDescriptorBuilder(**roiptr) );
844 
846 
849 
852 
853  selectorTest.clear();
854 
855 
856  if ( chainName.find("HLT_")!=std::string::npos ) {
857  if ( selectTracks<xAOD::TrackParticleContainer>( &selectorTest, roi_link, collectionName ) );
858  else {
859  if (m_provider->msg().level() <= MSG::DEBUG) {
860  m_provider->msg(MSG::WARNING) << "\tNo track collection " << collectionName << " found" << endmsg;
861  }
862  }
863  }
864 
866 
867  std::vector<TIDA::Vertex> tidavertices;
868 
869  if ( vtx_name!="" ) {
870 
871  m_provider->msg(MSG::DEBUG) << "\tFetch xAOD::VertexContainer for chain " << chainName << " with key " << vtx_name << endmsg;
872 
874 
875  std::pair< xAOD::VertexContainer::const_iterator,
876  xAOD::VertexContainer::const_iterator > vtx_itrpair = getCollection<xAOD::VertexContainer>( roi_link, vtx_name );
877 
878  if ( vtx_itrpair.first == vtx_itrpair.second ) {
879  if ( m_provider->msg().level() <= MSG::DEBUG ) {
880  m_provider->msg(MSG::WARNING) << "\tNo xAOD::Vertex for chain " << chainName << " for key " << vtx_name << endmsg;
881  }
882  }
883  else {
884 
885  m_provider->msg(MSG::DEBUG) << "\txAOD::VertexContainer found with size " << (vtx_itrpair.second - vtx_itrpair.first)
886  << "\t" << vtx_name << endmsg;
887 
888  // Vertex types in some secondary vertex collections are not properly set and are all 0,
889  // allow these vertices if primary vertices are not used
890  if ( vtx_name.find("SecVtx") != std::string::npos ) {
891  tidavertices = vertexBuilder.select( vtx_itrpair.first, vtx_itrpair.second, &selectorRef.tracks(), true );
892  }
893  else {
894  tidavertices = vertexBuilder.select( vtx_itrpair.first, vtx_itrpair.second, &selectorTest.tracks() );
895  }
896  }
897  }
898 
899 #if 0
900  // now get the jets if they are present
902  std::vector<TrackTrigObject> jets;
903  if ( chainName.find("HLT_j")!=std::string::npos ) {
904  if ( get_jets( comb, jets ) == 0 ) m_provider->msg(MSG::WARNING) << "\tjets could not be retrieved " << endmsg;
905  }
906 #endif
907 
908  const std::vector<TIDA::Track*>& testTracks = selectorTest.tracks();
909  m_provider->msg(MSG::DEBUG) << "\ttest tracks.size() " << testTracks.size() << endmsg;
910  for (unsigned int ii=0; ii < testTracks.size(); ii++) {
911  m_provider->msg(MSG::DEBUG) << " test track " << ii << "for chain " << chainName + ":" + collectionName << " " << *testTracks[ii] << endmsg;
912  }
913 
914 
915  // only add chain if there are any rois - also add beamline position for postprocessing
916 
917 
918  if ( roi_tmp == 0 ) {
919  if ( testTracks.size()>0 ) m_provider->msg(MSG::WARNING) << "\ttest tracks.size() " << testTracks.size() << "found but no roi!!!" << endmsg;
920  roi_tmp = new TIDARoiDescriptor(true);
921  }
922 
923  chain.addRoi( *roi_tmp );
924 
925  chain.back().addTracks(testTracks);
926  chain.back().addVertices(tidavertices);
927 
928 #if 0
929  if ( chainName.find("HLT_j")!=std::string::npos ) chain.back().addObjects( jets );
931 #endif
932 
933  if ( selectorTest.getBeamX()!=0 || selectorTest.getBeamY()!=0 || selectorTest.getBeamZ()!=0 ) {
934  std::vector<double> beamline_;
935  beamline_.push_back( selectorTest.getBeamX() );
936  beamline_.push_back( selectorTest.getBeamY() );
937  beamline_.push_back( selectorTest.getBeamZ() );
938  chain.back().addUserData(beamline_);
939  }
940 
941  delete roi_tmp;
942  roi_tmp = 0;
943 
944  }
945 
946  }
947 
948 #if 0
949 
951  {
953 
954  if ( filterOnRoi() || m_ptmin>0 ) {
955 
956  TIDA::Chain* offline = 0;
957 
958  std::vector<std::string> chainnames = m_event->chainnames();
959 
961 
962  for ( size_t ic=chainnames.size() ; ic-- ; ) {
963  if ( chainnames[ic] == "Offline" ) {
964  offline = &(m_event->chains()[ic]);
965  break;
966  }
967  }
968 
969  if ( offline ) {
970 
971  std::vector<TIDA::Chain>& chains = m_event->chains();
972  std::vector<TIDA::Chain>::iterator citr = chains.begin();
973 
974  std::vector<std::pair<double,double> > philims;
975 
976  for ( ; citr!=chains.end() ; ++citr ) {
977  if ( citr->name().find("HLT_")!=std::string::npos ) {
978  for ( size_t ir=0 ; ir<citr->size() ; ir++ ) {
979  TIDARoiDescriptor& roi = citr->rois()[ir].roi();
980  if ( roi.composite() ) {
981  for ( size_t isub=0 ; isub<roi.size() ; isub++ ) {
982  philims.push_back( std::pair<double,double>( roi[isub]->phiMinus(), roi[isub]->phiPlus() ) );
983  }
984  }
985  else philims.push_back( std::pair<double,double>( roi.phiMinus(), roi.phiPlus() ) );
986  }
987  }
988  }
989 
990  remove_duplicates( philims );
991 
992  for ( size_t iroi=0 ; iroi<offline->size() ; iroi++ ) {
993 
994  std::vector<TIDA::Track>& tracks = offline->rois()[iroi].tracks();
995 
998  // size_t Noffline = tracks.size();
999 
1000  for ( std::vector<TIDA::Track>::iterator it=tracks.begin() ; it<tracks.end() ; ) {
1001  bool inc = true;
1002  if ( m_ptmin>0 ) {
1003  if ( std::fabs(it->pT())<m_ptmin ) { inc=false; tracks.erase( it ); }
1004  }
1005  if ( inc && filterOnRoi() ) {
1006  bool remove_track = true;
1007  for ( size_t isub=0 ; isub<philims.size() ; isub++ ) {
1008 
1009  if ( philims[isub].first < philims[isub].second ) {
1010  if ( it->phi()>=philims[isub].first && it->phi()<=philims[isub].second ) {
1011  remove_track = false;
1012  break;
1013  }
1014  }
1015  else {
1016  if ( it->phi()>=philims[isub].first || it->phi()<=philims[isub].second ) {
1017  remove_track = false;
1018  break;
1019  }
1020  }
1021  }
1022  if ( remove_track ) { inc=false; tracks.erase( it ); }
1023  }
1024  if ( inc ) ++it;
1025  }
1026 
1029  // m_provider->msg(MSG::DEBUG) << "TIDA::Roi offline track reduction: " << Noffline << " -> " << tracks.size() << endmsg;
1030 
1031  }
1032 
1033  }
1034 
1035  }
1036  }
1037 
1038 #endif
1039 
1040  if ( m_Tree ) m_Tree->Fill();
1041 
1042 }

◆ mcTruth()

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

Definition at line 259 of file T_AnalysisConfig.h.

259 { return m_mcTruth; }

◆ name()

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

Definition at line 233 of file T_AnalysisConfig.h.

233 {return m_analysisInstanceName;}

◆ processElectrons()

unsigned T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::releaseData ( ) const
inlineinherited

Definition at line 271 of file T_AnalysisConfig.h.

271 { return m_releaseData; }

◆ releaseData() [2/2]

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

Definition at line 272 of file T_AnalysisConfig.h.

272 { m_releaseData = s; }

◆ requireDecision()

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

Definition at line 286 of file T_AnalysisConfig.h.

286 { return m_requireDecision; }

◆ retrieve()

StatusCode T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::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_fiducial_radius()

void AnalysisConfigMT_Ntuple::set_fiducial_radius ( double  d)
inline

Definition at line 44 of file AnalysisConfigMT_Ntuple.h.

44 { m_fiducial_radius = d; }

◆ set_ptmin()

void AnalysisConfigMT_Ntuple::set_ptmin ( double  d)
inline

Definition at line 45 of file AnalysisConfigMT_Ntuple.h.

45 { m_ptmin = d; }

◆ setBeamX()

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

Definition at line 261 of file T_AnalysisConfig.h.

261 { m_beamX=d; }

◆ setBeamY()

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

Definition at line 262 of file T_AnalysisConfig.h.

262 { m_beamY=d; }

◆ setBeamZ()

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

Definition at line 263 of file T_AnalysisConfig.h.

263 { m_beamZ=d; }

◆ setFilterOnRoi()

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

Definition at line 283 of file T_AnalysisConfig.h.

283 { return m_filterOnRoi=b; }

◆ setGenericFlag()

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

Definition at line 269 of file T_AnalysisConfig.h.

269 { m_genericFlag=b; }

◆ setMCTruth()

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

Definition at line 258 of file T_AnalysisConfig.h.

258 { m_mcTruth=b; }

◆ setRequireDecision()

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

Definition at line 285 of file T_AnalysisConfig.h.

285 { m_requireDecision=b; }

◆ setUseHighestPT()

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

Definition at line 276 of file T_AnalysisConfig.h.

276 { m_useHighestPT=b; }

◆ setVtxIndex()

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

Definition at line 279 of file T_AnalysisConfig.h.

279 { m_vtxIndex=i; }

◆ testChains()

const std::string T_AnalysisConfig< AthReentrantAlgorithm >::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  }

Member Data Documentation

◆ m_analysis

TrackAnalysis* T_AnalysisConfig< AthReentrantAlgorithm >::m_analysis
protectedinherited

Definition at line 984 of file T_AnalysisConfig.h.

◆ m_analysisInstanceName

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

Definition at line 963 of file T_AnalysisConfig.h.

◆ m_associator

TrackAssociator* T_AnalysisConfig< AthReentrantAlgorithm >::m_associator
protectedinherited

Definition at line 983 of file T_AnalysisConfig.h.

◆ m_beamX

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamX
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamY

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamY
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_beamZ

double T_AnalysisConfig< AthReentrantAlgorithm >::m_beamZ
protectedinherited

Definition at line 988 of file T_AnalysisConfig.h.

◆ m_chainNames

std::vector<ChainString> AnalysisConfig_Ntuple::m_chainNames
protectedinherited

Definition at line 162 of file AnalysisConfig_Ntuple.h.

◆ m_Dir

TDirectory* AnalysisConfig_Ntuple::m_Dir
protectedinherited

Definition at line 160 of file AnalysisConfig_Ntuple.h.

◆ m_doBjets

bool AnalysisConfig_Ntuple::m_doBjets
protectedinherited

Definition at line 181 of file AnalysisConfig_Ntuple.h.

◆ m_doMuons

bool AnalysisConfig_Ntuple::m_doMuons
protectedinherited

Definition at line 166 of file AnalysisConfig_Ntuple.h.

◆ m_doMuonsSP

bool AnalysisConfig_Ntuple::m_doMuonsSP
protectedinherited

Definition at line 167 of file AnalysisConfig_Ntuple.h.

◆ m_doOffline

bool AnalysisConfig_Ntuple::m_doOffline
protectedinherited

Definition at line 164 of file AnalysisConfig_Ntuple.h.

◆ m_doVertices

bool AnalysisConfig_Ntuple::m_doVertices
protectedinherited

Definition at line 165 of file AnalysisConfig_Ntuple.h.

◆ m_electronIsLRT

std::vector<bool> AnalysisConfig_Ntuple::m_electronIsLRT
protectedinherited

Definition at line 174 of file AnalysisConfig_Ntuple.h.

◆ m_electronType

std::vector<std::string> AnalysisConfig_Ntuple::m_electronType
protectedinherited

Definition at line 172 of file AnalysisConfig_Ntuple.h.

◆ m_event

TIDA::Event* AnalysisConfig_Ntuple::m_event
protectedinherited

Definition at line 156 of file AnalysisConfig_Ntuple.h.

◆ m_fiducial_radius

double AnalysisConfigMT_Ntuple::m_fiducial_radius
private

Definition at line 55 of file AnalysisConfigMT_Ntuple.h.

◆ m_File

TFile* AnalysisConfig_Ntuple::m_File
protectedinherited

Definition at line 158 of file AnalysisConfig_Ntuple.h.

◆ m_filterOnRoi

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_filterOnRoi
protectedinherited

Definition at line 999 of file T_AnalysisConfig.h.

◆ m_filters

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

Definition at line 977 of file T_AnalysisConfig.h.

◆ m_finalised

bool AnalysisConfig_Ntuple::m_finalised
protectedinherited

Definition at line 189 of file AnalysisConfig_Ntuple.h.

◆ m_genericFlag

int T_AnalysisConfig< AthReentrantAlgorithm >::m_genericFlag
protectedinherited

Definition at line 990 of file T_AnalysisConfig.h.

◆ m_hasTruthMap

bool AnalysisConfig_Ntuple::m_hasTruthMap
protectedinherited

Definition at line 182 of file AnalysisConfig_Ntuple.h.

◆ m_keepAllEvents

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_keepAllEvents
protectedinherited

Definition at line 993 of file T_AnalysisConfig.h.

◆ m_keys

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

Definition at line 968 of file T_AnalysisConfig.h.

◆ m_mcTruth

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_mcTruth
protectedinherited

Definition at line 986 of file T_AnalysisConfig.h.

◆ m_muonIsLRT

std::vector<bool> AnalysisConfig_Ntuple::m_muonIsLRT
protectedinherited

Definition at line 170 of file AnalysisConfig_Ntuple.h.

◆ m_muonType

std::vector<std::string> AnalysisConfig_Ntuple::m_muonType
protectedinherited

Definition at line 169 of file AnalysisConfig_Ntuple.h.

◆ m_outputFileName

std::string AnalysisConfig_Ntuple::m_outputFileName
protectedinherited

Definition at line 185 of file AnalysisConfig_Ntuple.h.

◆ m_parentTruthPdgId

int AnalysisConfig_Ntuple::m_parentTruthPdgId
protectedinherited

Definition at line 197 of file AnalysisConfig_Ntuple.h.

◆ m_printInfo

bool AnalysisConfig_Ntuple::m_printInfo
protectedinherited

Definition at line 193 of file AnalysisConfig_Ntuple.h.

◆ m_provider

AthReentrantAlgorithm * T_AnalysisConfig< AthReentrantAlgorithm >::m_provider
protectedinherited

Definition at line 955 of file T_AnalysisConfig.h.

◆ m_ptmin

double AnalysisConfigMT_Ntuple::m_ptmin
private

Definition at line 56 of file AnalysisConfigMT_Ntuple.h.

◆ m_rawElectrons

std::vector<std::string> AnalysisConfig_Ntuple::m_rawElectrons
protectedinherited

Definition at line 173 of file AnalysisConfig_Ntuple.h.

◆ m_refChainKey

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

Definition at line 971 of file T_AnalysisConfig.h.

◆ m_refChainName

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

Definition at line 970 of file T_AnalysisConfig.h.

◆ m_releaseData

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

Definition at line 991 of file T_AnalysisConfig.h.

◆ m_requireDecision

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_requireDecision
protectedinherited

Definition at line 1001 of file T_AnalysisConfig.h.

◆ m_selectorRef

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorRef
protectedinherited

Definition at line 979 of file T_AnalysisConfig.h.

◆ m_selectorSel

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorSel
protectedinherited

Definition at line 981 of file T_AnalysisConfig.h.

◆ m_selectorTest

TrigTrackSelector* T_AnalysisConfig< AthReentrantAlgorithm >::m_selectorTest
protectedinherited

Definition at line 980 of file T_AnalysisConfig.h.

◆ m_tauEtCutOffline

bool AnalysisConfig_Ntuple::m_tauEtCutOffline
protectedinherited

Definition at line 183 of file AnalysisConfig_Ntuple.h.

◆ m_tauProngs

std::vector<std::string> AnalysisConfig_Ntuple::m_tauProngs
protectedinherited

Definition at line 177 of file AnalysisConfig_Ntuple.h.

◆ m_tauType

std::vector<std::string> AnalysisConfig_Ntuple::m_tauType
protectedinherited

Definition at line 176 of file AnalysisConfig_Ntuple.h.

◆ m_tdt

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

Definition at line 957 of file T_AnalysisConfig.h.

◆ m_testChainKey

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

Definition at line 974 of file T_AnalysisConfig.h.

◆ m_testChainName

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

Definition at line 973 of file T_AnalysisConfig.h.

◆ m_Tree

TTree* AnalysisConfig_Ntuple::m_Tree
protectedinherited

Definition at line 159 of file AnalysisConfig_Ntuple.h.

◆ m_TruthPdgId

int AnalysisConfig_Ntuple::m_TruthPdgId
protectedinherited

Definition at line 187 of file AnalysisConfig_Ntuple.h.

◆ m_types

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

Definition at line 967 of file T_AnalysisConfig.h.

◆ m_useBeamCondSvc

bool AnalysisConfig_Ntuple::m_useBeamCondSvc
protectedinherited

Definition at line 154 of file AnalysisConfig_Ntuple.h.

◆ m_useHighestPT

bool T_AnalysisConfig< AthReentrantAlgorithm >::m_useHighestPT
protectedinherited

Definition at line 995 of file T_AnalysisConfig.h.

◆ m_vertexType

std::vector<std::string> AnalysisConfig_Ntuple::m_vertexType
protectedinherited

Definition at line 179 of file AnalysisConfig_Ntuple.h.

◆ m_vtxIndex

int T_AnalysisConfig< AthReentrantAlgorithm >::m_vtxIndex
protectedinherited

Definition at line 997 of file T_AnalysisConfig.h.

The documentation for this class was generated from the following files:
AnalysisConfig_Ntuple::get_jets
size_t get_jets(Trig::FeatureContainer::combination_const_iterator citr, std::vector< TrackTrigObject > &objects, const std::string &key="")
retrieve the jets from the Roi
Definition: AnalysisConfig_Ntuple.cxx:134
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AnalysisConfig_Ntuple::m_TruthPdgId
int m_TruthPdgId
Definition: AnalysisConfig_Ntuple.h:187
Trk::y
@ y
Definition: ParamDefs.h:62
TrackAnalysis::initialise
virtual void initialise()=0
standard operation interface
Trig::FeatureRequestDescriptor
Definition: FeatureRequestDescriptor.h:37
T_AnalysisConfig< AthReentrantAlgorithm >::m_types
std::vector< std::vector< std::string > > m_types
Definition: T_AnalysisConfig.h:967
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
T_AnalysisConfig< AthReentrantAlgorithm >::m_mcTruth
bool m_mcTruth
Definition: T_AnalysisConfig.h:986
Trig::Feature
Definition: Feature.h:112
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TIDA::isGoodOffline
bool isGoodOffline(const Analysis::Electron &elec)
Definition: OfflineObjectSelection.cxx:122
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
T_AnalysisConfig< AthReentrantAlgorithm >::processMuons
unsigned processMuons(TrigTrackSelector &selectorRef, const unsigned int selection=0, double ETOffline=0, const std::string &containerName="StacoMuonCollection")
select offlinqe muons
Definition: T_AnalysisConfig.h:787
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
T_AnalysisConfig< AthReentrantAlgorithm >::m_filterOnRoi
bool m_filterOnRoi
Definition: T_AnalysisConfig.h:999
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TIDAVertexBuilder::select
static std::vector< TIDA::Vertex > select(const xAOD::VertexContainer *xAODVertices, const std::vector< TIDA::Track * > *trackCollection=0, bool useType0=false, bool require_tracks=true)
Definition: TIDAVertexBuilder.cxx:13
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:63
LArConditions2Ntuple.objects
objects
Definition: LArConditions2Ntuple.py:56
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
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< AthReentrantAlgorithm >::m_provider
AthReentrantAlgorithm * m_provider
Definition: T_AnalysisConfig.h:955
TrigTrackSelector::clear
virtual void clear() override
Definition: TrigTrackSelector.h:102
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
TIDA::Roi::addTracks
void addTracks(const std::vector< TIDA::Track > &tracks)
accessors for the track vector
Definition: TIDARoi.h:46
T_AnalysisConfig< AthReentrantAlgorithm >::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
AnalysisConfig_Ntuple::m_muonIsLRT
std::vector< bool > m_muonIsLRT
Definition: AnalysisConfig_Ntuple.h:170
TrigInDetTrackCollection
Definition: TrigInDetTrackCollection.h:13
AnalysisConfigMT_Ntuple::get_configured_chains
std::set< std::string > get_configured_chains()
Definition: AnalysisConfigMT_Ntuple.cxx:43
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AnalysisConfig_Ntuple::m_parentTruthPdgId
int m_parentTruthPdgId
Definition: AnalysisConfig_Ntuple.h:197
TrackFilter
Definition: TrackFilter.h:26
hist_file_dump.d
d
Definition: hist_file_dump.py:137
TIDA::Event::chainnames
std::vector< std::string > chainnames() const
Definition: TIDAEvent.cxx:27
Filter_etaPT
Definition: Filter_etaPT.h:27
AnalysisConfig_Ntuple::m_vertexType
std::vector< std::string > m_vertexType
Definition: AnalysisConfig_Ntuple.h:179
AnalysisConfig_Ntuple::m_chainNames
std::vector< ChainString > m_chainNames
Definition: AnalysisConfig_Ntuple.h:162
skel.it
it
Definition: skel.GENtoEVGEN.py:423
LArDigits2NtupleDumper.tdt
tdt
Definition: LArDigits2NtupleDumper.py:121
TIDARoiDescriptor
Describes the Region of Ineterest geometry It has basically 8 parameters.
Definition: TIDARoiDescriptor.h:42
xAOD::Jet_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: Jet_v1.cxx:54
offline
Analysis::TauJetContainer
Definition: Reconstruction/tauEvent/tauEvent/TauJetContainer.h:31
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
ChainString
Definition: ChainString.h:23
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
TrigTrackSelector
L2 tracks.
Definition: TrigTrackSelector.h:58
Filter_AcceptAll
Definition: Filter_AcceptAll.h:29
isValid
bool isValid(const T &p)
Definition: AtlasPID.h:214
TIDA::Roi::addObjects
void addObjects(const std::vector< TrackTrigObject > &ob)
Definition: TIDARoi.h:65
TIDA::Event::lumi_block
void lumi_block(unsigned lb)
Definition: TIDAEvent.h:44
TruthParticleContainer
Definition: PhysicsAnalysis/TruthParticleID/McParticleEvent/McParticleEvent/TruthParticleContainer.h:42
AnalysisConfig_Ntuple::m_electronIsLRT
std::vector< bool > m_electronIsLRT
Definition: AnalysisConfig_Ntuple.h:174
TIDARoiDescriptor::size
size_t size() const
Definition: TIDARoiDescriptor.h:176
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.
date
std::string date()
sadly, includes a return at the end
Definition: hcg.cxx:55
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TIDARoiDescriptor::phiPlus
double phiPlus() const
Definition: TIDARoiDescriptor.h:141
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< AthReentrantAlgorithm >::m_analysisInstanceName
std::string m_analysisInstanceName
Definition: T_AnalysisConfig.h:963
Container
storage of the time histories of all the cells
covarianceTool.filter
filter
Definition: covarianceTool.py:514
T_AnalysisConfig< AthReentrantAlgorithm >::m_keys
std::vector< std::vector< std::string > > m_keys
Definition: T_AnalysisConfig.h:968
TIDA::Chain::back
TIDA::Roi & back()
Definition: TIDAChain.h:60
T_AnalysisConfig< AthReentrantAlgorithm >::genericFlag
bool genericFlag() const
Definition: T_AnalysisConfig.h:268
HLT::NavigationCore
The NavigationCore class, adds on top of the TrigNavStructure the EDM read-only handling.
Definition: NavigationCore.h:96
AthCommonDataStore::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
Trig::Feature::te
const HLT::TriggerElement * te() const
explicit conversion to TriggerElement
Definition: Feature.h:181
Filter_pdgIdpTeta
Definition: Filters.h:73
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
xAOD::Jet_v1::type
virtual Type::ObjectType type() const
The type of the object as a simple enumeration.
Definition: Jet_v1.cxx:85
AnalysisConfig_Ntuple::m_Dir
TDirectory * m_Dir
Definition: AnalysisConfig_Ntuple.h:160
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
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< AthReentrantAlgorithm >::m_beamY
double m_beamY
Definition: T_AnalysisConfig.h:988
TIDARoiDescriptor::composite
bool composite() const
composite RoI methods
Definition: TIDARoiDescriptor.h:174
T_AnalysisConfig< AthReentrantAlgorithm >::releaseData
std::string releaseData() const
Definition: T_AnalysisConfig.h:271
T_AnalysisConfig< AthReentrantAlgorithm >::m_beamX
double m_beamX
Definition: T_AnalysisConfig.h:988
AnalysisConfig_Ntuple::m_muonType
std::vector< std::string > m_muonType
Definition: AnalysisConfig_Ntuple.h:169
DeMoScan.directory
string directory
Definition: DeMoScan.py:80
TIDA::Event::back
TIDA::Chain & back()
get the last chain from the vector
Definition: TIDAEvent.h:89
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
lumiFormat.i
int i
Definition: lumiFormat.py:92
AnalysisConfig_Ntuple::m_Tree
TTree * m_Tree
Definition: AnalysisConfig_Ntuple.h:159
T_AnalysisConfig< AthReentrantAlgorithm >::processTaus
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
Definition: T_AnalysisConfig.h:844
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
T_AnalysisConfig< AthReentrantAlgorithm >::processElectrons
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
Definition: T_AnalysisConfig.h:701
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< AthReentrantAlgorithm >::m_analysis
TrackAnalysis * m_analysis
Definition: T_AnalysisConfig.h:984
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
T_AnalysisConfig< AthReentrantAlgorithm >::m_requireDecision
bool m_requireDecision
Definition: T_AnalysisConfig.h:1001
TrigInDetTrackTruthMap
Definition: TrigInDetTrackTruthMap.h:38
AnalysisConfig_Ntuple::m_rawElectrons
std::vector< std::string > m_rawElectrons
Definition: AnalysisConfig_Ntuple.h:173
TIDA::Roi::addUserData
void addUserData(const std::vector< double > &user)
Definition: TIDARoi.h:70
compute_lumi.leg
leg
Definition: compute_lumi.py:95
TIDAVertexBuilder
Definition: TIDAVertexBuilder.h:22
T_AnalysisConfig< AthReentrantAlgorithm >::m_keepAllEvents
bool m_keepAllEvents
Definition: T_AnalysisConfig.h:993
AnalysisConfig_Ntuple::AnalysisConfig_Ntuple
AnalysisConfig_Ntuple(const std::vector< std::string > &chainNames, std::string outputFileName="TrkNtuple.root", double tauEtCutOffline=0.0, int TruthPdgId=0, bool _keepAllEvents=false, int parentTruthPdgId=0)
Definition: AnalysisConfig_Ntuple.h:43
Analysis::MuonContainer
definition of StoreGate container holding a vector of Analysis::Muon
Definition: Reconstruction/MuonIdentification/muonEvent/muonEvent/MuonContainer.h:38
AnalysisConfig_Ntuple::m_tauProngs
std::vector< std::string > m_tauProngs
Definition: AnalysisConfig_Ntuple.h:177
selection
std::string selection
Definition: fbtTestBasics.cxx:73
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.
remove_duplicates
void remove_duplicates(std::vector< T > &vec)
Definition: AnalysisConfigMT_Ntuple.cxx:37
xAOD::Jet_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: Jet_v1.cxx:49
beamspotman.dir
string dir
Definition: beamspotman.py:623
TIDA::Vertex
Definition: TIDAVertex.h:23
TrigTrackSelector::selectTrack
bool selectTrack(const TrigInDetTrack *track, const TrigInDetTrackTruthMap *truthMap=0)
neater code to make use of vector function also for a single ancestor pdgid, instead of the full code...
Definition: TrigTrackSelector.cxx:116
grepfile.ic
int ic
Definition: grepfile.py:33
Trig::ChainGroup
Definition: Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/ChainGroup.h:51
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
Trig::ChainGroup::isPassed
bool isPassed(unsigned int condition=TrigDefs::Physics) const
tells if chain group passed
Definition: Trigger/TrigAnalysis/TrigDecisionTool/Root/ChainGroup.cxx:208
AnalysisConfig_Ntuple::m_finalised
bool m_finalised
Definition: AnalysisConfig_Ntuple.h:189
T_AnalysisConfig< AthReentrantAlgorithm >::retrieve
StatusCode retrieve(Collection const *&collection, const std::string &key="")
Definition: T_AnalysisConfig.h:571
AnalysisConfig_Ntuple::m_doOffline
bool m_doOffline
Definition: AnalysisConfig_Ntuple.h:164
TrackSelector::tracks
const std::vector< TIDA::Track * > & tracks() const
Definition: Trigger/TrigAnalysis/TrigInDetAnalysis/TrigInDetAnalysis/TrackSelector.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Rec::TrackParticleContainer
Definition: Reconstruction/Particle/Particle/TrackParticleContainer.h:33
TIDA::Chain
Definition: TIDAChain.h:28
AnalysisConfig_Ntuple::m_File
TFile * m_File
Definition: AnalysisConfig_Ntuple.h:158
xAOD::vertexType
vertexType
Definition: Vertex_v1.cxx:166
TIDARoiDescriptorBuilder
Definition: TIDARoiDescriptorBuilder.h:21
xAOD::Electron_v1
Definition: Electron_v1.h:34
T_AnalysisConfig< AthReentrantAlgorithm >::loop
virtual void loop()=0
T_AnalysisConfig< AthReentrantAlgorithm >::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
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
AnalysisConfigMT_Ntuple::m_fiducial_radius
double m_fiducial_radius
Definition: AnalysisConfigMT_Ntuple.h:55
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
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
AnalysisConfigMT_Ntuple::m_ptmin
double m_ptmin
Definition: AnalysisConfigMT_Ntuple.h:56
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DeMoScan.first
bool first
Definition: DeMoScan.py:534
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:353
TriggerTest.rois
rois
Definition: TriggerTest.py:23
AthCommonMsg::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
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.
AnalysisConfig_Ntuple::m_event
TIDA::Event * m_event
Definition: AnalysisConfig_Ntuple.h:156
T_AnalysisConfig< AthReentrantAlgorithm >::m_vtxIndex
int m_vtxIndex
Definition: T_AnalysisConfig.h:997
AnalysisConfig_Ntuple::m_doVertices
bool m_doVertices
Definition: AnalysisConfig_Ntuple.h:165
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< AthReentrantAlgorithm >::filterOnRoi
bool filterOnRoi() const
Definition: T_AnalysisConfig.h:282
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
AnalysisConfig_Ntuple::m_tauType
std::vector< std::string > m_tauType
Definition: AnalysisConfig_Ntuple.h:176
T_AnalysisConfig< AthReentrantAlgorithm >::name
const std::string name() const
Definition: T_AnalysisConfig.h:233
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TIDA::Roi::addVertices
void addVertices(const std::vector< TIDA::Vertex > &v)
Definition: TIDARoi.h:59
T_AnalysisConfig< AthReentrantAlgorithm >::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< AthReentrantAlgorithm >::m_beamZ
double m_beamZ
Definition: T_AnalysisConfig.h:988
T_AnalysisConfig< AthReentrantAlgorithm >::m_filters
std::vector< std::vector< TrackFilter * > > m_filters
Definition: T_AnalysisConfig.h:977
AnalysisConfig_Ntuple::m_hasTruthMap
bool m_hasTruthMap
Definition: AnalysisConfig_Ntuple.h:182
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
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
TrackTrigObject::addChild
void addChild(unsigned long id)
Definition: TrackTrigObject.h:43
AthenaPoolExample_Copy.outputFileName
string outputFileName
Definition: AthenaPoolExample_Copy.py:40
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AnalysisConfig_Ntuple::m_doMuonsSP
bool m_doMuonsSP
Definition: AnalysisConfig_Ntuple.h:167
TIDARoiDescriptor::phiMinus
double phiMinus() const
Definition: TIDARoiDescriptor.h:140
plotBeamSpotMon.nc
int nc
Definition: plotBeamSpotMon.py:83
AnalysisConfig_Ntuple::m_outputFileName
std::string m_outputFileName
Definition: AnalysisConfig_Ntuple.h:185
zbeam
Definition: zbeam.h:24
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.
AnalysisConfig_Ntuple::m_electronType
std::vector< std::string > m_electronType
Definition: AnalysisConfig_Ntuple.h:172
T_AnalysisConfig< AthReentrantAlgorithm >::select
bool select(std::vector< TIDA::Vertex > &vertices, xAOD::VertexContainer::const_iterator vtx_start, xAOD::VertexContainer::const_iterator vtx_end)
Definition: T_AnalysisConfig.h:340
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
T_AnalysisConfig< AthReentrantAlgorithm >::m_releaseData
std::string m_releaseData
Definition: T_AnalysisConfig.h:991
T_AnalysisConfig< AthReentrantAlgorithm >::m_chainNames
std::vector< std::vector< std::string > > m_chainNames
Definition: T_AnalysisConfig.h:966
Generated on Mon Jul 8 2024 21:38:17 for ATLAS Offline Software by   doxygen 1.8.18