ATLAS Offline Software
ElectronRetriever.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "AnalysisJiveXML/ElectronRetriever.h"
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
9 #include "egammaEvent/ElectronContainer.h"
10 
11 // for associations:
12 #include "Particle/TrackParticleContainer.h"
13 #include "CaloEvent/CaloClusterContainer.h"
14 
15 namespace JiveXML {
16 
23  ElectronRetriever::ElectronRetriever(const std::string& type,const std::string& name,const IInterface* parent):
24  AthAlgTool(type,name,parent),
25  m_typeName("Electron"){
26 
27  //Only declare the interface
28  declareInterface<IDataRetriever>(this);
29 
30  declareProperty("StoreGateKey", m_sgKey= "ElectronAODCollection",
31  "Collection to be first in output, shown in Atlantis without switching");
32  }
33 
38  StatusCode ElectronRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
39 
40  ATH_MSG_DEBUG( "in retrieveAll()" );
41 
42  SG::ConstIterator<ElectronContainer> iterator, end;
43  const ElectronContainer* electrons;
44 
45  //obtain the default collection first
46  ATH_MSG_DEBUG( "Trying to retrieve " << dataTypeName() << " (" << m_sgKey << ")" );
47  StatusCode sc = evtStore()->retrieve(electrons, m_sgKey);
48  if (sc.isFailure() ) {
49  ATH_MSG_WARNING( "Collection " << m_sgKey << " not found in SG " );
50  }else{
51  DataMap data = getData(electrons);
52  if ( FormatTool->AddToEvent(dataTypeName(), m_sgKey, &data).isFailure()){
53  ATH_MSG_WARNING( "Collection " << m_sgKey << " not found in SG " );
54  }else{
55  ATH_MSG_DEBUG( dataTypeName() << " (" << m_sgKey << ") Electron retrieved" );
56  }
57  }
58 
59  //obtain all other collections from StoreGate
60  if (( evtStore()->retrieve(iterator, end)).isFailure()){
61  ATH_MSG_WARNING( "Unable to retrieve iterator for Jet collection" );
62  }
63 
64  for (; iterator!=end; ++iterator) {
65  if (iterator.key()!=m_sgKey) {
66  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Trying to retrieve all " << dataTypeName() << " (" << iterator.key() << ")" << endmsg;
67  DataMap data = getData(&(*iterator));
68  if ( FormatTool->AddToEvent(dataTypeName(), iterator.key(), &data).isFailure()){
69  ATH_MSG_WARNING("Collection " << iterator.key() << " not found in SG ");
70  }else{
71  ATH_MSG_DEBUG( dataTypeName() << " (" << iterator.key() << ") Electron retrieved" );
72  }
73  }
74  }
75  //All collections retrieved okay
76  return StatusCode::SUCCESS;
77  }
78 
79 
84  const DataMap ElectronRetriever::getData(const ElectronContainer* elCont) {
85 
86  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "in getData()" << endmsg;
87 
88  DataMap DataMap;
89  const auto nElectrons = elCont->size();
90  DataVect pt; pt.reserve(nElectrons);
91  DataVect phi; phi.reserve(nElectrons);
92  DataVect eta; eta.reserve(nElectrons);
93  DataVect mass; mass.reserve(nElectrons);
94  DataVect energy; energy.reserve(nElectrons);
95  DataVect px; px.reserve(nElectrons);
96  DataVect py; py.reserve(nElectrons);
97  DataVect pz; pz.reserve(nElectrons);
98 
99  DataVect eOverp; eOverp.reserve(nElectrons);
100  DataVect isEM; isEM.reserve(nElectrons);
101  DataVect isEMString; isEMString.reserve(nElectrons);
102  DataVect hasTrack; hasTrack.reserve(nElectrons);
103  DataVect author; author.reserve(nElectrons);
104  DataVect label; label.reserve(nElectrons);
105 
106  DataVect pdgId; pdgId.reserve(nElectrons);
107  DataVect dataType; dataType.reserve(nElectrons);
108  DataVect hitsBLayer; hitsBLayer.reserve(nElectrons);
109  DataVect hitsPixel; hitsPixel.reserve(nElectrons);
110  DataVect hitsSCT; hitsSCT.reserve(nElectrons);
111  DataVect hitsTRT; hitsTRT.reserve(nElectrons);
112 
113  // for associations:
114  DataVect clusterKeyVec; clusterKeyVec.reserve(nElectrons);
115  DataVect clusterIndexVec; clusterIndexVec.reserve(nElectrons);
116  DataVect trackKeyVec; trackKeyVec.reserve(nElectrons);
117  DataVect trackIndexVec; trackIndexVec.reserve(nElectrons);
118 
119  ElectronContainer::const_iterator elItr = elCont->begin();
120  ElectronContainer::const_iterator elItrE = elCont->end();
121 
122  int MCdataType = 1;
123 
124 // isEM from
125 // https://uimon.cern.ch/twiki/bin/view/Atlas/RemoveOverlap
126 
127  double ep = 0., p=0., e=0.; // for eOverP calculation from track
128  //int counter = 0;
129  std::string electronAuthor = "";
130  std::string electronIsEMString = "none";
131  std::string electronLabel = "";
132 
133  for (; elItr != elItrE; ++elItr) {
134  electronIsEMString = "none";
135  phi.emplace_back((*elItr)->phi());
136  eta.emplace_back((*elItr)->eta());
137  pt.emplace_back((*elItr)->pt()/CLHEP::GeV);
138 
139  mass.emplace_back((*elItr)->m()/CLHEP::GeV);
140  energy.emplace_back( (*elItr)->e()/CLHEP::GeV );
141  px.emplace_back( (*elItr)->px()/CLHEP::GeV );
142  py.emplace_back( (*elItr)->py()/CLHEP::GeV );
143  pz.emplace_back( (*elItr)->pz()/CLHEP::GeV );
144 
145  pdgId.emplace_back( (*elItr)->pdgId() );
146 
147  electronAuthor = "author"+DataType( (*elItr)->author() ).toString(); // for odd ones eg FWD
148  electronLabel = electronAuthor;
149  if (( (*elItr)->author()) == 0){ electronAuthor = "unknown"; electronLabel += "_unknown"; }
150  if (( (*elItr)->author()) == 8){ electronAuthor = "forward"; electronLabel += "_forward"; }
151  if (( (*elItr)->author()) == 2){ electronAuthor = "softe"; electronLabel += "_softe"; }
152  if (( (*elItr)->author()) == 1){ electronAuthor = "egamma"; electronLabel += "_egamma"; }
153 
154  // Tight but without the use of isolation criteria:
155  // code from https://twiki.cern.ch/twiki/bin/view/Atlas/ElectronReconstruction#isEM_flag
156  // New PP Ids: PhysicsAnalysis/D3PDMaker/TrigEgammaD3PDMaker/python/EFElectronD3PDObject.py
157 
158  if ( (*elItr)->isem(egammaPIDObs::ElectronLoose)==0){
159  electronLabel += "_Loose";
160  electronIsEMString = "Loose"; // assume that hierarchy is obeyed !
161  }
162  if ( (*elItr)->isem(egammaPIDObs::ElectronMedium)==0){
163  electronLabel += "_Medium";
164  electronIsEMString = "Medium"; // assume that hierarchy is obeyed !
165  }
166  if ( (*elItr)->isem(egammaPIDObs::ElectronTight)==0){
167  electronLabel += "_Tight";
168  electronIsEMString = "Tight"; // assume that hierarchy is obeyed !
169  }
170  if ( (*elItr)->isem(egammaPIDObs::ElectronTightPP)==0){
171  electronLabel += "_TightPP";
172  electronIsEMString = "TightPP"; // last entry overwrites all others !
173  }
174  if ( (*elItr)->isem(egammaPIDObs::ElectronMediumPP)==0){
175  electronLabel += "_MediumPP";
176 // electronIsEMString = "MediumNoIso"; // would need AtlantisJava changes
177  }
178 
179  if ( (*elItr)->isem(egammaPIDObs::ElectronMediumNoIso)==0){
180  electronLabel += "_MediumNoIso";
181 // electronIsEMString = "MediumNoIso"; // would need AtlantisJava changes
182  }
183  if ( (*elItr)->isem(egammaPIDObs::ElectronTightTRTNoIso)==0){
184  electronLabel += "_TightTRTNoIso";
185 // electronIsEMString = "TightTRTNoIso"; // would need AtlantisJava changes
186  }
187  // Tight but without the use of isolation criteria:
188  if ( (*elItr)->isem(egammaPIDObs::ElectronTightNoIsolation)==0){
189  electronLabel += "_TightNoIsolation";
190 // electronIsEMString = "_TightNoIsolation"; // would need AtlantisJava changes
191  }
192  MCdataType = (*elItr)->dataType();
193  dataType.emplace_back( MCdataType );
194 
195 // check: full simulation input file (1) or fast (0)
196 // code from:
197 // PhysicsAnalysis/AnalysisCommon/AnalysisExamples/src/MiscellaneousExamples.cxx
198 
199  if (MCdataType != 3){ // full simulation
200 
201  isEM.emplace_back( (**elItr).isem() );
202 
203  const Trk::TrackSummary *summary;
204  bool elecTrack = (*elItr)->trackParticle();
205  if ( elecTrack ){
206 
207 // eOperp calculation from: Reconstruction/egamma/egammaRec/egammaAODBuilder.cxx,
208 // advised by Frederic Derue 16Mar09
209 // Old version with eOverP from EMTrackMatch is unreliable.
210 
211  ep = 0.;
212  p = (*elItr)->trackParticle()->p();
213  e = (*elItr)->e();
214  ep = p>0. ? e/p : 0.;
215  eOverp.emplace_back( ep );
216 
217  summary = (*elItr)->trackParticle()->trackSummary();
218  hasTrack.emplace_back( 1 );
219  hitsBLayer.emplace_back( summary->get(Trk::numberOfInnermostPixelLayerHits) );
220  hitsPixel.emplace_back( summary->get(Trk::numberOfPixelHits) );
221  hitsSCT.emplace_back( summary->get(Trk::numberOfSCTHits) );
222  hitsTRT.emplace_back( summary->get(Trk::numberOfTRTHits) );
223  } else {
224  eOverp.emplace_back( DataType( "0." ));
225  hasTrack.emplace_back( 0 );
226  hitsBLayer.emplace_back( -1 );
227  hitsPixel.emplace_back( -1 );
228  hitsSCT.emplace_back( -1 );
229  hitsTRT.emplace_back( -1 );
230  }
231 
232 // code from:
233 // PhysicsAnalysis/AnalysisCommon/AnalysisExamples/src/MiscellaneousExamples.cxx
234 
235 // parameters for associations: Storegate key and Index
236 
237  const ElementLink<CaloClusterContainer> clusterLink = (*elItr)->clusterElementLink();
238  if (clusterLink.isValid()) {
239  std::string clusterKey = clusterLink.dataID(); // Storegate key of
240  int clusterIndex = clusterLink.index(); // index into the contianer
241 
242 
243  clusterKeyVec.emplace_back( clusterKey );
244  clusterIndexVec.emplace_back( clusterIndex );
245  } else { // no clusterLink
246  clusterKeyVec.emplace_back( "none" );
247  clusterIndexVec.emplace_back( -1 );
248  }
249 
250  const ElementLink<Rec::TrackParticleContainer> trackLink = (*elItr)->trackParticleElementLink();
251  if (trackLink.isValid()) {
252  std::string trackKey = trackLink.dataID(); // Storegate key of
253  int trackIndex = trackLink.index(); // index into the contianer
254 
255 
256  trackKeyVec.emplace_back( trackKey );
257  trackIndexVec.emplace_back( trackIndex);
258  } else { // no trackLink
259  trackKeyVec.emplace_back( "none" );
260  trackIndexVec.emplace_back( -1 );
261  }
262 
263  //counter++;
264 
265 // end of associations data
266 
267  } else { // fast simulation: placeholders
268  hasTrack.emplace_back( 1 );
269  eOverp.emplace_back( 1. );
270  isEM.emplace_back( 0 );
271  electronIsEMString += "fastSim";
272  electronLabel += "fastSim" ;
273  hitsBLayer.emplace_back( 0 );
274  hitsPixel.emplace_back( 0 );
275  hitsSCT.emplace_back( 0 );
276  hitsTRT.emplace_back( 0 );
277 
278  clusterKeyVec.emplace_back( "none" );
279  clusterIndexVec.emplace_back( -1 );
280  trackKeyVec.emplace_back( "none" );
281  trackIndexVec.emplace_back( -1 );
282  } // end datatype case
283 
284  author.emplace_back( electronAuthor );
285  label.emplace_back( electronLabel );
286  isEMString.emplace_back( electronIsEMString );
287  } // end ElectronIterator
288 
289  // four-vectors
290  const auto nEntries = phi.size();
291  DataMap["phi"] = std::move(phi);
292  DataMap["eta"] = std::move(eta);
293  DataMap["pt"] = std::move(pt);
294  DataMap["energy"] = std::move(energy);
295  DataMap["mass"] = std::move(mass);
296  DataMap["px"] = std::move(px);
297  DataMap["py"] = std::move(py);
298  DataMap["pz"] = std::move(pz);
299 
300  // special Electron parameters
301  DataMap["eOverp"] = std::move(eOverp);
302  DataMap["isEM"] = std::move(isEM);
303  DataMap["isEMString"] = std::move(isEMString);
304  DataMap["label"] = std::move(label);
305  DataMap["hasTrack"] = std::move(hasTrack);
306  DataMap["author"] = std::move(author);
307  DataMap["pdgId"] = std::move(pdgId);
308  DataMap["dataType"] = std::move(dataType);
309  DataMap["hitsBLayer"] = std::move(hitsBLayer);
310  DataMap["hitsPixel"] = std::move(hitsPixel);
311  DataMap["hitsSCT"] = std::move(hitsSCT);
312  DataMap["hitsTRT"] = std::move(hitsTRT);
313 
314  // associations
315  DataMap["clusterKey"] = std::move(clusterKeyVec);
316  DataMap["clusterIndex"] = std::move(clusterIndexVec);
317  DataMap["trackKey"] = std::move(trackKeyVec);
318  DataMap["trackIndex"] = std::move(trackIndexVec);
319 
320  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << nEntries << " entries");
321 
322  //All collections retrieved okay
323  return DataMap;
324 
325  } // retrieve
326 
327  //--------------------------------------------------------------------------
328 
329 } // JiveXML namespace
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
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
ElectronContainer.h
egammaPIDObs::ElectronMediumPP
const unsigned int ElectronMediumPP
Medium++ electron selecton.
Definition: egammaPIDdefsObs.h:378
JiveXML::ElectronRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: ElectronRetriever.cxx:38
test_pyathena.px
px
Definition: test_pyathena.py:18
JiveXML::ElectronRetriever::ElectronRetriever
ElectronRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: ElectronRetriever.cxx:23
Trk::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 1st pixel layer
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:53
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
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
DataType
OFFLINE_FRAGMENTS_NAMESPACE::PointerType DataType
Definition: RoIBResultByteStreamTool.cxx:25
test_pyathena.pt
pt
Definition: test_pyathena.py:11
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
JiveXML::ElectronRetriever::getData
const DataMap getData(const ElectronContainer *)
Retrieve basic parameters, mainly four-vectors, for each collection.
Definition: ElectronRetriever.cxx:84
JiveXML::ElectronRetriever::m_sgKey
std::string m_sgKey
Definition: ElectronRetriever.h:53
JiveXML::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
egammaPIDObs::ElectronTightNoIsolation
const unsigned int ElectronTightNoIsolation
obsolete - kept not to crash clients
Definition: egammaPIDdefsObs.h:798
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
egammaPIDObs::ElectronMediumNoIso
const unsigned int ElectronMediumNoIso
obsolete - kept not crash clients
Definition: egammaPIDdefsObs.h:793
egammaPIDObs::ElectronLoose
const unsigned int ElectronLoose
Loose electron selection.
Definition: egammaPIDdefsObs.h:407
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
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
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
JiveXML::ElectronRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: ElectronRetriever.h:47
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ElectronRetriever.h
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:22
Trk::numberOfTRTHits
@ numberOfTRTHits
number of TRT outliers
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:79
Amg::py
@ py
Definition: GeoPrimitives.h:39
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
egammaPIDObs::ElectronMedium
const unsigned int ElectronMedium
Medium electron selecton.
Definition: egammaPIDdefsObs.h:430
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
egammaPIDObs::ElectronTightPP
const unsigned int ElectronTightPP
Tight++ electron selecton.
Definition: egammaPIDdefsObs.h:390
ElectronContainer
Definition: Reconstruction/egamma/egammaEvent/egammaEvent/ElectronContainer.h:32
AthAlgTool
Definition: AthAlgTool.h:26
egammaPIDObs::ElectronTightTRTNoIso
const unsigned int ElectronTightTRTNoIso
obsolete - kept not to crash clients
Definition: egammaPIDdefsObs.h:796
dqBeamSpot.nEntries
int nEntries
Definition: dqBeamSpot.py:73
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SG::ConstIterator
Definition: SGIterator.h:163
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
egammaPIDObs::ElectronTight
const unsigned int ElectronTight
Tight electron selection.
Definition: egammaPIDdefsObs.h:475
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
TrackParticleContainer.h
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Thu Nov 7 2024 21:14:24 for ATLAS Offline Software by   doxygen 1.8.18