ATLAS Offline Software
TauJetRetriever.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "AnalysisJiveXML/TauJetRetriever.h"
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
9 #include "tauEvent/TauJetContainer.h"
10 
11 #include "tauEvent/Tau1P3PDetails.h"
12 #include "tauEvent/Tau1P3PExtraDetails.h"
13 #include "tauEvent/TauRecDetails.h"
14 #include "tauEvent/TauRecExtraDetails.h"
15 #include "tauEvent/TauPID.h"
16 #include "tauEvent/TauCommonDetails.h"
17 
18 // for associations:
19 #include "Particle/TrackParticleContainer.h"
20 #include "CaloEvent/CaloClusterContainer.h"
21 
22 namespace JiveXML {
23 
30  TauJetRetriever::TauJetRetriever(const std::string& type,const std::string& name,const IInterface* parent):
31  AthAlgTool(type,name,parent),
32  m_typeName("TauJet"){
33 
34  //Only declare the interface
35  declareInterface<IDataRetriever>(this);
36 
37  declareProperty("StoreGateKey", m_sgKey = "TauRecContainer");
38  declareProperty("DoWriteHLT", m_doWriteHLT = false); // ignore HLTAutoKey objects
39  m_fastSimSGFlag = false; }
44  StatusCode TauJetRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
45 
46  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "in retrieveAll()" << endmsg;
47 
48  SG::ConstIterator<Analysis::TauJetContainer> iterator, end;
49  const Analysis::TauJetContainer* tauCont;
50 
51  //obtain the default collection first
52  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Trying to retrieve " << dataTypeName() << " (" << m_sgKey << ")" << endmsg;
53  StatusCode sc = evtStore()->retrieve(tauCont, m_sgKey);
54  if (sc.isFailure()) {
55  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Collection " << m_sgKey << " not found in SG " << endmsg;
56  }else{
57  if ( tauCont->size() > 0){ // check that collection is not empty
58  DataMap data = getData(tauCont);
59  if ( FormatTool->AddToEvent(dataTypeName(), m_sgKey, &data).isFailure()){
60  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Collection " << m_sgKey << " not found in SG " << endmsg;
61  }else{
62  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << dataTypeName() << " (" << m_sgKey << ") TauJet retrieved" << endmsg;
63  }
64  }
65  }
66 
67  //obtain all other collections from StoreGate
68  if (( evtStore()->retrieve(iterator, end)).isFailure()){
69  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Unable to retrieve iterator for Jet collection" << endmsg;
70 // return StatusCode::WARNING;
71  }
72 
73  for (; iterator!=end; ++iterator) {
74  m_fastSimSGFlag = false; //reset
75  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Trying TauJets from: " << iterator.key() << endmsg;
76  std::string::size_type position = iterator.key().find("HLT",0); // special case. Normally: HLTAutokey
77  // some Atlfast collections wrongly assign 'Full' to DataType:
78  std::string::size_type positionFast = iterator.key().find("Atlfast",0);
79  if ( positionFast == 0){
80  m_fastSimSGFlag = true;
81  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " SG key Atlfast collection: Fast Sim " << endmsg;
82  };
83  if ( m_doWriteHLT ){ position = 99; } // override SG key find
84  if ( position != 0 ){ // SG key doesn't contain HLTAutoKey
85  if ( iterator.key()!=m_sgKey) {
86  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Trying to retrieve all " << dataTypeName() << " (" << iterator.key() << ")" << endmsg;
87  DataMap data = getData(&(*iterator));
88  if ( FormatTool->AddToEvent(dataTypeName(), iterator.key(), &data).isFailure()){
89  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Collection " << iterator.key() << " not found in SG " << endmsg;
90  }else{
91  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << dataTypeName() << " (" << iterator.key() << ") TauJet retrieved" << endmsg;
92  }
93  }
94  }
95  } // end collection iterator
96  //All collections retrieved okay
97  return StatusCode::SUCCESS;
98  }
99 
100 
105  const DataMap TauJetRetriever::getData(const Analysis::TauJetContainer* taucont) {
106 
107  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "in getData()" << endmsg;
108 
109  DataMap DataMap;
110 
111  DataVect phi; phi.reserve(taucont->size());
112  DataVect eta; eta.reserve(taucont->size());
113  DataVect pt; pt.reserve(taucont->size());
114  DataVect mass; mass.reserve(taucont->size());
115  DataVect energy; energy.reserve(taucont->size());
116  DataVect px; px.reserve(taucont->size());
117  DataVect py; py.reserve(taucont->size());
118  DataVect pz; pz.reserve(taucont->size());
119 
120  DataVect isTauString; isTauString.reserve(taucont->size());
121  DataVect label; label.reserve(taucont->size());
122  DataVect numTracks; numTracks.reserve(taucont->size());
123  DataVect charge; charge.reserve(taucont->size());
124  DataVect author; author.reserve(taucont->size());
125  DataVect etEMCalib; etEMCalib.reserve(taucont->size());
126  DataVect etHadCalib; etHadCalib.reserve(taucont->size());
127  DataVect emRadius; emRadius.reserve(taucont->size());
128  DataVect isolFrac; isolFrac.reserve(taucont->size());
129  DataVect stripWidth; stripWidth.reserve(taucont->size());
130  DataVect logLhRatio; logLhRatio.reserve(taucont->size());
131 
132 // DataVect isTau; isTau.reserve(taucont->size()); // available from rel.15 ?
133 
134  // for associations:
135  DataVect clusterKeyVec; clusterKeyVec.reserve(taucont->size());
136  DataVect clusterIndexVec; clusterIndexVec.reserve(taucont->size());
137  DataVect trackKeyVec; trackKeyVec.reserve(taucont->size());
138  DataVect trackIndexVec; trackIndexVec.reserve(taucont->size());
139  DataVect trackLinkCountVec; trackLinkCountVec.reserve(taucont->size());
140 
141 //from AnalysisSkeleton
142 
143  Analysis::TauJetContainer::const_iterator taujetItr = taucont->begin();
144  Analysis::TauJetContainer::const_iterator taujetItrE = taucont->end();
145 
146  ParticleDataType::DataType dataType;
147  bool checkDataType=true;
148 
149  if ( taujetItr != taujetItrE) {
150  dataType = (*taujetItr)->dataType();
151  checkDataType = (dataType != ParticleDataType::Fast) &&
152  (dataType != ParticleDataType::True);
153  }
154 
155  if(checkDataType){
156  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " TauJet Datatype: Full Sim " << endmsg;
157  }else{
158  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " TauJet Datatype: Fast Sim " << endmsg;
159  }
160  // if ( m_fastSimSGFlag ){ if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " fastSimSGFlag set ! " << endmsg; }
161 
162  unsigned int countTrackLinks = 0;
163  unsigned int numTauJets = 0;
164  std::string numTracksPerTaujet = "";
165  std::string trackKeyString = "trackKey"; // default: n/a or fast sim
166  std::string trackIndexString = "trackIndex";
167 
168  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " Number of TauJets: " << taucont->size() << endmsg;
169  if (checkDataType && !m_fastSimSGFlag){ // full sim
170  for (; taujetItr != taujetItrE; ++taujetItr) { // first, just count trackKey for multiple
171  const ElementLinkVector<Rec::TrackParticleContainer> myTrackLinkVector = (*taujetItr)->trackLinkVector();
172  countTrackLinks += myTrackLinkVector.size();
173  numTauJets++;
174  }
175  if ( numTauJets == 0 ){ // capture division by zero
176  numTracksPerTaujet = "0";
177  } else {
178  numTracksPerTaujet = DataType( countTrackLinks/((double) numTauJets )).toString();
179  }
180  trackKeyString = "trackKey multiple=\""+numTracksPerTaujet+"\"";
181  trackIndexString = "trackIndex multiple=\""+numTracksPerTaujet+"\"";
182  } // full sim
183 
184  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " trackKeyString: " << trackKeyString <<
185  " trackIndexString: " << trackIndexString << endmsg;
186 
187  std::string labelStr = "none";
188  std::string isTauStr = "none";
189  int id=0;
190  taujetItr = taucont->begin(); // reset iterator
191  for (; taujetItr != taujetItrE; ++taujetItr) { // full loop
192 
193  pt.push_back( JiveXML::DataType((*taujetItr)->pt()/CLHEP::GeV ) );
194  phi.push_back( JiveXML::DataType((*taujetItr)->phi() ) );
195  eta.push_back( JiveXML::DataType((*taujetItr)->eta() ) );
196  px.push_back( JiveXML::DataType((*taujetItr)->px()/CLHEP::GeV ) );
197  py.push_back( JiveXML::DataType((*taujetItr)->py()/CLHEP::GeV ) );
198  pz.push_back( JiveXML::DataType((*taujetItr)->pz()/CLHEP::GeV ) );
199  energy.push_back( JiveXML::DataType((*taujetItr)->m()/CLHEP::GeV ) );
200  mass.push_back( JiveXML::DataType((*taujetItr)->e()/CLHEP::GeV ) );
201 
202  if (checkDataType && !m_fastSimSGFlag) { // full sim
203 
204  std::string taujetAuthor = "none";
205  if (( (*taujetItr)->author()) == 0){ taujetAuthor = "default"; }
206  if (( (*taujetItr)->author()) == 1){ taujetAuthor = "tauRec"; }
207  if (( (*taujetItr)->author()) == 2){ taujetAuthor = "tau1P3P"; }
208  author.push_back( JiveXML::DataType( taujetAuthor ) );
209 
210  labelStr = taujetAuthor;
211 
212  numTracks.push_back( JiveXML::DataType( (*taujetItr)->numTrack() ) );
213  charge.push_back( JiveXML::DataType((*taujetItr)->charge() ) );
214 
215  isTauStr = "none";
216  // this is organised as hierarchy: First Tau1P3p, then CaloCuts
217  // 'best' tau passed is TauCutTight. This is used for cut in GUI
218  // all info written into 'label'
219  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauLlhLoose)){
220  isTauStr = "TauLlhLoose"; labelStr += "_TauLlhLoose";}
221  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauLlhMedium)){
222  isTauStr = "TauLlhMedium"; labelStr += "_TauLlhMedium";}
223  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauLlhTight)){
224  isTauStr = "TauLlhTight"; labelStr += "_TauLlhTight";}
225  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauCutLoose)){
226  isTauStr = "TauCutLoose"; labelStr += "_TauCutLoose";}
227  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauCutMedium)){
228  isTauStr = "TauCutMedium"; labelStr += "_TauCutMedium";}
229  if ((*taujetItr)->tauID()->isTau(TauJetParameters::TauCutTight)){
230  isTauStr = "TauCutTight"; labelStr += "_TauCutTight"; }
231  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " TauJet # " << (++id)
232  << ", label:" << labelStr << endmsg;
233  isTauString.push_back (isTauStr);
234  label.push_back( labelStr );
235 // obsolete, only for backwards compatibility
236  etEMCalib.push_back( JiveXML::DataType( 0. ) );
237  etHadCalib.push_back( JiveXML::DataType( 0. ) );
238  emRadius.push_back( JiveXML::DataType( 0. ) );
239  isolFrac.push_back( JiveXML::DataType( 0. ) ); // keep this ?
240  stripWidth.push_back( JiveXML::DataType( 0. ) );
241  logLhRatio.push_back( JiveXML::DataType( 0. ) ); // drop this !
242 
243 // new access to details taken from: jpt 10Nov09
244 // PhysicsAnalysis/TauID/TauAnalysis/TauJetSelector.cxx
245 // http://atlas-sw.cern.ch/cgi-bin/viewcvs-atlas.cgi/offline/Reconstruction/tauRec/src/tauCuts.cxx?revision=1.27.8.1&view=markup&pathrev=tauRec-02-05-48-branch
246 // https://twiki.cern.ch/twiki/bin/view/Atlas/TauEDM
247 //
248 // parameters for associations: Storegate key and Index
249 
250  // This doesn't work in devval towards 16.0.0: no valid link.
251  // Also not with clusterLinkVector, not available for TauJet.
252  const ElementLink<CaloClusterContainer> clusterLink = (*taujetItr)->clusterLink();
253  if (clusterLink.isValid()) {
254  std::string clusterKey = clusterLink.dataID(); // Storegate key of
255  int clusterIndex = clusterLink.index(); // index into the contianer
256  clusterKeyVec.push_back(DataType( clusterKey ));
257  clusterIndexVec.push_back(DataType( clusterIndex));
258  } else { // no clusterLink
259  clusterKeyVec.push_back(DataType( "none" ));
260  clusterIndexVec.push_back(DataType( -1 ));
261  }
262 
263  // this works fine
264  const ElementLinkVector<Rec::TrackParticleContainer> myTrackLinkVector = (*taujetItr)->trackLinkVector();
265 
266  unsigned int trackLinkCount = myTrackLinkVector.size();
267  trackLinkCountVec.push_back(DataType( trackLinkCount ));
268 
269  if (trackLinkCount > 0){
270  for (unsigned int i=0; i<trackLinkCount; ++i){
271 
272  const ElementLink<Rec::TrackParticleContainer> trackParticleLink = myTrackLinkVector.at(i);
273  std::string trackKey = trackParticleLink.dataID();
274  int trackIndex = trackParticleLink.index();
275  if ( trackParticleLink.isValid()){
276  // if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << dataTypeName() << " TrackParticle " << trackKey << " ,"
277  // << " Index " << trackIndex << " " << endmsg;
278 
279  trackKeyVec.push_back(DataType( trackKey ));
280  trackIndexVec.push_back(DataType( trackIndex));
281  } else { // no trackLink
282  trackKeyVec.push_back(DataType( "none" ));
283  trackIndexVec.push_back(DataType( -1 ));
284  }
285  }
286  }
287  } else { // end of checkDataType loop. Now fast simulation placeholders:
288 
289  std::string numTracksEmpty = "0";
290  author.push_back( JiveXML::DataType( "atlfast" ) );
291  numTracks.push_back( JiveXML::DataType( "1" ));
292  charge.push_back( JiveXML::DataType( 1. ) );
293  etEMCalib.push_back( JiveXML::DataType( 0. ) );
294  etHadCalib.push_back( JiveXML::DataType( 0. ) );
295  emRadius.push_back( JiveXML::DataType( 0. ) );
296  isolFrac.push_back( JiveXML::DataType( 0. ) );
297  stripWidth.push_back( JiveXML::DataType( 0. ) );
298  logLhRatio.push_back( JiveXML::DataType( 0. ) );
299  isTauString.push_back( JiveXML::DataType( "fastSim" ) );
300  label.push_back( JiveXML::DataType( "atlfast" ) );
301 
302  clusterKeyVec.push_back(DataType( "none" ));
303  clusterIndexVec.push_back(DataType( -1 ));
304  trackKeyVec.push_back(DataType( "none" ));
305  trackIndexVec.push_back(DataType( -1 ));
306  trackLinkCountVec.push_back(DataType( -1 ));
307  }
308  } // end tau iterator
309 
310  // four-vectors
311  DataMap["phi"] = phi;
312  DataMap["eta"] = eta;
313  DataMap["pt"] = pt;
314  DataMap["energy"] = energy;
315  DataMap["mass"] = mass;
316  DataMap["px"] = px;
317  DataMap["py"] = py;
318  DataMap["pz"] = pz;
319 
320  // special tau parameters
321  DataMap["isTauString"] = isTauString;
322  DataMap["label"] = label;
323  DataMap["numTracks"] = numTracks;
324  DataMap["charge"] = charge;
325  DataMap["author"] = author;
326  DataMap["etEMCalib"] = etEMCalib;
327  DataMap["etHadCalib"] = etHadCalib;
328  DataMap["emRadius"] = emRadius;
329  DataMap["isolFrac"] = isolFrac;
330  DataMap["stripWidth"] = stripWidth;
331  DataMap["logLhRatio"] = logLhRatio;
332 // DataMap["isTau"] = isTau;
333  // associations
334  DataMap["clusterKey"] = clusterKeyVec;
335  DataMap["clusterIndex"] = clusterIndexVec;
336  DataMap[trackKeyString] = trackKeyVec;
337  DataMap[trackIndexString] = trackIndexVec;
338  DataMap["trackLinkCount"] = trackLinkCountVec;
339 
340  if (msgLvl(MSG::DEBUG)) {
341  msg(MSG::DEBUG) << dataTypeName() << " retrieved with " << phi.size() << " entries"<< endmsg;
342  }
343 
344  //All collections retrieved okay
345  return DataMap;
346 
347  } // retrieve
348 
349  //--------------------------------------------------------------------------
350 
351 } // JiveXML namespace
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TauRecExtraDetails.h
TauJetParameters::TauLlhLoose
@ TauLlhLoose
Definition: TauJetParameters.h:112
TauJetRetriever.h
test_pyathena.px
px
Definition: test_pyathena.py:18
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
TauJetParameters::TauCutMedium
@ TauCutMedium
Definition: TauJetParameters.h:106
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
TauJetParameters::etEMCalib
@ etEMCalib
Definition: TauJetParameters.h:148
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
test_pyathena.pt
pt
Definition: test_pyathena.py:11
JiveXML::TauJetRetriever::m_sgKey
std::string m_sgKey
Definition: TauJetRetriever.h:53
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
JiveXML::TauJetRetriever::TauJetRetriever
TauJetRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: TauJetRetriever.cxx:30
JiveXML::TauJetRetriever::m_fastSimSGFlag
bool m_fastSimSGFlag
Definition: TauJetRetriever.h:56
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Analysis::TauJetContainer
Definition: Reconstruction/tauEvent/tauEvent/TauJetContainer.h:31
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
Tau1P3PExtraDetails.h
ParticleDataType::DataType
DataType
Definition: Event/EventKernel/EventKernel/IParticle.h:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TauJetParameters::TauCutTight
@ TauCutTight
Definition: TauJetParameters.h:107
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Tau1P3PDetails.h
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
lumiFormat.i
int i
Definition: lumiFormat.py:85
JiveXML::DataType
Templated class to convert any object that is streamable in a ostringstream in a string.
Definition: DataType.h:21
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
TauJetParameters::TauLlhMedium
@ TauLlhMedium
Definition: TauJetParameters.h:111
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ParticleDataType::Fast
@ Fast
Definition: Event/EventKernel/EventKernel/IParticle.h:36
JiveXML::TauJetRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: TauJetRetriever.cxx:44
TauJetParameters::etHadCalib
@ etHadCalib
Definition: TauJetParameters.h:147
TauJetContainer.h
TauJetParameters::emRadius
@ emRadius
Definition: TauJetParameters.h:149
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:22
JiveXML::TauJetRetriever::m_doWriteHLT
bool m_doWriteHLT
Definition: TauJetRetriever.h:54
ElementLinkVector< Rec::TrackParticleContainer >
TauPID.h
Amg::py
@ py
Definition: GeoPrimitives.h:39
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:220
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
ParticleDataType::True
@ True
Definition: Event/EventKernel/EventKernel/IParticle.h:36
charge
double charge(const T &p)
Definition: AtlasPID.h:538
JiveXML::TauJetRetriever::getData
const DataMap getData(const Analysis::TauJetContainer *)
Retrieve basic parameters, mainly four-vectors, for each collection.
Definition: TauJetRetriever.cxx:105
ElementLinkVector::at
const_reference at(size_type n) const
Definition: AthLinks/ElementLinkVector.h:307
TauCommonDetails.h
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TauRecDetails.h
ElementLinkVector::size
size_type size() const
Definition: AthLinks/ElementLinkVector.h:292
JiveXML::TauJetRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: TauJetRetriever.h:47
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:26
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
xAOD::TauJetParameters::isolFrac
@ isolFrac
Get isolation fraction.
Definition: TauDefs.h:198
TauJetParameters::TauLlhTight
@ TauLlhTight
Definition: TauJetParameters.h:110
AthAlgTool
Definition: AthAlgTool.h:26
TauJetParameters::TauCutLoose
@ TauCutLoose
Definition: TauJetParameters.h:105
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SG::ConstIterator
Definition: SGIterator.h:163
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
TrackParticleContainer.h
Generated on Thu Nov 7 2024 21:27:03 for ATLAS Offline Software by   doxygen 1.8.18