ATLAS Offline Software
DumpEventDataToJsonAlg.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 "DumpEventDataToJsonAlg.h"
6 
7 #include <cmath>
8 #include <fstream>
9 #include <string>
10 #include <algorithm> // std::reverse
11 
12 #include "Acts/EventData/TrackContainer.hpp"
13 #include "Acts/EventData/TrackParameters.hpp"
14 #include "ActsEvent/MultiTrajectory.h"
15 #include "Gaudi/Property.h"
16 #include "GaudiKernel/Algorithm.h"
17 #include "GaudiKernel/MsgStream.h"
18 #include "GeoPrimitives/GeoPrimitivesHelpers.h"
19 #include "xAODTracking/TrackJacobianAuxContainer.h"
20 #include "xAODTracking/TrackJacobianContainer.h"
21 #include "xAODTracking/TrackMeasurementAuxContainer.h"
22 #include "xAODTracking/TrackMeasurementContainer.h"
23 #include "xAODTracking/TrackParametersAuxContainer.h"
24 #include "xAODTracking/TrackParametersContainer.h"
25 #include "xAODTracking/TrackStateAuxContainer.h"
26 #include "xAODTracking/TrackStateContainer.h"
27 #include "ActsGeometryInterfaces/ActsGeometryContext.h"
28 
29 
30 DumpEventDataToJsonAlg::DumpEventDataToJsonAlg(const std::string &name,
31  ISvcLocator *pSvcLocator)
32  : AthAlgorithm(name, pSvcLocator) {}
33 
34 StatusCode DumpEventDataToJsonAlg::initialize() {
35  ATH_CHECK(m_eventInfoKey.initialize());
36  ATH_CHECK(m_trackParticleKeys.initialize(!m_trackParticleKeys.empty()));
37  ATH_CHECK(m_jetKeys.initialize(!m_jetKeys.empty()));
38  ATH_CHECK(m_caloClustersKeys.initialize(!m_caloClustersKeys.empty()));
39  ATH_CHECK(m_caloCellKey.initialize(!m_caloCellKey.empty()));
40  ATH_CHECK(m_muonKeys.initialize(!m_muonKeys.empty()));
41  ATH_CHECK(m_tauJetKeys.initialize(!m_tauJetKeys.empty()));
42  ATH_CHECK(m_electronKeys.initialize(!m_electronKeys.empty()));
43  ATH_CHECK(m_photonKeys.initialize(!m_photonKeys.empty()));
44  ATH_CHECK(m_trackCollectionKeys.initialize(!m_trackCollectionKeys.empty()));
45 
46  // ACTS
47  ATH_CHECK(m_trackContainerKeys.initialize());
48  if (!m_cscPrepRawDataKey.empty())
49  ATH_CHECK(m_cscPrepRawDataKey.initialize());
50  if (!m_mdtPrepRawDataKey.empty())
51  ATH_CHECK(m_mdtPrepRawDataKey.initialize());
52  if (!m_tgcPrepRawDataKey.empty())
53  ATH_CHECK(m_tgcPrepRawDataKey.initialize());
54  if (!m_rpcPrepRawDataKey.empty())
55  ATH_CHECK(m_rpcPrepRawDataKey.initialize());
56  if (!m_mmPrepRawDataKey.empty())
57  ATH_CHECK(m_mmPrepRawDataKey.initialize());
58  if (!m_stgcPrepRawDataKey.empty())
59  ATH_CHECK(m_stgcPrepRawDataKey.initialize());
60  if (!m_pixelPrepRawDataKey.empty())
61  ATH_CHECK(m_pixelPrepRawDataKey.initialize());
62  if (!m_sctPrepRawDataKey.empty())
63  ATH_CHECK(m_sctPrepRawDataKey.initialize());
64  if (!m_trtPrepRawDataKey.empty())
65  ATH_CHECK(m_trtPrepRawDataKey.initialize());
66 
67  ATH_CHECK(m_extrapolator.retrieve( DisableTool{m_extrapolator.empty()} ));
68  if (m_extrapolator.empty()) {
69  ATH_MSG_WARNING("No extrapolator found. Will not be able to extrapolate tracks.");
70  } else {
71  ATH_MSG_INFO("Extrapolator found. Will be able to extrapolate tracks.");
72  }
73 
74  if (!m_geometryContextKey.empty())
75  ATH_CHECK(m_geometryContextKey.initialize());
76 
77  return StatusCode::SUCCESS;
78 }
79 
80 nlohmann::json DumpEventDataToJsonAlg::getActsData(const Acts::TrackProxy<ActsTrk::TrackSummaryContainer, ActsTrk::MultiTrajectory, ActsTrk::DataLinkHolder, true> &track, const Acts::GeometryContext& gctx) {
81  nlohmann::json data;
82 
83  // ACTS units are GeV, whilst ATLAS is MeV. So we need to convert.
84  data["dparams"] = {track.loc0(), track.loc1(), track.phi(), track.theta(), track.qOverP() * 0.001};
85  ATH_MSG_VERBOSE(" Track has dparams"<<data["dparams"][0]<<", "<<data["dparams"][1]<<", "<<data["dparams"][2]<<", "<<data["dparams"][3]<<", "<<data["dparams"][4]);
86  ATH_MSG_VERBOSE(track.referenceSurface().toString(gctx));
87 
88  // Add dparams positions to the output
89  const Acts::BoundTrackParameters trackparams(track.referenceSurface().getSharedPtr(),
90  track.parameters(), std::nullopt, Acts::ParticleHypothesis::pion());
91  auto trackPosition = trackparams.position(gctx);;
92  data["pos"].push_back(trackPosition.x());
93  data["pos"].push_back(trackPosition.y());
94  data["pos"].push_back(trackPosition.z());
95 
96  unsigned int nTrackStates = track.nTrackStates();
97  ATH_MSG_VERBOSE("Track has " << nTrackStates << " states.");
98  // Unfortunately actsTracks are stored in reverse order, so we need to do some gymnastics
99  // (There is certainly a more elegant way to do this, but since this will all be changed soon I don't think it matters)
100  std::vector<ActsTrk::MultiTrajectory::ConstTrackStateProxy> trackStates;
101  trackStates.reserve(nTrackStates);
102  for (auto trackstate : track.trackStatesReversed()) {
103  trackStates.push_back(trackstate);
104  }
105 
106  std::reverse(trackStates.begin(), trackStates.end());
107 
108  unsigned int count = 0;
109  for (auto trackstate : trackStates) {
110  // Currently only converting smoothed states, but we will extend this later.
111  if (trackstate.hasSmoothed() && trackstate.hasReferenceSurface()) {
112  const Acts::BoundTrackParameters params(trackstate.referenceSurface().getSharedPtr(),
113  trackstate.smoothed(),
114  trackstate.smoothedCovariance(),
115  Acts::ParticleHypothesis::pion());
116  ATH_MSG_VERBOSE("Track parameters: "<<params.parameters());
117 
118  auto pos = params.position(gctx);
119  data["pos"].push_back(pos.x());
120  data["pos"].push_back(pos.y());
121  data["pos"].push_back(pos.z());
122  ATH_MSG_VERBOSE("TrackState "<<count<<" has smoothed state and reference surface. Position is "<<pos.x()<<", "<<pos.y()<<", "<<pos.z());
123  ATH_MSG_VERBOSE(params.referenceSurface().toString(gctx));
124  ATH_MSG_VERBOSE("GeometryId "<<params.referenceSurface().geometryId().value());
125  } else {
126  ATH_MSG_WARNING("TrackState "<<count<<" does not have smoothed state ["<<trackstate.hasSmoothed()<<"] or reference surface ["<<trackstate.hasReferenceSurface()<<"]. Skipping.");
127  }
128  // TODO: Add measurements etc
129  count++;
130  }
131 
132  return data;
133 }
134 
135 StatusCode DumpEventDataToJsonAlg::execute() {
136  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
137  if (!eventInfo.isValid()) {
138  ATH_MSG_WARNING("Did not find xAOD::EventInfo at " << m_eventInfoKey);
139  return StatusCode::SUCCESS;
140  }
141 
142  if (m_dumpTestEvent) {
143  prependTestEvent();
144  m_dumpTestEvent = false;
145  }
146 
147  ATH_MSG_VERBOSE("Run num :" << eventInfo->runNumber()
148  << " Event num: " << eventInfo->eventNumber());
149 
150  nlohmann::json j;
151  j["event number"] = eventInfo->eventNumber();
152  j["run number"] = eventInfo->runNumber();
153 
154  ATH_CHECK(getAndFillArrayOfContainers(j, m_jetKeys, "Jets"));
155  ATH_CHECK(getAndFillArrayOfContainers(j, m_trackParticleKeys, "Tracks"));
156  ATH_CHECK(getAndFillArrayOfContainers(j, m_muonKeys, "Muons"));
157  ATH_CHECK(getAndFillArrayOfContainers(j, m_tauJetKeys, "Taus"));
158  ATH_CHECK(getAndFillArrayOfContainers(j, m_electronKeys, "Electrons"));
159  ATH_CHECK(getAndFillArrayOfContainers(j, m_photonKeys, "Photons"));
160  ATH_CHECK(getAndFillArrayOfContainers(j, m_caloClustersKeys, "CaloClusters"));
161  ATH_CHECK(getAndFillArrayOfContainers(j, m_caloCellKey, "CaloCells"));
162  ATH_CHECK(getAndFillArrayOfContainers(j, m_trackCollectionKeys, "Tracks"));
163 
164  // ACTS
165  if (!m_geometryContextKey.empty()){
166  auto tcHandles = m_trackContainerKeys.makeHandles();
167  SG::ReadHandle<ActsGeometryContext> gcx(m_geometryContextKey, Gaudi::Hive::currentContext());
168 
169  for ( SG::ReadHandle<ActsTrk::TrackContainer>& tcHandle: tcHandles ) {
170  // Temporary debugging information
171  ATH_MSG_VERBOSE("TrackStateContainer has "<< tcHandle->size() << " elements");
172 
173  ATH_MSG_VERBOSE("Trying to load " << tcHandle.key() << " with " << tcHandle->size() << " tracks");
174  const ActsTrk::TrackContainer* tc = tcHandle.get();
175  for (auto track : *tc) {
176  nlohmann::json tmp = getActsData(track, gcx->context());
177  j["TrackContainers"][tcHandle.key()].push_back(tmp);
178  }
179  }
180  }
181 
182  // hits
183  ATH_CHECK(getAndFillContainer(j, m_cscPrepRawDataKey, "Hits"));
184  ATH_CHECK(getAndFillContainer(j, m_mdtPrepRawDataKey, "Hits"));
185  ATH_CHECK(getAndFillContainer(j, m_rpcPrepRawDataKey, "Hits"));
186  ATH_CHECK(getAndFillContainer(j, m_tgcPrepRawDataKey, "Hits"));
187  ATH_CHECK(getAndFillContainer(j, m_stgcPrepRawDataKey, "Hits"));
188  ATH_CHECK(getAndFillContainer(j, m_mmPrepRawDataKey, "Hits"));
189  ATH_CHECK(getAndFillContainer(j, m_pixelPrepRawDataKey, "Hits"));
190  ATH_CHECK(getAndFillContainer(j, m_sctPrepRawDataKey, "Hits"));
191  // ATH_CHECK(getAndFillContainer(j, m_trtPrepRawDataKey, "Hits")); // Need
192  // specialisation. TODO.
193 
194  // For the moment the label is just the event/run number again, but can be
195  // manually overwritten in the output file
196  std::string label = std::to_string(eventInfo->eventNumber()) + "/" +
197  std::to_string(eventInfo->runNumber());
198  m_eventData[label] = j;
199 
200  return StatusCode::SUCCESS;
201 }
202 
203 void DumpEventDataToJsonAlg::prependTestEvent() {
204  ATH_MSG_VERBOSE("Prepending a test event.");
205  nlohmann::json j;
206 
207  // FIXME - this
208  auto writeEtaPhiLabel = [](float eta, float phi) {
209  return std::to_string(eta) + "/" + std::to_string(phi);
210  };
211 
212  j["event number"] = 999;
213  j["run number"] = 999;
214 
215  // Here we want to draw some tracks at predefined positons
216  unsigned int maxSteps = 3;
217  Amg::Vector3D trackPos;
218  float phi, eta;
219  for (unsigned int nPhi = 0; nPhi < maxSteps; ++nPhi) {
220  phi = static_cast<float>(nPhi) / static_cast<float>(maxSteps) *
221  M_PI; // Want to range from 0 to M_PI
222  for (unsigned int nEta = 0; nEta < maxSteps; ++nEta) {
223  eta = static_cast<float>(nEta) / static_cast<float>(maxSteps) *
224  3.0; // Want to range from 0 to 3.0
225 
226  // Create a calo cluster at each value
227  nlohmann::json cluster;
228  cluster["phi"] = phi;
229  cluster["eta"] = eta;
230  cluster["energy"] = 999.9;
231  cluster["label"] = writeEtaPhiLabel(eta, phi);
232 
233  j["CaloClusters"]["TestClusters"].push_back(cluster);
234 
235  // create a jet at each value
236  nlohmann::json jet;
237  jet["phi"] = phi;
238  jet["eta"] = eta;
239  jet["energy"] = 99999.9;
240  jet["label"] = writeEtaPhiLabel(eta, phi);
241  j["Jets"]["TestJets"].push_back(jet);
242 
243  nlohmann::json track;
244  track["chi2"] = 0.0;
245  track["dof"] = 0.0;
246 
247  double theta = 2 * std::atan(std::exp(-eta));
248  // d0, z0, phi, theta, qOverP
249  track["dparams"] = {0.0, 0.0, phi, theta, 0.0};
250  // Add three positions (less than this might not count as a)
251  for (unsigned int i = 0; i < 4; ++i) {
252  Amg::setRThetaPhi(trackPos, i * 1000., theta, phi);
253  track["pos"].push_back({trackPos.x(), trackPos.y(), trackPos.z()});
254  }
255  track["label"] = writeEtaPhiLabel(eta, phi);
256  j["Tracks"]["TestTracks"].push_back(track);
257  }
258  }
259  m_eventData["Test"] = j;
260 }
261 
262 template <class TYPE>
263 StatusCode DumpEventDataToJsonAlg::getAndFillArrayOfContainers(
264  nlohmann::json &event, const SG::ReadHandleKeyArray<TYPE> &keys,
265  const std::string &jsonType) {
266  for (SG::ReadHandle<TYPE> handle : keys.makeHandles()) {
267  ATH_MSG_VERBOSE("Trying to load " << handle.key());
268  ATH_CHECK(handle.isValid());
269  ATH_MSG_VERBOSE("Got back " << handle->size());
270 
271  for (auto object : *handle) {
272  nlohmann::json tmp = getData(*object);
273  event[jsonType][handle.key()].push_back(tmp);
274  }
275  }
276  return StatusCode::SUCCESS;
277 }
278 
279 // Specialisation for Jets
280 template <>
281 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::Jet &jet) {
282  nlohmann::json data;
283  data["phi"] = jet.phi();
284  data["eta"] = jet.eta();
285  data["energy"] = jet.e();
286  return data;
287 }
288 
289 // Specialisation for CaloClusters
290 template <>
291 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::CaloCluster &clust) {
292  nlohmann::json data;
293  data["phi"] = clust.phi();
294  data["eta"] = clust.eta();
295  data["energy"] = clust.e();
296  // data["etaSize"] = clust.getClusterEtaSize(); // empty
297  // data["phiSize"] = clust.getClusterPhiSize(); // empty
298  return data;
299 }
300 
301 // Specialisation for CaloCells
302 template <>
303 nlohmann::json DumpEventDataToJsonAlg::getData(const CaloCell &cell) {
304  nlohmann::json data;
305  data["phi"] = cell.phi();
306  data["eta"] = cell.eta();
307  data["energy"] = cell.e();
308  // data["etaSize"] = clust.getClusterEtaSize(); // empty
309  // data["phiSize"] = clust.getClusterPhiSize(); // empty
310  return data;
311 }
312 
313 // Specialisation for TracksParticles
314 template <>
315 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::TrackParticle &tp) {
316  nlohmann::json data;
317  data["chi2"] = tp.chiSquared();
318  data["dof"] = tp.numberDoF();
319  data["dparams"] = {tp.d0(), tp.z0(), tp.phi0(), tp.theta(), tp.qOverP()};
320 
321  if (m_physlite) {
322  ATH_MSG_VERBOSE("Physlite mode enabled. Not adding track parameters.");
323  return data;
324  }
325 
326  if (m_extrapolator.empty()) {
327  data["pos"] = {tp.perigeeParameters().position().x(),
328  tp.perigeeParameters().position().y(),
329  tp.perigeeParameters().position().z()};
330  for (unsigned int i = 0; i < tp.numberOfParameters(); ++i) {
331  data["pos"].push_back(tp.parameterX(i));
332  data["pos"].push_back(tp.parameterY(i));
333  data["pos"].push_back(tp.parameterZ(i));
334  }
335  } else {
336  std::vector<Amg::Vector3D> positions;
337  const Trk::Perigee &peri = tp.perigeeParameters();
338  positions.push_back(Amg::Vector3D(peri.position().x(), peri.position().y(),
339  peri.position().z()));
340 
341  Trk::CurvilinearParameters startParameters(peri.position(), peri.momentum(),
342  peri.charge());
343  Trk::ExtrapolationCell<Trk::TrackParameters> ecc(startParameters);
344  ecc.addConfigurationMode(Trk::ExtrapolationMode::StopAtBoundary);
345  ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectPassive);
346  ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectSensitive);
347  Trk::ExtrapolationCode eCode = m_extrapolator->extrapolate(ecc);
348  if (eCode.isSuccess()) {
349  // loop over the collected information
350  for (auto &es : ecc.extrapolationSteps) {
351 
352  // continue if we have parameters
353  const Trk::TrackParameters *parameters = es.parameters;
354  if (parameters) {
355  Amg::Vector3D pos = parameters->position();
356  positions.push_back(pos);
357  delete parameters;
358  }
359  }
360  positions.push_back(ecc.endParameters->position());
361 
362  // Now add the positions to the output
363  for (auto pos : positions) {
364  data["pos"].push_back(pos.x());
365  data["pos"].push_back(pos.y());
366  data["pos"].push_back(pos.z());
367  }
368 
369  } else {
370  ATH_MSG_WARNING(
371  "Failure in extrapolation for Track with start parameters "
372  << startParameters);
373  }
374  }
375 
376  return data;
377 }
378 
379 // Specialisation for Tracks
380 template <>
381 nlohmann::json DumpEventDataToJsonAlg::getData(const Trk::Track &track) {
382  nlohmann::json data;
383  const Trk::FitQuality *quality = track.fitQuality();
384 
385  data["chi2"] = (quality ? quality->chiSquared() : 0.0);
386  data["dof"] = (quality ? quality->doubleNumberDoF() : 0.0);
387 
388  const Trk::Perigee *peri = track.perigeeParameters();
389  if (peri) {
390  data["dparams"] = {peri->parameters()[Trk::d0], peri->parameters()[Trk::z0],
391  peri->parameters()[Trk::phi0],
392  peri->parameters()[Trk::theta],
393  peri->parameters()[Trk::qOverP]};
394 
395  } else {
396  data["pos"] = {};
397  }
398 
399  const DataVector<const Trk::TrackParameters> *parameters =
400  track.trackParameters();
401  if (parameters) {
402  for (const Trk::TrackParameters *param : *parameters) {
403  data["pos"].push_back(param->position().x());
404  data["pos"].push_back(param->position().y());
405  data["pos"].push_back(param->position().z());
406  }
407  } else {
408  const DataVector<const Trk::MeasurementBase> *measurements =
409  track.measurementsOnTrack();
410  if (measurements) {
411  for (const Trk::MeasurementBase *meas : *measurements) {
412  data["pos"].push_back(meas->globalPosition().x());
413  data["pos"].push_back(meas->globalPosition().y());
414  data["pos"].push_back(meas->globalPosition().z());
415  }
416  }
417  }
418 
419  return data;
420 }
421 
422 // Specialisation for Muons
423 template <>
424 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::Muon &muon) {
425  nlohmann::json data;
426  data["Phi"] = muon.phi();
427  data["Eta"] = muon.eta();
428 
429  std::vector<std::string> quality = {"Tight", "Medium", "Loose", "VeryLoose"};
430  data["Quality"] = quality[static_cast<unsigned int>(muon.quality())];
431  std::vector<std::string> type = {"Combined", "Standalone", "SegmentTagged",
432  "CaloTagged", "SiAssociatedForward"};
433  data["Type"] = type[static_cast<unsigned int>(muon.muonType())];
434 
435  addLink(muon.clusterLink(), data["LinkedClusters"]);
436  addLink(muon.inDetTrackParticleLink(), data["LinkedTracks"]);
437  addLink(muon.muonSpectrometerTrackParticleLink(), data["LinkedTracks"]);
438  addLink(muon.extrapolatedMuonSpectrometerTrackParticleLink(),
439  data["LinkedTracks"]);
440 
441  return data;
442 }
443 
444 // Specialisation for Tau Jets
445 template <>
446 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::TauJet &tauJet) {
447  nlohmann::json data;
448  data["phi"] = tauJet.phi();
449  data["eta"] = tauJet.eta();
450  data["energy"] = tauJet.e();
451  return data;
452 }
453 
454 // Specialisation for Electrons
455 template <>
456 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::Electron &electron) {
457  nlohmann::json data;
458  data["phi"] = electron.phi();
459  data["eta"] = electron.eta();
460  data["energy"] = electron.e();
461  addLink(electron.caloClusterLink(), data["LinkedClusters"]);
462  addLink(electron.trackParticleLink(), data["LinkedTracks"]);
463 
464  return data;
465 }
466 
467 // Specialisation for Photons
468 template <>
469 nlohmann::json DumpEventDataToJsonAlg::getData(const xAOD::Photon &photon) {
470  nlohmann::json data;
471  data["phi"] = photon.phi();
472  data["eta"] = photon.eta();
473  data["energy"] = photon.e();
474  addLink(photon.caloClusterLink(), data["LinkedClusters"]);
475 
476  return data;
477 }
478 
479 template <class TYPE>
480 void DumpEventDataToJsonAlg::addLink(const TYPE &link, nlohmann::json &data) {
481  if (link.isValid()) {
482  data.push_back(link.dataID() + ":" + std::to_string(link.index()));
483  }
484 }
485 
486 StatusCode DumpEventDataToJsonAlg::finalize() {
487  std::ofstream outputFile(m_outputJSON_Name);
488  if (!outputFile.is_open()) {
489  ATH_MSG_WARNING("Unable to open " << m_outputJSON_Name << " for writing.");
490  return StatusCode::FAILURE;
491  }
492  outputFile << m_eventData;
493  return StatusCode::SUCCESS;
494 }
495 
496 template <class TYPE>
497 StatusCode DumpEventDataToJsonAlg::getAndFillContainer(
498  nlohmann::json &event, const SG::ReadHandleKey<TYPE> &key,
499  const std::string &jsonType) {
500  if (key.empty()) {
501  return StatusCode::SUCCESS;
502  }
503  SG::ReadHandle<TYPE> handle(key);
504 
505  ATH_MSG_VERBOSE("Trying to load " << handle.key());
506  ATH_CHECK(handle.isValid());
507  ATH_MSG_VERBOSE("Which has " << handle->numberOfCollections()
508  << " collections: ");
509 
510  nlohmann::json tmp = getData(*handle);
511  if (!tmp.is_null()) {
512  ATH_MSG_VERBOSE("Writing " << jsonType << " : " << handle.key() << " with"
513  << tmp.size() << " elements:");
514  event[jsonType][handle.key()] = tmp;
515  }
516  return StatusCode::SUCCESS;
517 }
518 
519 // Generic PRD
520 template <class TYPE>
521 nlohmann::json DumpEventDataToJsonAlg::getData(const TYPE &container) {
522 
523  nlohmann::json colldata = {};
524  for (const auto &coll : container) {
525  for (const auto &prd : *coll) {
526  nlohmann::json data;
527  data["pos"] = {prd->globalPosition().x(), prd->globalPosition().y(),
528  prd->globalPosition().z()};
529  Identifier id = prd->identify();
530  data["id"] = id.get_compact();
531  colldata.push_back(data);
532  }
533  }
534 
535  return colldata;
536 }
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
DumpEventDataToJsonAlg.h
DumpEventDataToJsonAlg::initialize
virtual StatusCode initialize() override
inherited from Algorithm
Definition: DumpEventDataToJsonAlg.cxx:34
Trk::ExtrapolationMode::CollectPassive
@ CollectPassive
Definition: ExtrapolationCell.h:57
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
DumpEventDataToJsonAlg::m_geometryContextKey
SG::ReadHandleKey< ActsGeometryContext > m_geometryContextKey
Definition: DumpEventDataToJsonAlg.h:118
ActsTrk::TrackContainer
Definition: TrackContainer.h:31
Trk::ExtrapolationCell::extrapolationSteps
std::vector< ExtrapolationStep< T > > extrapolationSteps
parameters on sensitive detector elements
Definition: ExtrapolationCell.h:292
TrackStateAuxContainer.h
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
xAOD::TauJet_v3::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
json
nlohmann::json json
Definition: HistogramDef.cxx:9
ActsGeometryContext.h
DumpEventDataToJsonAlg::m_extrapolator
ToolHandle< Trk::IExtrapolationEngine > m_extrapolator
Definition: DumpEventDataToJsonAlg.h:116
Trk::ExtrapolationCell::addConfigurationMode
void addConfigurationMode(ExtrapolationMode::eMode em)
add a configuration mode
Definition: ExtrapolationCell.h:345
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
PlotCalibFromCool.label
label
Definition: PlotCalibFromCool.py:78
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
DumpEventDataToJsonAlg::m_stgcPrepRawDataKey
SG::ReadHandleKey< Muon::sTgcPrepDataContainer > m_stgcPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:111
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
DumpEventDataToJsonAlg::m_trackCollectionKeys
SG::ReadHandleKeyArray< TrackCollection > m_trackCollectionKeys
Definition: DumpEventDataToJsonAlg.h:101
DumpEventDataToJsonAlg::m_pixelPrepRawDataKey
SG::ReadHandleKey< InDet::PixelClusterContainer > m_pixelPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:112
DumpEventDataToJsonAlg::getAndFillArrayOfContainers
StatusCode getAndFillArrayOfContainers(nlohmann::json &event, const SG::ReadHandleKeyArray< TYPE > &keys, const std::string &jsonType)
Definition: DumpEventDataToJsonAlg.cxx:263
DumpEventDataToJsonAlg::m_rpcPrepRawDataKey
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_rpcPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:108
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrackParametersContainer.h
DumpEventDataToJsonAlg::m_trtPrepRawDataKey
SG::ReadHandleKey< InDet::TRT_DriftCircleContainer > m_trtPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:114
ParticleTest.tp
tp
Definition: ParticleTest.py:25
xAOD::pion
@ pion
Definition: TrackingPrimitives.h:196
Trk::z0
@ z0
Definition: ParamDefs.h:64
SG::HandleKeyArray
Definition: StoreGate/StoreGate/HandleKeyArray.h:38
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition: StoreGate/StoreGate/ReadHandleKey.h:39
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
DumpEventDataToJsonAlg::prependTestEvent
void prependTestEvent()
Dumps a dummy event with some objects at specific eta/phi coordinates for calibration.
Definition: DumpEventDataToJsonAlg.cxx:203
xAOD::TauJet_v3::e
virtual double e() const
The total energy of the particle.
Definition: TauJet_v3.cxx:88
DumpEventDataToJsonAlg::finalize
virtual StatusCode finalize() override
Definition: DumpEventDataToJsonAlg.cxx:486
DumpEventDataToJsonAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: DumpEventDataToJsonAlg.h:83
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
DumpEventDataToJsonAlg::m_trackContainerKeys
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_trackContainerKeys
Definition: DumpEventDataToJsonAlg.h:104
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
DeMoUpdate.reverse
reverse
Definition: DeMoUpdate.py:563
DumpEventDataToJsonAlg::m_tgcPrepRawDataKey
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_tgcPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:109
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
compareGeometries.outputFile
string outputFile
Definition: compareGeometries.py:25
TrackStateContainer.h
xAOD::TauJet_v3::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
DumpEventDataToJsonAlg::m_mmPrepRawDataKey
SG::ReadHandleKey< Muon::MMPrepDataContainer > m_mmPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:110
DumpEventDataToJsonAlg::m_tauJetKeys
SG::ReadHandleKeyArray< xAOD::TauJetContainer > m_tauJetKeys
Definition: DumpEventDataToJsonAlg.h:91
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
DumpEventDataToJsonAlg::m_dumpTestEvent
Gaudi::Property< bool > m_dumpTestEvent
Definition: DumpEventDataToJsonAlg.h:123
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
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:85
DumpEventDataToJsonAlg::m_jetKeys
SG::ReadHandleKeyArray< xAOD::JetContainer > m_jetKeys
Definition: DumpEventDataToJsonAlg.h:87
Trk::theta
@ theta
Definition: ParamDefs.h:66
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::ExtrapolationCode::isSuccess
bool isSuccess() const
return success
Definition: ExtrapolationCell.h:153
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
Trk::ExtrapolationCode
Definition: ExtrapolationCell.h:105
Trk::ExtrapolationCell::endParameters
T * endParameters
by pointer - are newly created and can be optionally 0
Definition: ExtrapolationCell.h:238
DumpEventDataToJsonAlg::m_outputJSON_Name
Gaudi::Property< std::string > m_outputJSON_Name
Definition: DumpEventDataToJsonAlg.h:121
DumpEventDataToJsonAlg::m_sctPrepRawDataKey
SG::ReadHandleKey< InDet::SCT_ClusterContainer > m_sctPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:113
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::ExtrapolationMode::CollectSensitive
@ CollectSensitive
Definition: ExtrapolationCell.h:56
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
Trk::ParametersBase
Definition: ParametersBase.h:55
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
DumpEventDataToJsonAlg::m_mdtPrepRawDataKey
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_mdtPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:107
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
DumpEventDataToJsonAlg::m_eventData
nlohmann::json m_eventData
Definition: DumpEventDataToJsonAlg.h:126
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TrackJacobianContainer.h
Trk::MeasurementBase
Definition: MeasurementBase.h:58
TYPE
#define TYPE(CODE, TYP, IOTYP)
DumpEventDataToJsonAlg::getAndFillContainer
StatusCode getAndFillContainer(nlohmann::json &event, const SG::ReadHandleKey< TYPE > &key, const std::string &jsonType)
Definition: DumpEventDataToJsonAlg.cxx:497
DumpEventDataToJsonAlg::execute
virtual StatusCode execute() override
Definition: DumpEventDataToJsonAlg.cxx:135
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
DumpEventDataToJsonAlg::addLink
void addLink(const TYPE &link, nlohmann::json &data)
Definition: DumpEventDataToJsonAlg.cxx:480
Trk::d0
@ d0
Definition: ParamDefs.h:63
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
DumpEventDataToJsonAlg::m_caloClustersKeys
SG::ReadHandleKeyArray< xAOD::CaloClusterContainer > m_caloClustersKeys
Definition: DumpEventDataToJsonAlg.h:97
DumpEventDataToJsonAlg::getData
nlohmann::json getData(const TYPE &object)
Definition: DumpEventDataToJsonAlg.cxx:521
DumpEventDataToJsonAlg::m_cscPrepRawDataKey
SG::ReadHandleKey< Muon::CscPrepDataContainer > m_cscPrepRawDataKey
Definition: DumpEventDataToJsonAlg.h:106
DumpEventDataToJsonAlg::m_physlite
Gaudi::Property< bool > m_physlite
Definition: DumpEventDataToJsonAlg.h:124
DumpEventDataToJsonAlg::DumpEventDataToJsonAlg
DumpEventDataToJsonAlg(const std::string &name, ISvcLocator *pService)
Algorithm constructor.
Definition: DumpEventDataToJsonAlg.cxx:30
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
xAOD::Electron_v1
Definition: Electron_v1.h:34
TrackMeasurementAuxContainer.h
DumpEventDataToJsonAlg::m_electronKeys
SG::ReadHandleKeyArray< xAOD::ElectronContainer > m_electronKeys
Definition: DumpEventDataToJsonAlg.h:93
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
MultiTrajectory.h
DumpEventDataToJsonAlg::getActsData
nlohmann::json getActsData(const Acts::TrackProxy< ActsTrk::TrackSummaryContainer, ActsTrk::MultiTrajectory, ActsTrk::DataLinkHolder, true > &track, const Acts::GeometryContext &gctx)
Definition: DumpEventDataToJsonAlg.cxx:80
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
DumpEventDataToJsonAlg::m_photonKeys
SG::ReadHandleKeyArray< xAOD::PhotonContainer > m_photonKeys
Definition: DumpEventDataToJsonAlg.h:95
Trk::ExtrapolationCell
Definition: ExtrapolationCell.h:231
xAOD::photon
@ photon
Definition: TrackingPrimitives.h:199
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
xAOD::Photon_v1
Definition: Photon_v1.h:37
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
GeoPrimitivesHelpers.h
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Amg::setRThetaPhi
void setRThetaPhi(Amg::Vector3D &v, double r, double theta, double phi)
sets radius, the theta and phi angle of a vector.
Definition: GeoPrimitivesHelpers.h:80
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
DumpEventDataToJsonAlg::m_caloCellKey
SG::ReadHandleKeyArray< CaloCellContainer > m_caloCellKey
Definition: DumpEventDataToJsonAlg.h:99
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
TrackJacobianAuxContainer.h
TrigVSI::AlgConsts::nEta
constexpr int nEta
Default bin number of eta for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:26
Trk::ExtrapolationMode::StopAtBoundary
@ StopAtBoundary
Definition: ExtrapolationCell.h:55
TrackParametersAuxContainer.h
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
Trk::phi0
@ phi0
Definition: ParamDefs.h:65
DumpEventDataToJsonAlg::m_trackParticleKeys
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_trackParticleKeys
Definition: DumpEventDataToJsonAlg.h:85
TrackMeasurementContainer.h
Trk::FitQuality::doubleNumberDoF
double doubleNumberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as double
Definition: FitQuality.h:68
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
DumpEventDataToJsonAlg::m_muonKeys
SG::ReadHandleKeyArray< xAOD::MuonContainer > m_muonKeys
Definition: DumpEventDataToJsonAlg.h:89
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:13:53 for ATLAS Offline Software by   doxygen 1.8.18