ATLAS Offline Software
MuonRetriever.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
7 #include "CLHEP/Units/SystemOfUnits.h"
8 
10 
11 // for associations:
13 #include "CaloEvent/CaloClusterContainer.h"
14 
15 namespace JiveXML {
16 
23  MuonRetriever::MuonRetriever(const std::string& type,const std::string& name,const IInterface* parent):
25  m_typeName("Muon"){
26 
27  //Only declare the interface
28  declareInterface<IDataRetriever>(this);
29 
30  declareProperty("StoreGateKey", m_sgKey= "Muons",
31  "Collection to be first in output, shown in Atlantis without switching");
32  }
33 
38  StatusCode MuonRetriever::retrieve(ToolHandle<IFormatTool> &FormatTool) {
39 
40  ATH_MSG_DEBUG( "in retrieveAll()" );
41 
43  const Analysis::MuonContainer* muCont;
44 
45  //obtain the default collection first
46  ATH_MSG_DEBUG( "Trying to retrieve " << dataTypeName() << " (" << m_sgKey << ")" );
47  StatusCode sc = evtStore()->retrieve(muCont, m_sgKey);
48  if (sc.isFailure() ) {
49  ATH_MSG_WARNING( "Collection " << m_sgKey << " not found in SG " );
50  }else{
51  DataMap data = getData(muCont);
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 << ") Muon 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  // hack to remove CaloMuons, jpt 31Mar10
66  if ((iterator.key() != m_sgKey) && (iterator.key() != "CaloMuonCollection") &&
67  (iterator.key() != "CaloESDMuonCollection" )) {
69  // if (iterator.key()!=m_sgKey) {
70  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Trying to retrieve all " << dataTypeName() << " (" << iterator.key() << ")" << endmsg;
72  if ( FormatTool->AddToEvent(dataTypeName(), iterator.key(), &data).isFailure()){
73  ATH_MSG_WARNING( "Collection " << iterator.key() << " not found in SG " );
74  }else{
75  ATH_MSG_DEBUG( dataTypeName() << " (" << iterator.key() << ") Muon retrieved" );
76  }
77  }
78  }
79  //All collections retrieved okay
80  return StatusCode::SUCCESS;
81  }
82 
83 
89 
90  ATH_MSG_DEBUG( "in getData()" );
91 
93 
94  DataVect phi; phi.reserve(muoncont->size());
95  DataVect eta; eta.reserve(muoncont->size());
96  DataVect pt; pt.reserve(muoncont->size());
97  DataVect mass; mass.reserve(muoncont->size());
98  DataVect energy; energy.reserve(muoncont->size());
99  DataVect px; px.reserve(muoncont->size());
100  DataVect py; py.reserve(muoncont->size());
101  DataVect pz; pz.reserve(muoncont->size());
102 
103  DataVect dataType; dataType.reserve(muoncont->size());
104  DataVect chi2; chi2.reserve(muoncont->size());
105  DataVect pdgId; pdgId.reserve(muoncont->size());
106  DataVect etConeIsol; etConeIsol.reserve(muoncont->size());
107  DataVect author; author.reserve(muoncont->size());
108 
109  // for associations:
110  DataVect clusterKeyVec; clusterKeyVec.reserve(muoncont->size());
111  DataVect clusterIndexVec; clusterIndexVec.reserve(muoncont->size());
112  DataVect trackKeyVec; trackKeyVec.reserve(muoncont->size());
113  DataVect trackIndexVec; trackIndexVec.reserve(muoncont->size());
114 
115  Analysis::MuonContainer::const_iterator muonItr = muoncont->begin();
116  Analysis::MuonContainer::const_iterator muonItrE = muoncont->end();
117 
118  int MCdataType = 1;
119  std::string clusterKey = "none"; // Storegate key of container
120  int clusterIndex = -1; // index number inside the container
121  std::string trackKey = "none"; // Storegate key of container
122  int trackIndex = -1; // index number inside the container
123 
124  for (; muonItr != muonItrE; ++muonItr) {
125  phi.emplace_back((*muonItr)->phi());
126  eta.emplace_back((*muonItr)->eta());
127  pt.emplace_back((*muonItr)->pt()/CLHEP::GeV);
128  mass.emplace_back((*muonItr)->m()/CLHEP::GeV);
129  energy.emplace_back( (*muonItr)->e()/CLHEP::GeV );
130  px.emplace_back( (*muonItr)->px()/CLHEP::GeV );
131  py.emplace_back( (*muonItr)->py()/CLHEP::GeV );
132  pz.emplace_back( (*muonItr)->pz()/CLHEP::GeV );
133 
134  pdgId.emplace_back( (*muonItr)->pdgId() );
135 
136  std::string muonAuthor = "none";
137  if (( (*muonItr)->author()) == 0){ muonAuthor = "unknown"; }
138  if (( (*muonItr)->author()) == 1){ muonAuthor = "highpt"; }
139  if (( (*muonItr)->author()) == 2){ muonAuthor = "lowpt"; }
140  author.emplace_back( muonAuthor );
141 
142  MCdataType = (*muonItr)->dataType();
143  dataType.emplace_back( MCdataType );
144 
145 // check: full simulation input file (1) or fast (0)
146 // code from:
147 // PhysicsAnalysis/AnalysisCommon/AnalysisExamples/src/MiscellaneousExamples.cxx
148  if (MCdataType != 3){ // full simulation
149  chi2.emplace_back( (*muonItr)->matchChi2OverDoF() );
150  etConeIsol.emplace_back(
151  ((*muonItr)->parameter(MuonParameters::etcone20))/CLHEP::GeV );
152 
153 // print some more variables, taken from:
154 // PhysicsAnalysis/EventViewBuilder/EventViewUserData/EVUDMuonAll
155 
156  ATH_MSG_DEBUG(
157  " Muon: matchChi2OverDoF: " << (*muonItr)->matchChi2OverDoF() <<
158  ", matchChi2: " << (*muonItr)->matchChi2() <<
159  ", fitChi2: " << (*muonItr)->fitChi2() <<
160  ", isCombined: " << (int)(*muonItr)->isCombinedMuon() );
161 
162 // parameters for associations:
163 // stricly speaking, these should be ElementLinkVectors (see TauJet association)
164 // const ElementLinkVector<Rec::TrackParticleContainer> trackLink = (*muonItr)->trackLinkVector();
165 // necessary to change ?
166 
167  const ElementLink<Rec::TrackParticleContainer> trackLink = (*muonItr)->inDetTrackLink();
168  if (trackLink.isValid()) {
169  trackKey = trackLink.dataID(); // Storegate key of
170  trackIndex = trackLink.index(); // index into the contianer
171  trackKeyVec.emplace_back( trackKey );
172  trackIndexVec.emplace_back( trackIndex );
173  } else {
174  trackKeyVec.emplace_back( "none" );
175  trackIndexVec.emplace_back( -1 );
176  }
177  const ElementLink<CaloClusterContainer> clusterLink = (*muonItr)->clusterLink();
178  if (clusterLink.isValid()) {
179  clusterKey = clusterLink.dataID(); // Storegate key of container
180  clusterIndex = clusterLink.index(); // index number inside the container
181  clusterKeyVec.emplace_back( clusterKey );
182  clusterIndexVec.emplace_back( clusterIndex );
183  } else { // no clusterLink
184  clusterKeyVec.emplace_back( "none" );
185  clusterIndexVec.emplace_back( -1 );
186  }
187 
188  } else { // fast simulation
189  chi2.emplace_back( 0 );
190  etConeIsol.emplace_back( 0 );
191  trackKeyVec.emplace_back( "none" );
192  trackIndexVec.emplace_back( -1 );
193  clusterKeyVec.emplace_back( "none");
194  clusterIndexVec.emplace_back( -1 );
195  }
196  }
197  // four-vectors
198  const auto nEntries = phi.size();
199  DataMap["phi"] = std::move(phi);
200  DataMap["eta"] = std::move(eta);
201  DataMap["pt"] = std::move(pt);
202  DataMap["energy"] = std::move(energy);
203  DataMap["mass"] = std::move(mass);
204  DataMap["px"] = std::move(px);
205  DataMap["py"] = std::move(py);
206  DataMap["pz"] = std::move(pz);
207 
208  // special muon parameters
209  DataMap["chi2"] = std::move(chi2);
210  DataMap["etConeIsol"] = std::move(etConeIsol);
211  DataMap["author"] = std::move(author);
212  DataMap["pdgId"] = std::move(pdgId);
213  DataMap["dataType"] = std::move(dataType);
214  // further details and associations
215  DataMap["clusterKey"] = std::move(clusterKeyVec);
216  DataMap["clusterIndex"] = std::move(clusterIndexVec);
217  DataMap["trackKey"] = std::move(trackKeyVec);
218  DataMap["trackIndex"] = std::move(trackIndexVec);
219 
220  ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << nEntries << " entries");
221 
222  //All collections retrieved okay
223  return DataMap;
224 
225  } // retrieve
226 
227  //--------------------------------------------------------------------------
228 
229 } // JiveXML namespace
JiveXML::MuonRetriever::m_sgKey
std::string m_sgKey
Definition: MuonRetriever.h:50
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
MuonParameters::etcone20
@ etcone20
Definition: MuonParamDefs.h:114
test_pyathena.px
px
Definition: test_pyathena.py:18
JiveXML::MuonRetriever::retrieve
virtual StatusCode retrieve(ToolHandle< IFormatTool > &FormatTool)
Retrieve all the data.
Definition: MuonRetriever.cxx:38
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
JiveXML::DataVect
std::vector< DataType > DataVect
Defines a map with a key and a vector of DataType objects e.g.
Definition: DataType.h:58
MuonContainer.h
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::DataMap
std::map< std::string, DataVect > DataMap
Definition: DataType.h:59
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
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
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
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:523
JiveXML::MuonRetriever::getData
const DataMap getData(const Analysis::MuonContainer *)
Retrieve basic parameters, mainly four-vectors, for each collection.
Definition: MuonRetriever.cxx:88
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
Analysis::MuonContainer
definition of StoreGate container holding a vector of Analysis::Muon
Definition: Reconstruction/MuonIdentification/muonEvent/muonEvent/MuonContainer.h:38
JiveXML
This header is shared inbetween the C-style server thread and the C++ Athena ServerSvc.
Definition: BadLArRetriever.cxx:22
Amg::py
@ py
Definition: GeoPrimitives.h:39
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
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
MuonRetriever.h
JiveXML::MuonRetriever::dataTypeName
virtual std::string dataTypeName() const
Return the name of the data type.
Definition: MuonRetriever.h:44
AthAlgTool
Definition: AthAlgTool.h:26
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
JiveXML::MuonRetriever::MuonRetriever
MuonRetriever(const std::string &type, const std::string &name, const IInterface *parent)
Standard Constructor.
Definition: MuonRetriever.cxx:23
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
TrackParticleContainer.h