ATLAS Offline Software
xAODJetRetriever.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 "xAODJiveXML/xAODJetRetriever.h"
6 
7 #include "xAODJet/JetContainer.h"
8 #include "xAODCaloEvent/CaloCluster.h"
9 #include "xAODTracking/TrackParticle.h"
10 #include "xAODBTagging/BTagging.h"
11 #include "xAODBTagging/BTaggingUtilities.h"
12 #include "xAODJet/JetAttributes.h"
13 
14 #include "TrkTrack/Track.h"
15 #include "TrkTrack/TrackCollection.h"
16 #include "CaloEvent/CaloCellContainer.h"
17 
18 
19 #include "AthenaKernel/Units.h"
20 using Athena::Units::GeV;
21 
22 namespace JiveXML {
23 
38  xAODJetRetriever::xAODJetRetriever(const std::string& type,const std::string& name,const IInterface* parent):
39  AthAlgTool(type,name,parent), m_typeName("Jet"){
40 
41  //Only declare the interface
42  declareInterface<IDataRetriever>(this);
43 
44  //In xAOD 25Mar14:
45  // AntiKt4LCTopoJets, CamKt12LCTopoJets, AntiKt4EMTopoJets, AntiKt4TruthWZJets
46  // Kt4EMTopoJets, AntiKt10TruthWZJets, Kt4LCTopoJets, AntiKt4TruthJets
47  // CamKt12TruthJets, AntiKt10TruthJets, CamKt12TruthWZJets, AntiKt10LCTopoJets
48 
49  declareProperty("StoreGateKey", m_sgKey = "AntiKt4EMTopoJets",
50  "Collection to be first in output, shown in Atlantis without switching");
51  declareProperty("FavouriteJetCollection" ,m_sgKeyFavourite = "AntiKt4TopoEMJets" ,
52  "Collection to be first in output, shown in Atlantis without switching");
53  declareProperty("OtherJetCollections" ,m_otherKeys,
54  "Other collections to be retrieved. If list left empty, all available retrieved");
55  declareProperty("DoWriteHLT", m_doWriteHLT = false,"Ignore HLTAutokey object by default."); // ignore HLTAutoKey objects
56  declareProperty("WriteJetQuality", m_writeJetQuality = false,"Don't write extended jet quality details by default.");
57  declareProperty("TracksName", m_tracksName="InDetTrackParticles_xAOD");
58  }
59 
64  StatusCode xAODJetRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
65 
66  ATH_MSG_DEBUG( "in retrieveAll()" );
67 
68  SG::ConstIterator<xAOD::JetContainer> iterator, end;
69  const xAOD::JetContainer* Jets;
70 
71  //obtain the default collection first
72  ATH_MSG_DEBUG( "Trying to retrieve " << dataTypeName() << " (" << m_sgKeyFavourite << ")" );
73  StatusCode sc = evtStore()->retrieve(Jets, m_sgKeyFavourite);
74  if (sc.isFailure() ) {
75  ATH_MSG_WARNING( "Collection " << m_sgKeyFavourite << " not found in SG " );
76  }else{
77  DataMap data = getData(Jets);
78  if ( FormatTool->AddToEvent(dataTypeName(), m_sgKeyFavourite+"_xAOD", &data).isFailure()){
79  ATH_MSG_WARNING( "Collection " << m_sgKeyFavourite << " not found in SG " );
80  }else{
81  ATH_MSG_DEBUG( dataTypeName() << " (" << m_sgKeyFavourite << ") Jet retrieved" );
82  }
83  }
84 
85  if ( m_otherKeys.empty() ) {
86  //obtain all other collections from StoreGate
87  if (( evtStore()->retrieve(iterator, end)).isFailure()){
88  ATH_MSG_WARNING( "Unable to retrieve iterator for Jet collection" );
89  // return false;
90  }
91 
92  for (; iterator!=end; ++iterator) {
93 
94  std::string::size_type position = iterator.key().find("HLT",0);
95  if ( m_doWriteHLT ){ position = 99; } // override SG key find
96  if ( position != 0 ){ // SG key doesn't contain HLTAutoKey
97  if (iterator.key()!=m_sgKeyFavourite) {
98  ATH_MSG_DEBUG( "Trying to retrieve all " << dataTypeName() << " (" << iterator.key() << ")" );
99  DataMap data = getData(&(*iterator));
100  if ( FormatTool->AddToEvent(dataTypeName(), iterator.key()+"_xAOD", &data).isFailure()){
101  ATH_MSG_WARNING( "Collection " << iterator.key() << " not found in SG " );
102  }else{
103  ATH_MSG_DEBUG( dataTypeName() << " (" << iterator.key() << ") AODJet retrieved" );
104  }
105  }
106  }
107  }
108  }else {
109  //obtain all collections with the given keys
110  std::vector<std::string>::const_iterator keyIter;
111  for ( keyIter=m_otherKeys.begin(); keyIter!=m_otherKeys.end(); ++keyIter ){
112  if ( !evtStore()->contains<xAOD::JetContainer>( (*keyIter) ) ){ continue; } // skip if not in SG
113  StatusCode sc = evtStore()->retrieve( Jets, (*keyIter) );
114  if (!sc.isFailure()) {
115  ATH_MSG_DEBUG( "Trying to retrieve selected " << dataTypeName() << " (" << (*keyIter) << ")" );
116  DataMap data = getData(Jets);
117  if ( FormatTool->AddToEvent(dataTypeName(), (*keyIter)+"_xAOD", &data).isFailure()){
118  ATH_MSG_WARNING( "Collection " << (*keyIter) << " not found in SG " );
119  }else{
120  ATH_MSG_DEBUG( dataTypeName() << " (" << (*keyIter) << ") retrieved" );
121  }
122  }
123  }
124  }
125  //All collections retrieved okay
126  return StatusCode::SUCCESS;
127  }
128 
129 
134  const DataMap xAODJetRetriever::getData(const xAOD::JetContainer* jetCont) {
135 
136  ATH_MSG_DEBUG( "in getData()" );
137 
138  DataMap DataMap;
139 
140  DataVect et; et.reserve(jetCont->size());
141  DataVect phi; phi.reserve(jetCont->size());
142  DataVect eta; eta.reserve(jetCont->size());
143  DataVect mass; mass.reserve(jetCont->size());
144  DataVect energy; energy.reserve(jetCont->size());
145  DataVect bTagName; bTagName.reserve(jetCont->size());
146  DataVect bTagValue; bTagValue.reserve(jetCont->size());
147  //DataVect charge; energy.reserve(jetCont->size());
148  DataVect idVec; idVec.reserve(jetCont->size());
149  DataVect px; px.reserve(jetCont->size());
150  DataVect py; py.reserve(jetCont->size());
151  DataVect pz; pz.reserve(jetCont->size());
152  DataVect jvf; jvf.reserve(jetCont->size());
153  DataVect isGood; isGood.reserve(jetCont->size());
154  DataVect isBad; isBad.reserve(jetCont->size());
155  DataVect isUgly; isUgly.reserve(jetCont->size());
156  DataVect emfrac; emfrac.reserve(jetCont->size());
157 
158  DataVect clusterKey; clusterKey.reserve(jetCont->size());
159  DataVect trackKey; trackKey.reserve(jetCont->size());
160  DataVect trackContKey; trackContKey.reserve(jetCont->size());
161  DataVect trackLinkCount; trackLinkCount.reserve(jetCont->size());
162  DataVect clusterID; clusterID.reserve(jetCont->size());
163 
164  DataVect cellID; cellID.reserve(jetCont->size());
165  DataVect numCells; numCells.reserve(jetCont->size());
166 
167  int id = 0;
168 
169  xAOD::JetContainer::const_iterator jetItr = jetCont->begin();
170  xAOD::JetContainer::const_iterator jetItrE = jetCont->end();
171 
172  int counter = 0;
173  double btag1 = 0.;
174  double btag2 = 0.;
175  double btag3 = 0.;
176  for (; jetItr != jetItrE; ++jetItr) {
177  bool isCalo = false;
178  ATH_MSG_DEBUG( " Jet #" << counter++ << " : eta = " << (*jetItr)->eta() << ", phi = " << (*jetItr)->phi() << ", pt = " << (*jetItr)->pt() );
179 
180  //if rawConstituent are CaloClusters, get associated tracks, and mark jet as isCalo
181 
182  std::vector<std::string> tempCellID;
183  std::vector<float> clusterKey;
184  std::vector<int> tempTrackKey;
185  std::vector<std::string> tempTrackContKey;
186 
187  for( size_t j = 0; j < ( *jetItr )->numConstituents(); ++j ) {
188  const xAOD::CaloCluster* cluster =
189  dynamic_cast< const xAOD::CaloCluster* >(
190  ( *jetItr )->rawConstituent( j ) );
191  if( ! cluster ) {
192  ATH_MSG_VERBOSE( " Associated cluster: n/a" );
193  } else {
194 
195  isCalo=true;
196  // const xAOD::CaloClusterContainer* container = dynamic_cast< const xAOD::CaloClusterContainer* >( cluster);
197  clusterID.push_back(DataType(cluster->index()));
198 
199 
200  for (const auto cc : *(cluster->getCellLinks())) {
201  if (std::find(tempCellID.begin(), tempCellID.end(), std::to_string(cc->caloDDE()->identify().get_compact()))!=tempCellID.end()){
202  continue;}
203  else{
204  cellID.push_back(DataType(cc->caloDDE()->identify().get_compact()));
205  tempCellID.push_back(std::to_string(cc->caloDDE()->identify().get_compact()));}
206  }
207 
208 
209  ATH_MSG_VERBOSE( " Associated cluster: eta = " << cluster->eta() << ", phi = " << cluster->phi() );
210  }
211  }
212 
213 
214  numCells.push_back(DataType(tempCellID.size() ) );
215 
216  //if a calo jet try and get the ghost tracks
217  if (isCalo){
218 
219  std::vector<const xAOD::TrackParticle*> ghosttracks = (*jetItr)->getAssociatedObjects<xAOD::TrackParticle >(xAOD::JetAttribute::GhostTrack);
220 
221  if( ghosttracks.empty() ) {
222  ATH_MSG_VERBOSE( " Associated track: ERROR" );
223  trackLinkCount.push_back(DataType(0.));
224  }
225  else {
226  for (size_t i=0; i< ghosttracks.size(); i++) {
227 
228  //can access the base track class, should be able to get tracker hits?
229  // const Trk::Track* baseTrack = dynamic_cast< const Trk::Track* >( ghosttracks[i]->track());
230 
231  trackKey.push_back(DataType(ghosttracks[i]->index()));
232  trackContKey.push_back(m_tracksName);
233 
234  ATH_MSG_VERBOSE( " Associated track: d0 = "
235  << ghosttracks[i]->d0() << ", pt = "
236  << ghosttracks[i]->pt() );
237  }
238  trackLinkCount.push_back(DataType(ghosttracks.size()));
239  }
240  }
241 
242 
243  // If rawConstituents are tracks then fill those as associated tracks
244  int trackcounter =0;
245  for( size_t j = 0; j < ( *jetItr )->numConstituents(); ++j ) {
246  const xAOD::TrackParticle* track = dynamic_cast< const xAOD::TrackParticle* >( ( *jetItr )->rawConstituent( j ) );
247  if( ! track ) {
248  ATH_MSG_VERBOSE( " Associated track: ERROR" );
249  }
250  else{
251  if(!isCalo){
252  trackKey.push_back(DataType(track->index()));
253  trackContKey.push_back(m_tracksName);
254  //trackLinkCount.push_back(DataType(
255  trackcounter++;
256  ATH_MSG_VERBOSE( " Associated track: d0 = " << track->d0() << ", pt = " << track->pt() );
257  }
258  }
259  }
260  if(!isCalo){trackLinkCount.push_back(DataType(trackcounter));}
261 
262  phi.push_back(DataType((*jetItr)->phi()));
263  eta.push_back(DataType((*jetItr)->eta()));
264  et.push_back(DataType((*jetItr)->pt()/GeV)); // hack ! no et in xAOD_Jet_v1 currently
265  idVec.push_back( DataType( ++id ));
266 
267  mass.push_back(DataType((*jetItr)->m()/GeV));
268  energy.push_back( DataType((*jetItr)->e()/GeV ) );
269 
270  px.push_back(DataType((*jetItr)->px()/GeV));
271  py.push_back(DataType((*jetItr)->py()/GeV));
272  pz.push_back(DataType((*jetItr)->pz()/GeV));
273 
274  // bjet tagger values
275  const xAOD::BTagging *bTagJet = xAOD::BTaggingUtilities::getBTagging( **jetItr );
276 
277 
278  bTagName.push_back( DataType( "default" ));
279  if (bTagJet){
280  bTagJet->MVx_discriminant("MV2c10",btag1);
281  }
282  else{
283  btag1=0;}
284  // bTagJet->MVx_discriminant("MV2c10",btag1);
285  // bTagJet->MVx_discriminant("MV2c10");
286  bTagValue.push_back( btag1 );
287  bTagName.push_back(DataType( "MV2c10"));
288  bTagValue.push_back(btag1);
289  bTagName.push_back( DataType( "IP3D" ));
290  btag2 = (bTagJet) ? bTagJet->IP3D_loglikelihoodratio() : 0;
291  bTagValue.push_back( btag2 );
292  bTagName.push_back( DataType( "SV1" ));
293  btag3 = 0;
294  bTagValue.push_back( btag3 );
295 
296  ATH_MSG_VERBOSE( " Jet #" << counter << "; BTagging: MV2c10: " << btag1 << ", IP3D: " << btag2 << ", SV1: " << btag3 );
297 
298  // from AnalysisJiveXML:
299  // bTagName.push_back( DataType( "JetFitterTagNN" ));
300  // bTagValue.push_back( DataType( (*itr)->getFlavourTagWeight("JetFitterTagNN") ));
301  //
302  // code from PaulT, 16Oct14
303  /*
304  const xAOD::BTagging *btag = (*jetItr)->btagging();
305  std::cout << "btag " << btag << std::endl;
306  double mv1 = (btag) ? btag->MV1_discriminant() : 0;
307  std::cout <<"mv1 "<< mv1 << std::endl;
308  double ip3d = (btag) ? btag->IP3D_loglikelihoodratio() : 0;
309  std::cout <<"ip3d "<< ip3d << std::endl;
310  double sv1 = (btag) ? btag->SV1_loglikelihoodratio() : 0;
311  std::cout <<"sv1 "<< sv1 << std::endl;
312  */
313  //charge.push_back( DataType( (*jetItr)->charge() )); // charge not directly accessible. placeholder.
314 
315  // updated for data15
316  // from: Reconstruction/MET/METReconstruction/Root/METJetFilterTool.cxx
317  std::vector<float> jvfread;
318  (*jetItr)->getAttribute<std::vector<float> >(xAOD::JetAttribute::JVF,jvfread);
319  if(!(*jetItr)->getAttribute<std::vector<float> >(xAOD::JetAttribute::JVF,jvfread)) {
320  ATH_MSG_WARNING("Jet JVF unavailable!");
321  jvf.push_back( DataType( 1. ));
322  }else{
323  //ATH_MSG_VERBOSE("Jet JVF = " << jvfread[0]);
324  jvf.push_back( DataType( jvfread[0] ));
325  }
326 
327  isGood.push_back( DataType( -1111. )); // not anymore defined ?
329  // isBad.push_back( DataType( (*jetItr)->auxdata<float>("isBadMedium") ));
330  // isUgly.push_back( DataType( (*jetItr)->auxdata<float>("isUgly") ));
331  isBad.push_back( DataType( -1111. ));
332  isUgly.push_back( DataType( -1111. ));
333  if (isCalo){
334  float emfracread = 0;
335  if(!(*jetItr)->getAttribute(xAOD::JetAttribute::EMFrac,emfracread)) {
336  ATH_MSG_WARNING("Jet EMFrac unavailable!");
337  emfrac.push_back( DataType( 0. ));
338  }else{
339  emfrac.push_back( DataType( emfracread ));
340  }
341  }
342  else { emfrac.push_back( DataType( 0. ));
343  }
344 
345  } // end JetIterator
346 
347  // four-vectors
348  DataMap["phi"] = phi;
349  DataMap["eta"] = eta;
350  DataMap["et"] = et;
351  DataMap["energy"] = energy;
352  DataMap["mass"] = mass;
353  DataMap["bTagName multiple=\"4\""] = bTagName; // assigned by hand !
354  DataMap["bTagValue multiple=\"4\""] = bTagValue;
355  // DataMap["charge"] = charge;
356  DataMap["id"] = idVec;
357  DataMap["px"] = px;
358  DataMap["py"] = py;
359  DataMap["pz"] = pz;
360 
361  DataMap["jvf"] = jvf;
362  DataMap["isGood"] = isGood;
363  DataMap["isBad"] = isBad;
364  DataMap["isUgly"] = isUgly;
365  DataMap["emfrac"] = emfrac;
366 
367  if ((trackKey.size()) != 0){
368  double NTracksPerVertex = trackKey.size()*1./jetCont->size();
369  std::string tag = "trackIndex multiple=\"" +DataType(NTracksPerVertex).toString()+"\"";
370  DataMap[tag] = trackKey;
371  tag = "trackKey multiple=\"" +DataType(NTracksPerVertex).toString()+"\"";
372  DataMap[tag] = trackContKey;
373  }
374 
375  if ((clusterID.size())!=0){
376  std::string tag = "clusterIndex multiple=\"" + DataType(clusterID.size()).toString()+"\"";
377  double NCellsPerJet = cellID.size()*1./jetCont->size();
378  tag = "cells multiple=\"" +DataType(NCellsPerJet).toString()+"\"";
379  DataMap[tag]=cellID;
380  }
381 
382  DataMap["trackLinkCount"] = trackLinkCount;
383  DataMap["numCells"] = numCells;
384 
385  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << phi.size() << " entries" );
386 
387  //All collections retrieved okay
388  return DataMap;
389 
390  } // retrieve
391 
392  //--------------------------------------------------------------------------
393 
394 } // JiveXML namespace
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
BTaggingUtilities.h
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
et
Extra patterns decribing particle interation process.
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
test_pyathena.px
px
Definition: test_pyathena.py:18
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
BTagging.h
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
JiveXML::xAODJetRetriever::m_doWriteHLT
bool m_doWriteHLT
Definition: xAODJetRetriever.h:55
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
JetAttributes.h
test_pyathena.pt
pt
Definition: test_pyathena.py:11
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Track.h
JiveXML::xAODJetRetriever::xAODJetRetriever
xAODJetRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: xAODJetRetriever.cxx:38
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
JiveXML::xAODJetRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: xAODJetRetriever.cxx:64
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:92
CaloCluster.h
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrackCollection.h
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::JetAttribute::JVF
@ JVF
Definition: JetAttributes.h:99
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
xAOD::BTagging_v1
Definition: BTagging_v1.h:39
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
JiveXML::xAODJetRetriever::m_sgKey
std::string m_sgKey
Definition: xAODJetRetriever.h:51
xAOD::CaloCluster_v1::getCellLinks
const CaloClusterCellLink * getCellLinks() const
Get a pointer to the CaloClusterCellLink object (const version)
Definition: CaloCluster_v1.cxx:905
JiveXML::xAODJetRetriever::getData
const DataMap getData(const xAOD::JetContainer *)
Retrieve basic parameters, mainly four-vectors, for each collection.
Definition: xAODJetRetriever.cxx:134
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:21
Amg::py
@ py
Definition: GeoPrimitives.h:39
JiveXML::xAODJetRetriever::m_otherKeys
std::vector< std::string > m_otherKeys
Definition: xAODJetRetriever.h:54
JiveXML::xAODJetRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: xAODJetRetriever.h:45
xAOD::BTagging_v1::IP3D_loglikelihoodratio
float IP3D_loglikelihoodratio() const
get IP3D log likelihood ratio
Definition: BTagging_v1.h:159
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Units.h
Wrapper to avoid constant divisions when using units.
CaloCellContainer.h
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition: BTaggingUtilities.cxx:37
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrackParticle.h
DeMoScan.index
string index
Definition: DeMoScan.py:362
xAOD::TauJetParameters::numCells
@ numCells
Definition: TauDefs.h:171
xAODJetRetriever.h
JetContainer.h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
JiveXML::xAODJetRetriever::m_sgKeyFavourite
std::string m_sgKeyFavourite
Definition: xAODJetRetriever.h:52
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
AthAlgTool
Definition: AthAlgTool.h:26
test_pyathena.counter
counter
Definition: test_pyathena.py:15
xAOD::JetAttribute::GhostTrack
@ GhostTrack
Definition: JetAttributes.h:252
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
JiveXML::xAODJetRetriever::m_writeJetQuality
bool m_writeJetQuality
Definition: xAODJetRetriever.h:56
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.
python.handimod.cc
int cc
Definition: handimod.py:523
JiveXML::xAODJetRetriever::m_tracksName
std::string m_tracksName
Definition: xAODJetRetriever.h:53
xAOD::BTagging_v1::MVx_discriminant
bool MVx_discriminant(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:381
Generated on Sun Jun 30 2024 21:32:52 for ATLAS Offline Software by   doxygen 1.8.18