CMS 3D CMS Logo
List of all members | Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes
MuonAssociatorByHitsHelper Class Reference

#include <MuonAssociatorByHitsHelper.h>

Classes

struct  IndexMatch
 
struct  Resources
 

Public Types

typedef std::map< size_t, std::vector< IndexMatch > > IndexAssociation
 
typedef boost::ptr_vector< uint_SimHitIdpr_pair > MapOfMatchedIds
 
typedef std::pair< uint32_t, EncodedEventId > SimHitIdpr
 
typedef std::vector< std::pair< trackingRecHit_iterator, trackingRecHit_iterator > > TrackHitsCollection
 
typedef std::pair< unsigned int, std::vector< SimHitIdpr > > uint_SimHitIdpr_pair
 

Public Member Functions

IndexAssociation associateRecoToSimIndices (const TrackHitsCollection &, const edm::RefVector< TrackingParticleCollection > &, Resources const &) const
 
IndexAssociation associateSimToRecoIndices (const TrackHitsCollection &, const edm::RefVector< TrackingParticleCollection > &, Resources const &) const
 
 MuonAssociatorByHitsHelper (const edm::ParameterSet &conf)
 

Private Member Functions

const TrackingRecHit * getHitPtr (edm::OwnVector< TrackingRecHit >::const_iterator iter) const
 
const TrackingRecHit * getHitPtr (const trackingRecHit_iterator &iter) const
 
void getMatchedIds (MapOfMatchedIds &tracker_matchedIds_valid, MapOfMatchedIds &muon_matchedIds_valid, MapOfMatchedIds &tracker_matchedIds_INVALID, MapOfMatchedIds &muon_matchedIds_INVALID, int &n_tracker_valid, int &n_dt_valid, int &n_csc_valid, int &n_rpc_valid, int &n_gem_valid, int &n_tracker_matched_valid, int &n_dt_matched_valid, int &n_csc_matched_valid, int &n_rpc_matched_valid, int &n_gem_matched_valid, int &n_tracker_INVALID, int &n_dt_INVALID, int &n_csc_INVALID, int &n_rpc_INVALID, int &n_gem_INVALID, int &n_tracker_matched_INVALID, int &n_dt_matched_INVALID, int &n_csc_matched_INVALID, int &n_rpc_matched_INVALID, int &n_gem_matched_INVALID, trackingRecHit_iterator begin, trackingRecHit_iterator end, const TrackerHitAssociator *trackertruth, const DTHitAssociator &dttruth, const CSCHitAssociator &csctruth, const RPCHitAssociator &rpctruth, const GEMHitAssociator &gemtruth, bool printRts, const TrackerTopology *) const
 
int getShared (MapOfMatchedIds &matchedIds, TrackingParticleCollection::const_iterator trpart) const
 
int LayerFromDetid (const DetId &) const
 
std::string write_matched_simtracks (const std::vector< SimHitIdpr > &) const
 

Private Attributes

const bool AbsoluteNumberOfHits_muon
 
const bool AbsoluteNumberOfHits_track
 
const bool acceptOneStubMatchings
 
const bool dumpDT
 
double EfficiencyCut_muon
 
double EfficiencyCut_track
 
const bool includeZeroHitMuons
 
unsigned int NHitCut_muon
 
unsigned int NHitCut_track
 
double PurityCut_muon
 
double PurityCut_track
 
const bool ThreeHitTracksAreSpecial
 
const bool UseGrouped
 
bool UseMuon
 
const bool UsePixels
 
const bool UseSplitting
 
bool UseTracker
 

Detailed Description

Definition at line 27 of file MuonAssociatorByHitsHelper.h.

Member Typedef Documentation

typedef std::map<size_t, std::vector<IndexMatch> > MuonAssociatorByHitsHelper::IndexAssociation

Definition at line 54 of file MuonAssociatorByHitsHelper.h.

typedef boost::ptr_vector<uint_SimHitIdpr_pair> MuonAssociatorByHitsHelper::MapOfMatchedIds

Definition at line 33 of file MuonAssociatorByHitsHelper.h.

typedef std::pair<uint32_t, EncodedEventId> MuonAssociatorByHitsHelper::SimHitIdpr

Definition at line 30 of file MuonAssociatorByHitsHelper.h.

typedef std::vector<std::pair<trackingRecHit_iterator, trackingRecHit_iterator> > MuonAssociatorByHitsHelper::TrackHitsCollection

Definition at line 34 of file MuonAssociatorByHitsHelper.h.

typedef std::pair<unsigned int,std::vector<SimHitIdpr> > MuonAssociatorByHitsHelper::uint_SimHitIdpr_pair

Definition at line 32 of file MuonAssociatorByHitsHelper.h.

Constructor & Destructor Documentation

MuonAssociatorByHitsHelper::MuonAssociatorByHitsHelper ( const edm::ParameterSet &  conf)

Definition at line 17 of file MuonAssociatorByHitsHelper.cc.

References edm::ParameterSet::dump(), EfficiencyCut_muon, includeZeroHitMuons, NHitCut_muon, PurityCut_muon, UseMuon, and UseTracker.

17  :
18  includeZeroHitMuons(conf.getParameter<bool>("includeZeroHitMuons")),
19  acceptOneStubMatchings(conf.getParameter<bool>("acceptOneStubMatchings")),
20  UseTracker(conf.getParameter<bool>("UseTracker")),
21  UseMuon(conf.getParameter<bool>("UseMuon")),
22  AbsoluteNumberOfHits_track(conf.getParameter<bool>("AbsoluteNumberOfHits_track")),
23  NHitCut_track(conf.getParameter<unsigned int>("NHitCut_track")),
24  EfficiencyCut_track(conf.getParameter<double>("EfficiencyCut_track")),
25  PurityCut_track(conf.getParameter<double>("PurityCut_track")),
26  AbsoluteNumberOfHits_muon(conf.getParameter<bool>("AbsoluteNumberOfHits_muon")),
27  NHitCut_muon(conf.getParameter<unsigned int>("NHitCut_muon")),
28  EfficiencyCut_muon(conf.getParameter<double>("EfficiencyCut_muon")),
29  PurityCut_muon(conf.getParameter<double>("PurityCut_muon")),
30  UsePixels(conf.getParameter<bool>("UsePixels")),
31  UseGrouped(conf.getParameter<bool>("UseGrouped")),
32  UseSplitting(conf.getParameter<bool>("UseSplitting")),
33  ThreeHitTracksAreSpecial(conf.getParameter<bool>("ThreeHitTracksAreSpecial")),
34  dumpDT(conf.getParameter<bool>("dumpDT"))
35 {
36  edm::LogVerbatim("MuonAssociatorByHitsHelper") << "constructing MuonAssociatorByHitsHelper" << conf.dump();
37 
38  // up to the user in the other cases - print a message
39  if (UseTracker) edm::LogVerbatim("MuonAssociatorByHitsHelper")<<"\n UseTracker = TRUE : Tracker SimHits and RecHits WILL be counted";
40  else edm::LogVerbatim("MuonAssociatorByHitsHelper") <<"\n UseTracker = FALSE : Tracker SimHits and RecHits WILL NOT be counted";
41 
42  // up to the user in the other cases - print a message
43  if (UseMuon) edm::LogVerbatim("MuonAssociatorByHitsHelper")<<" UseMuon = TRUE : Muon SimHits and RecHits WILL be counted";
44  else edm::LogVerbatim("MuonAssociatorByHitsHelper") <<" UseMuon = FALSE : Muon SimHits and RecHits WILL NOT be counted"<<endl;
45 
46  // check consistency of the configuration when allowing zero-hit muon matching (counting invalid hits)
47  if (includeZeroHitMuons) {
48  edm::LogVerbatim("MuonAssociatorByHitsHelper")
49  <<"\n includeZeroHitMuons = TRUE"
50  <<"\n ==> (re)set NHitCut_muon = 0, PurityCut_muon = 0, EfficiencyCut_muon = 0"<<endl;
51  NHitCut_muon = 0;
52  PurityCut_muon = 0.;
53  EfficiencyCut_muon = 0.;
54  }
55 
56 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::dump
std::string dump(unsigned int indent=0) const
Definition: ParameterSet.cc:924

Member Function Documentation

MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associateRecoToSimIndices ( const TrackHitsCollection &  ,
const edm::RefVector< TrackingParticleCollection > &  ,
Resources const &   
) const

Definition at line 59 of file MuonAssociatorByHitsHelper.cc.

References AbsoluteNumberOfHits_muon, AbsoluteNumberOfHits_track, acceptOneStubMatchings, MuonAssociatorByHitsHelper::Resources::cscHitAssoc_, MuonAssociatorByHitsHelper::Resources::diagnostics_, MuonAssociatorByHitsHelper::Resources::dtHitAssoc_, MuonAssociatorByHitsHelper::Resources::gemHitAssoc_, getMatchedIds(), getShared(), includeZeroHitMuons, NHitCut_muon, NHitCut_track, PurityCut_muon, PurityCut_track, MuonAssociatorByHitsHelper::Resources::rpcHitAssoc_, edm::RefVector< C, T, F >::size(), AlCaHLTBitMon_QueryRunRegistry::string, ThreeHitTracksAreSpecial, HiIsolationCommonParameters_cff::track, MuonAssociatorByHitsHelper::Resources::trackerHitAssoc_, and MuonAssociatorByHitsHelper::Resources::tTopo_.

Referenced by MuonToSimAssociatorByHits::associateMuons(), MuonToTrackingParticleAssociatorByHitsImpl::associateMuons(), and MuonAssociatorByHits::associateRecoToSim().

61  {
62 
63  auto tTopo = resources.tTopo_;
64  auto trackertruth = resources.trackerHitAssoc_;
65  auto const & csctruth = *resources.cscHitAssoc_;
66  auto const& dttruth = *resources.dtHitAssoc_;
67  auto const& rpctruth = *resources.rpcHitAssoc_;
68  auto const& gemtruth = *resources.gemHitAssoc_;
69 
70  int tracker_nshared = 0;
71  int muon_nshared = 0;
72  int global_nshared = 0;
73 
74  double tracker_quality = 0;
75  double tracker_quality_cut;
76  if (AbsoluteNumberOfHits_track) tracker_quality_cut = static_cast<double>(NHitCut_track);
77  else tracker_quality_cut = PurityCut_track;
78 
79  double muon_quality = 0;
80  double muon_quality_cut;
81  if (AbsoluteNumberOfHits_muon) muon_quality_cut = static_cast<double>(NHitCut_muon);
82  else muon_quality_cut = PurityCut_muon;
83 
84  double global_quality = 0;
85 
86  MapOfMatchedIds tracker_matchedIds_valid, muon_matchedIds_valid;
87  MapOfMatchedIds tracker_matchedIds_INVALID, muon_matchedIds_INVALID;
88 
89  IndexAssociation outputCollection;
90  bool printRtS(true);
91 
92  TrackingParticleCollection tPC;
93  tPC.reserve(TPCollectionH.size());
94  for(auto const& ref: TPCollectionH) {
95  tPC.push_back(*ref);
96  }
97 
98  if(resources.diagnostics_) {
99  resources.diagnostics_(tC,tPC);
100  }
101 
102  int tindex=0;
103  for (TrackHitsCollection::const_iterator track=tC.begin(); track!=tC.end(); track++, tindex++) {
104  edm::LogVerbatim("MuonAssociatorByHitsHelper")
105  <<"\n"<<"reco::Track "<<tindex
106  <<", number of RecHits = "<< (track->second - track->first) << "\n";
107  tracker_matchedIds_valid.clear();
108  muon_matchedIds_valid.clear();
109 
110  tracker_matchedIds_INVALID.clear();
111  muon_matchedIds_INVALID.clear();
112 
113  bool this_track_matched = false;
114  int n_matching_simhits = 0;
115 
116  // all hits = valid +INVALID
117  int n_all = 0;
118  int n_tracker_all = 0;
119  int n_dt_all = 0;
120  int n_csc_all = 0;
121  int n_rpc_all = 0;
122  int n_gem_all = 0;
123 
124  int n_valid = 0;
125  int n_tracker_valid = 0;
126  int n_muon_valid = 0;
127  int n_dt_valid = 0;
128  int n_csc_valid = 0;
129  int n_rpc_valid = 0;
130  int n_gem_valid = 0;
131 
132  int n_tracker_matched_valid = 0;
133  int n_muon_matched_valid = 0;
134  int n_dt_matched_valid = 0;
135  int n_csc_matched_valid = 0;
136  int n_rpc_matched_valid = 0;
137  int n_gem_matched_valid = 0;
138 
139  int n_INVALID = 0;
140  int n_tracker_INVALID = 0;
141  int n_muon_INVALID = 0;
142  int n_dt_INVALID = 0;
143  int n_csc_INVALID = 0;
144  int n_rpc_INVALID = 0;
145  int n_gem_INVALID = 0;
146 
147  int n_tracker_matched_INVALID = 0;
148  int n_muon_matched_INVALID = 0;
149  int n_dt_matched_INVALID = 0;
150  int n_csc_matched_INVALID = 0;
151  int n_rpc_matched_INVALID = 0;
152  int n_gem_matched_INVALID = 0;
153 
154  printRtS = true;
155  getMatchedIds(tracker_matchedIds_valid, muon_matchedIds_valid,
156  tracker_matchedIds_INVALID, muon_matchedIds_INVALID,
157  n_tracker_valid, n_dt_valid, n_csc_valid, n_rpc_valid, n_gem_valid,
158  n_tracker_matched_valid, n_dt_matched_valid, n_csc_matched_valid, n_rpc_matched_valid, n_gem_matched_valid,
159  n_tracker_INVALID, n_dt_INVALID, n_csc_INVALID, n_rpc_INVALID, n_gem_INVALID,
160  n_tracker_matched_INVALID, n_dt_matched_INVALID, n_csc_matched_INVALID, n_rpc_matched_INVALID, n_gem_matched_INVALID,
161  track->first, track->second,
162  trackertruth, dttruth, csctruth, rpctruth, gemtruth,
163  printRtS,tTopo);
164 
165  n_matching_simhits = tracker_matchedIds_valid.size() + muon_matchedIds_valid.size() +
166  tracker_matchedIds_INVALID.size() +muon_matchedIds_INVALID.size();
167 
168  n_muon_valid = n_dt_valid + n_csc_valid + n_rpc_valid + n_gem_valid;
169  n_valid = n_tracker_valid + n_muon_valid;
170  n_muon_INVALID = n_dt_INVALID + n_csc_INVALID + n_rpc_INVALID + n_gem_INVALID;
171  n_INVALID = n_tracker_INVALID + n_muon_INVALID;
172 
173  // all used hits (valid+INVALID), defined by UseTracker, UseMuon
174  n_tracker_all = n_tracker_valid + n_tracker_INVALID;
175  n_dt_all = n_dt_valid + n_dt_INVALID;
176  n_csc_all = n_csc_valid + n_csc_INVALID;
177  n_rpc_all = n_rpc_valid + n_rpc_INVALID;
178  n_gem_all = n_gem_valid + n_gem_INVALID;
179  n_all = n_valid + n_INVALID;
180 
181  n_muon_matched_valid = n_dt_matched_valid + n_csc_matched_valid + n_rpc_matched_valid + n_gem_matched_valid;
182  n_muon_matched_INVALID = n_dt_matched_INVALID + n_csc_matched_INVALID + n_rpc_matched_INVALID + n_gem_matched_INVALID;
183 
184  // selected hits are set initially to valid hits
185  int n_tracker_selected_hits = n_tracker_valid;
186  int n_muon_selected_hits = n_muon_valid;
187  int n_dt_selected_hits = n_dt_valid;
188  int n_csc_selected_hits = n_csc_valid;
189  int n_rpc_selected_hits = n_rpc_valid;
190  int n_gem_selected_hits = n_gem_valid;
191 
192  // matched hits are a subsample of the selected hits
193  int n_tracker_matched = n_tracker_matched_valid;
194  int n_muon_matched = n_muon_matched_valid;
195  int n_dt_matched = n_dt_matched_valid;
196  int n_csc_matched = n_csc_matched_valid;
197  int n_rpc_matched = n_rpc_matched_valid;
198  int n_gem_matched = n_gem_matched_valid;
199 
200  std::string InvMuonHits, ZeroHitMuon;
201 
202  if (includeZeroHitMuons && n_muon_valid==0 && n_muon_INVALID!=0) {
203  // selected muon hits = INVALID when (useZeroHitMuons == True) and track has no valid muon hits
204 
205  InvMuonHits = " ***INVALID MUON HITS***";
206  ZeroHitMuon = " ***ZERO-HIT MUON***";
207 
208  n_muon_selected_hits = n_muon_INVALID;
209  n_dt_selected_hits = n_dt_INVALID;
210  n_csc_selected_hits = n_csc_INVALID;
211  n_rpc_selected_hits = n_rpc_INVALID;
212  n_gem_selected_hits = n_gem_INVALID;
213 
214  n_muon_matched = n_muon_matched_INVALID;
215  n_dt_matched = n_dt_matched_INVALID;
216  n_csc_matched = n_csc_matched_INVALID;
217  n_rpc_matched = n_rpc_matched_INVALID;
218  n_gem_matched = n_gem_matched_INVALID;
219  }
220 
221  int n_selected_hits = n_tracker_selected_hits + n_muon_selected_hits;
222  int n_matched = n_tracker_matched + n_muon_matched;
223 
224  edm::LogVerbatim("MuonAssociatorByHitsHelper")
225  <<"\n"<<"# TrackingRecHits: "<<(track->second - track->first)
226  <<"\n"<< "# used RecHits = " << n_all <<" ("<<n_tracker_all<<"/"
227  <<n_dt_all<<"/"<<n_csc_all<<"/"<<n_rpc_all<<"/"<<n_gem_all<<" in Tracker/DT/CSC/RPC/GEM)"<<", obtained from " << n_matching_simhits << " SimHits"
228  <<"\n"<< "# selected RecHits = " <<n_selected_hits <<" (" <<n_tracker_selected_hits<<"/"
229  <<n_dt_selected_hits<<"/"<<n_csc_selected_hits<<"/"<<n_rpc_selected_hits<<"/"<<n_gem_selected_hits<<" in Tracker/DT/CSC/RPC/GEM)"<<InvMuonHits
230  <<"\n"<< "# matched RecHits = " <<n_matched<<" ("<<n_tracker_matched<<"/"
231  <<n_dt_matched<<"/"<<n_csc_matched<<"/"<<n_rpc_matched<<"/"<<n_gem_matched<<" in Tracker/DT/CSC/RPC/GEM)";
232 
233  if (n_all>0 && n_matching_simhits == 0)
234  edm::LogWarning("MuonAssociatorByHitsHelper")
235  <<"*** WARNING in MuonAssociatorByHitsHelper::associateRecoToSim: no matching PSimHit found for this reco::Track !";
236 
237  if (n_matching_simhits != 0) {
238  edm::LogVerbatim("MuonAssociatorByHitsHelper")
239  <<"\n"<< "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
240  <<"\n"<< "reco::Track "<<tindex<<ZeroHitMuon
241  <<"\n\t"<< "made of "<<n_selected_hits<<" selected RecHits (tracker:"<<n_tracker_selected_hits<<"/muons:"<<n_muon_selected_hits<<")";
242 
243  int tpindex = 0;
244  for (TrackingParticleCollection::const_iterator trpart = tPC.begin(); trpart != tPC.end(); ++trpart, ++tpindex) {
245  tracker_nshared = getShared(tracker_matchedIds_valid, trpart);
246  muon_nshared = getShared(muon_matchedIds_valid, trpart);
247 
248  if (includeZeroHitMuons && n_muon_valid==0 && n_muon_INVALID!=0)
249  muon_nshared = getShared(muon_matchedIds_INVALID, trpart);
250 
251  global_nshared = tracker_nshared + muon_nshared;
252 
253  if (AbsoluteNumberOfHits_track) tracker_quality = static_cast<double>(tracker_nshared);
254  else if(n_tracker_selected_hits != 0) tracker_quality = (static_cast<double>(tracker_nshared)/static_cast<double>(n_tracker_selected_hits));
255  else tracker_quality = 0;
256 
257  if (AbsoluteNumberOfHits_muon) muon_quality = static_cast<double>(muon_nshared);
258  else if(n_muon_selected_hits != 0) muon_quality = (static_cast<double>(muon_nshared)/static_cast<double>(n_muon_selected_hits));
259  else muon_quality = 0;
260 
261  // global_quality used to order the matching TPs
262  if (n_selected_hits != 0) {
263  if (AbsoluteNumberOfHits_muon && AbsoluteNumberOfHits_track)
264  global_quality = global_nshared;
265  else
266  global_quality = (static_cast<double>(global_nshared)/static_cast<double>(n_selected_hits));
267  } else global_quality = 0;
268 
269  bool trackerOk = false;
270  if (n_tracker_selected_hits != 0) {
271  if (tracker_quality > tracker_quality_cut) trackerOk = true;
272  //if a track has just 3 hits in the Tracker we require that all 3 hits are shared
273  if (ThreeHitTracksAreSpecial && n_tracker_selected_hits==3 && tracker_nshared<3) trackerOk = false;
274  }
275 
276  bool muonOk = false;
277  if (n_muon_selected_hits != 0) {
278  if (muon_quality > muon_quality_cut) muonOk = true;
279  }
280 
281  // (matchOk) has to account for different track types (tracker-only, standalone muons, global muons)
282  bool matchOk = trackerOk || muonOk;
283 
284  // only for global muons: match both tracker and muon stub unless (acceptOneStubMatchings==true)
285  if (!acceptOneStubMatchings && n_tracker_selected_hits!=0 && n_muon_selected_hits!=0)
286  matchOk = trackerOk && muonOk;
287 
288  if (matchOk) {
289 
290  outputCollection[tindex].push_back(IndexMatch(tpindex, global_quality));
291  this_track_matched = true;
292 
293  edm::LogVerbatim("MuonAssociatorByHitsHelper")
294  << "\n\t"<<" **MATCHED** with quality = "<<global_quality<<" (tracker: "<<tracker_quality<<" / muon: "<<muon_quality<<")"
295  << "\n\t"<<" N shared hits = "<<global_nshared<<" (tracker: "<<tracker_nshared<<" / muon: "<<muon_nshared<<")"
296  <<"\n"<< " to: TrackingParticle " <<tpindex<<", q = "<<(*trpart).charge()<<", p = "<<(*trpart).p()
297  <<", pT = "<<(*trpart).pt()<<", eta = "<<(*trpart).eta()<<", phi = "<<(*trpart).phi()
298  <<"\n\t"<< " pdg code = "<<(*trpart).pdgId()<<", made of "<<(*trpart).numberOfHits()<<" PSimHits"
299  <<" from "<<(*trpart).g4Tracks().size()<<" SimTrack:";
300  for(TrackingParticle::g4t_iterator g4T=(*trpart).g4Track_begin();
301  g4T!=(*trpart).g4Track_end();
302  ++g4T) {
303  edm::LogVerbatim("MuonAssociatorByHitsHelper")
304  <<"\t"<< " Id:"<<(*g4T).trackId()<<"/Evt:("<<(*g4T).eventId().event()<<","<<(*g4T).eventId().bunchCrossing()<<")";
305  }
306  }
307  else {
308  // print something only if this TrackingParticle shares some hits with the current reco::Track
309  if (global_nshared != 0)
310  edm::LogVerbatim("MuonAssociatorByHitsHelper")
311  <<"\n\t"<<" NOT matched to TrackingParticle "<<tpindex
312  << " with quality = "<<global_quality<<" (tracker: "<<tracker_quality<<" / muon: "<<muon_quality<<")"
313  << "\n"<< " N shared hits = "<<global_nshared<<" (tracker: "<<tracker_nshared<<" / muon: "<<muon_nshared<<")";
314  }
315 
316  } // loop over TrackingParticle
317 
318  if (!this_track_matched) {
319  edm::LogVerbatim("MuonAssociatorByHitsHelper")
320  <<"\n"<<" NOT matched to any TrackingParticle";
321  }
322 
323  edm::LogVerbatim("MuonAssociatorByHitsHelper")
324  <<"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"<<"\n";
325 
326  } // if(n_matching_simhits != 0)
327 
328  } // loop over reco::Track
329 
330  if (!tC.size())
331  edm::LogVerbatim("MuonAssociatorByHitsHelper")<<"0 reconstructed tracks (-->> 0 associated !)";
332 
333  for (IndexAssociation::iterator it = outputCollection.begin(), ed = outputCollection.end(); it != ed; ++it) {
334  std::sort(it->second.begin(), it->second.end());
335  }
336  return outputCollection;
337 }
TrackingParticleCollection
std::vector< TrackingParticle > TrackingParticleCollection
Definition: HiEvtPlaneFlatProducer.cc:111
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
MuonAssociatorByHitsHelper::IndexAssociation
std::map< size_t, std::vector< IndexMatch > > IndexAssociation
Definition: MuonAssociatorByHitsHelper.h:54
MuonAssociatorByHitsHelper::getShared
int getShared(MapOfMatchedIds &matchedIds, TrackingParticleCollection::const_iterator trpart) const
Definition: MuonAssociatorByHitsHelper.cc:1234
mps_fire.resources
resources
Definition: mps_fire.py:84
TrackingParticle::g4t_iterator
std::vector< SimTrack >::const_iterator g4t_iterator
Definition: TrackingParticle.h:41
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
MuonAssociatorByHitsHelper::MapOfMatchedIds
boost::ptr_vector< uint_SimHitIdpr_pair > MapOfMatchedIds
Definition: MuonAssociatorByHitsHelper.h:33
MuonAssociatorByHitsHelper::getMatchedIds
void getMatchedIds(MapOfMatchedIds &tracker_matchedIds_valid, MapOfMatchedIds &muon_matchedIds_valid, MapOfMatchedIds &tracker_matchedIds_INVALID, MapOfMatchedIds &muon_matchedIds_INVALID, int &n_tracker_valid, int &n_dt_valid, int &n_csc_valid, int &n_rpc_valid, int &n_gem_valid, int &n_tracker_matched_valid, int &n_dt_matched_valid, int &n_csc_matched_valid, int &n_rpc_matched_valid, int &n_gem_matched_valid, int &n_tracker_INVALID, int &n_dt_INVALID, int &n_csc_INVALID, int &n_rpc_INVALID, int &n_gem_INVALID, int &n_tracker_matched_INVALID, int &n_dt_matched_INVALID, int &n_csc_matched_INVALID, int &n_rpc_matched_INVALID, int &n_gem_matched_INVALID, trackingRecHit_iterator begin, trackingRecHit_iterator end, const TrackerHitAssociator *trackertruth, const DTHitAssociator &dttruth, const CSCHitAssociator &csctruth, const RPCHitAssociator &rpctruth, const GEMHitAssociator &gemtruth, bool printRts, const TrackerTopology *) const
Definition: MuonAssociatorByHitsHelper.cc:766
MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associateSimToRecoIndices ( const TrackHitsCollection &  ,
const edm::RefVector< TrackingParticleCollection > &  ,
Resources const &   
) const

Definition at line 341 of file MuonAssociatorByHitsHelper.cc.

References AbsoluteNumberOfHits_muon, AbsoluteNumberOfHits_track, acceptOneStubMatchings, MuonAssociatorByHitsHelper::Resources::cscHitAssoc_, MuonAssociatorByHitsHelper::Resources::dtHitAssoc_, EfficiencyCut_muon, EfficiencyCut_track, MuonAssociatorByHitsHelper::Resources::gemHitAssoc_, getMatchedIds(), getShared(), includeZeroHitMuons, NHitCut_muon, NHitCut_track, PurityCut_muon, PurityCut_track, MuonAssociatorByHitsHelper::Resources::rpcHitAssoc_, edm::RefVector< C, T, F >::size(), AlCaHLTBitMon_QueryRunRegistry::string, ThreeHitTracksAreSpecial, HiIsolationCommonParameters_cff::track, MuonAssociatorByHitsHelper::Resources::trackerHitAssoc_, MuonAssociatorByHitsHelper::Resources::tTopo_, UseMuon, and UseTracker.

Referenced by MuonToSimAssociatorByHits::associateMuons(), MuonToTrackingParticleAssociatorByHitsImpl::associateMuons(), and MuonAssociatorByHits::associateSimToReco().

343  {
344  auto tTopo = resources.tTopo_;
345  auto trackertruth = resources.trackerHitAssoc_;
346  auto const & csctruth = *resources.cscHitAssoc_;
347  auto const& dttruth = *resources.dtHitAssoc_;
348  auto const& rpctruth = *resources.rpcHitAssoc_;
349  auto const& gemtruth = *resources.gemHitAssoc_;
350 
351  int tracker_nshared = 0;
352  int muon_nshared = 0;
353  int global_nshared = 0;
354 
355  double tracker_quality = 0;
356  double tracker_quality_cut;
357  if (AbsoluteNumberOfHits_track) tracker_quality_cut = static_cast<double>(NHitCut_track);
358  else tracker_quality_cut = EfficiencyCut_track;
359 
360  double muon_quality = 0;
361  double muon_quality_cut;
362  if (AbsoluteNumberOfHits_muon) muon_quality_cut = static_cast<double>(NHitCut_muon);
363  else muon_quality_cut = EfficiencyCut_muon;
364 
365  double global_quality = 0;
366 
367  double tracker_purity = 0;
368  double muon_purity = 0;
369  double global_purity = 0;
370 
371  MapOfMatchedIds tracker_matchedIds_valid, muon_matchedIds_valid;
372  MapOfMatchedIds tracker_matchedIds_INVALID, muon_matchedIds_INVALID;
373 
374  IndexAssociation outputCollection;
375 
376 
377  bool printRtS(true);
378 
379  TrackingParticleCollection tPC;
380  tPC.reserve(TPCollectionH.size());
381  for(auto const& ref: TPCollectionH) {
382  tPC.push_back(*ref);
383  }
384 
385  bool any_trackingParticle_matched = false;
386 
387  int tindex=0;
388  for (TrackHitsCollection::const_iterator track=tC.begin(); track!=tC.end(); track++, tindex++) {
389  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
390  <<"\n"<<"reco::Track "<<tindex
391  <<", number of RecHits = "<< (track->second - track->first) << "\n";
392 
393  tracker_matchedIds_valid.clear();
394  muon_matchedIds_valid.clear();
395 
396  tracker_matchedIds_INVALID.clear();
397  muon_matchedIds_INVALID.clear();
398 
399  int n_matching_simhits = 0;
400 
401  // all hits = valid +INVALID
402  int n_all = 0;
403  int n_tracker_all = 0;
404  int n_dt_all = 0;
405  int n_csc_all = 0;
406  int n_rpc_all = 0;
407  int n_gem_all = 0;
408 
409  int n_valid = 0;
410  int n_tracker_valid = 0;
411  int n_muon_valid = 0;
412  int n_dt_valid = 0;
413  int n_csc_valid = 0;
414  int n_rpc_valid = 0;
415  int n_gem_valid = 0;
416 
417  int n_tracker_matched_valid = 0;
418  int n_muon_matched_valid = 0;
419  int n_dt_matched_valid = 0;
420  int n_csc_matched_valid = 0;
421  int n_rpc_matched_valid = 0;
422  int n_gem_matched_valid = 0;
423 
424  int n_INVALID = 0;
425  int n_tracker_INVALID = 0;
426  int n_muon_INVALID = 0;
427  int n_dt_INVALID = 0;
428  int n_csc_INVALID = 0;
429  int n_rpc_INVALID = 0;
430  int n_gem_INVALID = 0;
431 
432  int n_tracker_matched_INVALID = 0;
433  int n_muon_matched_INVALID = 0;
434  int n_dt_matched_INVALID = 0;
435  int n_csc_matched_INVALID = 0;
436  int n_rpc_matched_INVALID = 0;
437  int n_gem_matched_INVALID = 0;
438 
439  printRtS = false;
440  getMatchedIds(tracker_matchedIds_valid, muon_matchedIds_valid,
441  tracker_matchedIds_INVALID, muon_matchedIds_INVALID,
442  n_tracker_valid, n_dt_valid, n_csc_valid, n_rpc_valid, n_gem_valid,
443  n_tracker_matched_valid, n_dt_matched_valid, n_csc_matched_valid, n_rpc_matched_valid, n_gem_matched_valid,
444  n_tracker_INVALID, n_dt_INVALID, n_csc_INVALID, n_rpc_INVALID, n_gem_INVALID,
445  n_tracker_matched_INVALID, n_dt_matched_INVALID, n_csc_matched_INVALID, n_rpc_matched_INVALID, n_gem_matched_INVALID,
446  track->first, track->second,
447  trackertruth, dttruth, csctruth, rpctruth, gemtruth,
448  printRtS,tTopo);
449 
450  n_matching_simhits = tracker_matchedIds_valid.size() + muon_matchedIds_valid.size() +
451  tracker_matchedIds_INVALID.size() +muon_matchedIds_INVALID.size();
452 
453  n_muon_valid = n_dt_valid + n_csc_valid + n_rpc_valid + n_gem_valid;
454  n_valid = n_tracker_valid + n_muon_valid;
455  n_muon_INVALID = n_dt_INVALID + n_csc_INVALID + n_rpc_INVALID + n_gem_INVALID;
456  n_INVALID = n_tracker_INVALID + n_muon_INVALID;
457 
458  // all used hits (valid+INVALID), defined by UseTracker, UseMuon
459  n_tracker_all = n_tracker_valid + n_tracker_INVALID;
460  n_dt_all = n_dt_valid + n_dt_INVALID;
461  n_csc_all = n_csc_valid + n_csc_INVALID;
462  n_rpc_all = n_rpc_valid + n_rpc_INVALID;
463  n_gem_all = n_gem_valid + n_gem_INVALID;
464  n_all = n_valid + n_INVALID;
465 
466  n_muon_matched_valid = n_dt_matched_valid + n_csc_matched_valid + n_rpc_matched_valid + n_gem_matched_valid;
467  n_muon_matched_INVALID = n_dt_matched_INVALID + n_csc_matched_INVALID + n_rpc_matched_INVALID + n_gem_matched_INVALID;
468 
469  // selected hits are set initially to valid hits
470  int n_tracker_selected_hits = n_tracker_valid;
471  int n_muon_selected_hits = n_muon_valid;
472  int n_dt_selected_hits = n_dt_valid;
473  int n_csc_selected_hits = n_csc_valid;
474  int n_rpc_selected_hits = n_rpc_valid;
475  int n_gem_selected_hits = n_gem_valid;
476 
477  // matched hits are a subsample of the selected hits
478  int n_tracker_matched = n_tracker_matched_valid;
479  int n_muon_matched = n_muon_matched_valid;
480  int n_dt_matched = n_dt_matched_valid;
481  int n_csc_matched = n_csc_matched_valid;
482  int n_rpc_matched = n_rpc_matched_valid;
483  int n_gem_matched = n_gem_matched_valid;
484 
485  std::string InvMuonHits, ZeroHitMuon;
486 
487  if (includeZeroHitMuons && n_muon_valid==0 && n_muon_INVALID!=0) {
488  // selected muon hits = INVALID when (useZeroHitMuons == True) and track has no valid muon hits
489 
490  InvMuonHits = " ***INVALID MUON HITS***";
491  ZeroHitMuon = " ***ZERO-HIT MUON***";
492 
493  n_muon_selected_hits = n_muon_INVALID;
494  n_dt_selected_hits = n_dt_INVALID;
495  n_csc_selected_hits = n_csc_INVALID;
496  n_rpc_selected_hits = n_rpc_INVALID;
497  n_gem_selected_hits = n_gem_INVALID;
498 
499  n_muon_matched = n_muon_matched_INVALID;
500  n_dt_matched = n_dt_matched_INVALID;
501  n_csc_matched = n_csc_matched_INVALID;
502  n_rpc_matched = n_rpc_matched_INVALID;
503  n_gem_matched = n_gem_matched_INVALID;
504  }
505 
506  int n_selected_hits = n_tracker_selected_hits + n_muon_selected_hits;
507  int n_matched = n_tracker_matched + n_muon_matched;
508 
509  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
510  <<"\n"<<"# TrackingRecHits: "<<(track->second - track->first)
511  <<"\n"<< "# used RecHits = " <<n_all <<" ("<<n_tracker_all<<"/"
512  <<n_dt_all<<"/"<<n_csc_all<<"/"<<n_rpc_all<<"/"<<n_gem_all<<" in Tracker/DT/CSC/RPC/GEM)"<<", obtained from " << n_matching_simhits << " SimHits"
513  <<"\n"<< "# selected RecHits = " <<n_selected_hits <<" (" <<n_tracker_selected_hits<<"/"
514  <<n_dt_selected_hits<<"/"<<n_csc_selected_hits<<"/"<<n_rpc_selected_hits<<"/"<<n_gem_selected_hits<<" in Tracker/DT/CSC/RPC/GEM)"<<InvMuonHits
515  <<"\n"<< "# matched RecHits = " <<n_matched<<" ("<<n_tracker_matched<<"/"
516  <<n_dt_matched<<"/"<<n_csc_matched<<"/"<<n_rpc_matched<<"/"<<n_gem_matched<<" in Tracker/DT/CSC/RPC/GEM)";
517 
518  if (printRtS && n_all>0 && n_matching_simhits==0)
519  edm::LogWarning("MuonAssociatorByHitsHelper")
520  <<"*** WARNING in MuonAssociatorByHitsHelper::associateSimToReco: no matching PSimHit found for this reco::Track !";
521 
522  if (n_matching_simhits != 0) {
523  int tpindex =0;
524  for (TrackingParticleCollection::const_iterator trpart = tPC.begin(); trpart != tPC.end(); ++trpart, ++tpindex) {
525 
526  // int n_tracker_simhits = 0;
527  int n_tracker_recounted_simhits = 0;
528  int n_muon_simhits = 0;
529  int n_global_simhits = 0;
530  // std::vector<PSimHit> tphits;
531 
532  int n_tracker_selected_simhits = 0;
533  int n_muon_selected_simhits = 0;
534  int n_global_selected_simhits = 0;
535 
536  // shared hits are counted over the selected ones
537  tracker_nshared = getShared(tracker_matchedIds_valid, trpart);
538  muon_nshared = getShared(muon_matchedIds_valid, trpart);
539 
540  if (includeZeroHitMuons && n_muon_valid==0 && n_muon_INVALID!=0)
541  muon_nshared = getShared(muon_matchedIds_INVALID, trpart);
542 
543  global_nshared = tracker_nshared + muon_nshared;
544  if (global_nshared == 0) continue; // if this TP shares no hits with the current reco::Track loop over
545 
546  // This does not work with the new TP interface
547  /*
548  for(std::vector<PSimHit>::const_iterator TPhit = trpart->pSimHit_begin(); TPhit != trpart->pSimHit_end(); TPhit++) {
549  DetId dId = DetId(TPhit->detUnitId());
550  DetId::Detector detector = dId.det();
551 
552  if (detector == DetId::Tracker) {
553  n_tracker_simhits++;
554 
555  unsigned int subdetId = static_cast<unsigned int>(dId.subdetId());
556  if (!UsePixels && (subdetId==PixelSubdetector::PixelBarrel || subdetId==PixelSubdetector::PixelEndcap) )
557  continue;
558 
559  SiStripDetId* stripDetId = 0;
560  if (subdetId==SiStripDetId::TIB||subdetId==SiStripDetId::TOB||
561  subdetId==SiStripDetId::TID||subdetId==SiStripDetId::TEC)
562  stripDetId= new SiStripDetId(dId);
563 
564  bool newhit = true;
565  for(std::vector<PSimHit>::const_iterator TPhitOK = tphits.begin(); TPhitOK != tphits.end(); TPhitOK++) {
566  DetId dIdOK = DetId(TPhitOK->detUnitId());
567  //no grouped, no splitting
568  if (!UseGrouped && !UseSplitting)
569  if (tTopo->layer(dId)==tTopo->layer(dIdOK) &&
570  dId.subdetId()==dIdOK.subdetId()) newhit = false;
571  //no grouped, splitting
572  if (!UseGrouped && UseSplitting)
573  if (tTopo->layer(dId)==tTopo->layer(dIdOK) &&
574  dId.subdetId()==dIdOK.subdetId() &&
575  (stripDetId==0 || stripDetId->partnerDetId()!=dIdOK.rawId()))
576  newhit = false;
577  //grouped, no splitting
578  if (UseGrouped && !UseSplitting)
579  if ( tTopo->layer(dId)== tTopo->layer(dIdOK) &&
580  dId.subdetId()==dIdOK.subdetId() &&
581  stripDetId!=0 && stripDetId->partnerDetId()==dIdOK.rawId())
582  newhit = false;
583  //grouped, splitting
584  if (UseGrouped && UseSplitting)
585  newhit = true;
586  }
587  if (newhit) {
588  tphits.push_back(*TPhit);
589  }
590  delete stripDetId;
591  }
592  else if (detector == DetId::Muon) {
593  n_muon_simhits++;
594 
595  // discard BAD CSC chambers (ME4/2) from hit counting
596  if (dId.subdetId() == MuonSubdetId::CSC) {
597  if (csctruth.cscBadChambers->isInBadChamber(CSCDetId(dId))) {
598  // edm::LogVerbatim("MuonAssociatorByHitsHelper")<<"This PSimHit is in a BAD CSC chamber, CSCDetId = "<<CSCDetId(dId);
599  n_muon_simhits--;
600  }
601  }
602 
603  }
604  }
605  */
606  // n_tracker_recounted_simhits = tphits.size();
607 
608  // adapt to new TP interface: this gives the total number of hits in tracker
609  // should reproduce the behaviour of UseGrouped=UseSplitting=.true.
610  n_tracker_recounted_simhits = trpart->numberOfTrackerHits();
611  // numberOfHits() gives the total number of hits (tracker + muons)
612  n_muon_simhits = trpart->numberOfHits() - trpart->numberOfTrackerHits();
613 
614  // Handle the case of TrackingParticles that don't have PSimHits inside, e.g. because they were made on RECOSIM only.
615  if (trpart->numberOfHits()==0) {
616  // FIXME this can be made better, counting the digiSimLinks associated to this TP, but perhaps it's not worth it
617  n_tracker_recounted_simhits = tracker_nshared;
618  n_muon_simhits = muon_nshared;
619  }
620  n_global_simhits = n_tracker_recounted_simhits + n_muon_simhits;
621 
622  if (UseMuon) {
623  n_muon_selected_simhits = n_muon_simhits;
624  n_global_selected_simhits = n_muon_selected_simhits;
625  }
626  if (UseTracker) {
627  n_tracker_selected_simhits = n_tracker_recounted_simhits;
628  n_global_selected_simhits += n_tracker_selected_simhits;
629  }
630 
631  if (AbsoluteNumberOfHits_track) tracker_quality = static_cast<double>(tracker_nshared);
632  else if (n_tracker_selected_simhits!=0)
633  tracker_quality = static_cast<double>(tracker_nshared)/static_cast<double>(n_tracker_selected_simhits);
634  else tracker_quality = 0;
635 
636  if (AbsoluteNumberOfHits_muon) muon_quality = static_cast<double>(muon_nshared);
637  else if (n_muon_selected_simhits!=0)
638  muon_quality = static_cast<double>(muon_nshared)/static_cast<double>(n_muon_selected_simhits);
639  else muon_quality = 0;
640 
641  // global_quality used to order the matching tracks
642  if (n_global_selected_simhits != 0) {
643  if (AbsoluteNumberOfHits_muon && AbsoluteNumberOfHits_track)
644  global_quality = global_nshared;
645  else
646  global_quality = static_cast<double>(global_nshared)/static_cast<double>(n_global_selected_simhits);
647  }
648  else global_quality = 0;
649 
650  // global purity
651  if (n_selected_hits != 0) {
652  if (AbsoluteNumberOfHits_muon && AbsoluteNumberOfHits_track)
653  global_purity = global_nshared;
654  else
655  global_purity = static_cast<double>(global_nshared)/static_cast<double>(n_selected_hits);
656  }
657  else global_purity = 0;
658 
659  bool trackerOk = false;
660  if (n_tracker_selected_hits != 0) {
661  if (tracker_quality > tracker_quality_cut) trackerOk = true;
662 
663  tracker_purity = static_cast<double>(tracker_nshared)/static_cast<double>(n_tracker_selected_hits);
664  if (AbsoluteNumberOfHits_track) tracker_purity = static_cast<double>(tracker_nshared);
665 
666  if ((!AbsoluteNumberOfHits_track) && tracker_purity <= PurityCut_track) trackerOk = false;
667 
668  //if a track has just 3 hits in the Tracker we require that all 3 hits are shared
669  if (ThreeHitTracksAreSpecial && n_tracker_selected_hits==3 && tracker_nshared<3) trackerOk = false;
670  }
671 
672  bool muonOk = false;
673  if (n_muon_selected_hits != 0) {
674  if (muon_quality > muon_quality_cut) muonOk = true;
675 
676  muon_purity = static_cast<double>(muon_nshared)/static_cast<double>(n_muon_selected_hits);
677  if (AbsoluteNumberOfHits_muon) muon_purity = static_cast<double>(muon_nshared);
678 
679  if ((!AbsoluteNumberOfHits_muon) && muon_purity <= PurityCut_muon) muonOk = false;
680  }
681 
682  // (matchOk) has to account for different track types (tracker-only, standalone muons, global muons)
683  bool matchOk = trackerOk || muonOk;
684 
685  // only for global muons: match both tracker and muon stub unless (acceptOneStubMatchings==true)
686  if (!acceptOneStubMatchings && n_tracker_selected_hits!=0 && n_muon_selected_hits!=0)
687  matchOk = trackerOk && muonOk;
688 
689  if (matchOk) {
690 
691  outputCollection[tpindex].push_back(IndexMatch(tindex,global_quality));
692  any_trackingParticle_matched = true;
693 
694  edm::LogVerbatim("MuonAssociatorByHitsHelper")
695  <<"************************************************************************************************************************"
696  <<"\n"<< "TrackingParticle " << tpindex <<", q = "<<(*trpart).charge()<<", p = "<<(*trpart).p()
697  <<", pT = "<<(*trpart).pt()<<", eta = "<<(*trpart).eta()<<", phi = "<<(*trpart).phi()
698  <<"\n"<<" pdg code = "<<(*trpart).pdgId()
699  <<", made of "<<(*trpart).numberOfHits()<<" PSimHits, recounted "<<n_global_simhits<<" PSimHits"
700  <<" (tracker:"<<n_tracker_recounted_simhits<<"/muons:"<<n_muon_simhits<<")"
701  <<", from "<<(*trpart).g4Tracks().size()<<" SimTrack:";
702  for(TrackingParticle::g4t_iterator g4T=(*trpart).g4Track_begin();
703  g4T!=(*trpart).g4Track_end();
704  ++g4T) {
705  edm::LogVerbatim("MuonAssociatorByHitsHelper")
706  <<" Id:"<<(*g4T).trackId()<<"/Evt:("<<(*g4T).eventId().event()<<","<<(*g4T).eventId().bunchCrossing()<<")";
707  }
708  edm::LogVerbatim("MuonAssociatorByHitsHelper")
709  <<"\t selected "<<n_global_selected_simhits<<" PSimHits"
710  <<" (tracker:"<<n_tracker_selected_simhits<<"/muons:"<<n_muon_selected_simhits<<")"
711  << "\n\t **MATCHED** with quality = "<<global_quality<<" (tracker: "<<tracker_quality<<" / muon: "<<muon_quality<<")"
712  << "\n\t and purity = "<<global_purity<<" (tracker: "<<tracker_purity<<" / muon: "<<muon_purity<<")"
713  << "\n\t N shared hits = "<<global_nshared<<" (tracker: "<<tracker_nshared<<" / muon: "<<muon_nshared<<")"
714  <<"\n" <<" to: reco::Track "<<tindex<<ZeroHitMuon
715  <<"\n\t"<< " made of "<<n_selected_hits<<" RecHits (tracker:"<<n_tracker_valid<<"/muons:"<<n_muon_selected_hits<<")";
716  }
717  else {
718  // print something only if this TrackingParticle shares some hits with the current reco::Track
719  if (global_nshared != 0) {
720  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
721  <<"************************************************************************************************************************"
722  <<"\n"<<"TrackingParticle " << tpindex <<", q = "<<(*trpart).charge()<<", p = "<<(*trpart).p()
723  <<", pT = "<<(*trpart).pt()<<", eta = "<<(*trpart).eta()<<", phi = "<<(*trpart).phi()
724  <<"\n"<<" pdg code = "<<(*trpart).pdgId()
725  <<", made of "<<(*trpart).numberOfHits()<<" PSimHits, recounted "<<n_global_simhits<<" PSimHits"
726  <<" (tracker:"<<n_tracker_recounted_simhits<<"/muons:"<<n_muon_simhits<<")"
727  <<", from "<<(*trpart).g4Tracks().size()<<" SimTrack:";
728  for(TrackingParticle::g4t_iterator g4T=(*trpart).g4Track_begin();
729  g4T!=(*trpart).g4Track_end();
730  ++g4T) {
731  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
732  <<" Id:"<<(*g4T).trackId()<<"/Evt:("<<(*g4T).eventId().event()<<","<<(*g4T).eventId().bunchCrossing()<<")";
733  }
734  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
735  <<"\t selected "<<n_global_selected_simhits<<" PSimHits"
736  <<" (tracker:"<<n_tracker_selected_simhits<<"/muons:"<<n_muon_selected_simhits<<")"
737  <<"\n\t NOT matched to reco::Track "<<tindex<<ZeroHitMuon
738  <<" with quality = "<<global_quality<<" (tracker: "<<tracker_quality<<" / muon: "<<muon_quality<<")"
739  <<"\n\t and purity = "<<global_purity<<" (tracker: "<<tracker_purity<<" / muon: "<<muon_purity<<")"
740  <<"\n\t N shared hits = "<<global_nshared<<" (tracker: "<<tracker_nshared<<" / muon: "<<muon_nshared<<")";
741  }
742  }
743  } // loop over TrackingParticle's
744  } // if(n_matching_simhits != 0)
745  } // loop over reco Tracks
746 
747  if (!any_trackingParticle_matched) {
748  edm::LogVerbatim("MuonAssociatorByHitsHelper")
749  <<"\n"
750  <<"************************************************************************************************************************"
751  << "\n NO TrackingParticle associated to ANY input reco::Track ! \n"
752  <<"************************************************************************************************************************"<<"\n";
753  } else {
754  edm::LogVerbatim("MuonAssociatorByHitsHelper")
755  <<"************************************************************************************************************************"<<"\n";
756  }
757 
758  for (IndexAssociation::iterator it = outputCollection.begin(), ed = outputCollection.end(); it != ed; ++it) {
759  std::sort(it->second.begin(), it->second.end());
760  }
761  return outputCollection;
762 }
TrackingParticleCollection
std::vector< TrackingParticle > TrackingParticleCollection
Definition: HiEvtPlaneFlatProducer.cc:111
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
MuonAssociatorByHitsHelper::IndexAssociation
std::map< size_t, std::vector< IndexMatch > > IndexAssociation
Definition: MuonAssociatorByHitsHelper.h:54
MuonAssociatorByHitsHelper::getShared
int getShared(MapOfMatchedIds &matchedIds, TrackingParticleCollection::const_iterator trpart) const
Definition: MuonAssociatorByHitsHelper.cc:1234
mps_fire.resources
resources
Definition: mps_fire.py:84
TrackingParticle::g4t_iterator
std::vector< SimTrack >::const_iterator g4t_iterator
Definition: TrackingParticle.h:41
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
MuonAssociatorByHitsHelper::MapOfMatchedIds
boost::ptr_vector< uint_SimHitIdpr_pair > MapOfMatchedIds
Definition: MuonAssociatorByHitsHelper.h:33
MuonAssociatorByHitsHelper::getMatchedIds
void getMatchedIds(MapOfMatchedIds &tracker_matchedIds_valid, MapOfMatchedIds &muon_matchedIds_valid, MapOfMatchedIds &tracker_matchedIds_INVALID, MapOfMatchedIds &muon_matchedIds_INVALID, int &n_tracker_valid, int &n_dt_valid, int &n_csc_valid, int &n_rpc_valid, int &n_gem_valid, int &n_tracker_matched_valid, int &n_dt_matched_valid, int &n_csc_matched_valid, int &n_rpc_matched_valid, int &n_gem_matched_valid, int &n_tracker_INVALID, int &n_dt_INVALID, int &n_csc_INVALID, int &n_rpc_INVALID, int &n_gem_INVALID, int &n_tracker_matched_INVALID, int &n_dt_matched_INVALID, int &n_csc_matched_INVALID, int &n_rpc_matched_INVALID, int &n_gem_matched_INVALID, trackingRecHit_iterator begin, trackingRecHit_iterator end, const TrackerHitAssociator *trackertruth, const DTHitAssociator &dttruth, const CSCHitAssociator &csctruth, const RPCHitAssociator &rpctruth, const GEMHitAssociator &gemtruth, bool printRts, const TrackerTopology *) const
Definition: MuonAssociatorByHitsHelper.cc:766
const TrackingRecHit* MuonAssociatorByHitsHelper::getHitPtr ( edm::OwnVector< TrackingRecHit >::const_iterator  iter) const
inlineprivate

Definition at line 99 of file MuonAssociatorByHitsHelper.h.

Referenced by getMatchedIds().

99 {return &*iter;}
const TrackingRecHit* MuonAssociatorByHitsHelper::getHitPtr ( const trackingRecHit_iterator &  iter) const
inlineprivate

Definition at line 100 of file MuonAssociatorByHitsHelper.h.

References AlCaHLTBitMon_QueryRunRegistry::string, and write_matched_simtracks().

100 {return &**iter;}
void MuonAssociatorByHitsHelper::getMatchedIds ( MapOfMatchedIds &  tracker_matchedIds_valid,
MapOfMatchedIds &  muon_matchedIds_valid,
MapOfMatchedIds &  tracker_matchedIds_INVALID,
MapOfMatchedIds &  muon_matchedIds_INVALID,
int &  n_tracker_valid,
int &  n_dt_valid,
int &  n_csc_valid,
int &  n_rpc_valid,
int &  n_gem_valid,
int &  n_tracker_matched_valid,
int &  n_dt_matched_valid,
int &  n_csc_matched_valid,
int &  n_rpc_matched_valid,
int &  n_gem_matched_valid,
int &  n_tracker_INVALID,
int &  n_dt_INVALID,
int &  n_csc_INVALID,
int &  n_rpc_INVALID,
int &  n_gem_INVALID,
int &  n_tracker_matched_INVALID,
int &  n_dt_matched_INVALID,
int &  n_csc_matched_INVALID,
int &  n_rpc_matched_INVALID,
int &  n_gem_matched_INVALID,
trackingRecHit_iterator  begin,
trackingRecHit_iterator  end,
const TrackerHitAssociator *  trackertruth,
const DTHitAssociator &  dttruth,
const CSCHitAssociator &  csctruth,
const RPCHitAssociator &  rpctruth,
const GEMHitAssociator &  gemtruth,
bool  printRts,
const TrackerTopology *  tTopo 
) const
private

Definition at line 766 of file MuonAssociatorByHitsHelper.cc.

References CSCHitAssociator::associateCSCHitId(), DTHitAssociator::associateDTHitId(), DTHitAssociator::associateHit(), TrackerHitAssociator::associateHitId(), RPCHitAssociator::associateRecHit(), GEMHitAssociator::associateRecHit(), MuonSubdetId::CSC, DetId::det(), MuonSubdetId::DT, dumpDT, end, MuonSubdetId::GEM, TrackingRecHit::geographicalId(), getHitPtr(), DTRecSegment4D::hasPhi(), DTRecSegment4D::hasZed(), diffTreeTool::index, TrackingRecHit::isValid(), DetId::Muon, DTRecSegment4D::phiSegment(), TrackerTopology::print(), DetId::rawId(), CSCSegment::recHits(), GEMSegment::recHits(), DTRecSegment2D::recHits(), MuonSubdetId::RPC, DetId::subdetId(), DetId::Tracker, UseMuon, UseTracker, DTRecHit1D::wireId(), write_matched_simtracks(), and DTRecSegment4D::zSegment().

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

777 {
778  tracker_matchedIds_valid.clear();
779  muon_matchedIds_valid.clear();
780 
781  tracker_matchedIds_INVALID.clear();
782  muon_matchedIds_INVALID.clear();
783 
784  n_tracker_valid = 0;
785  n_dt_valid = 0;
786  n_csc_valid = 0;
787  n_rpc_valid = 0;
788  n_gem_valid = 0;
789 
790  n_tracker_matched_valid = 0;
791  n_dt_matched_valid = 0;
792  n_csc_matched_valid = 0;
793  n_rpc_matched_valid = 0;
794  n_gem_matched_valid = 0;
795 
796  n_tracker_INVALID = 0;
797  n_dt_INVALID = 0;
798  n_csc_INVALID = 0;
799  n_rpc_INVALID = 0;
800  n_gem_INVALID = 0;
801 
802  n_tracker_matched_INVALID = 0;
803  n_dt_matched_INVALID = 0;
804  n_csc_matched_INVALID = 0;
805  n_rpc_matched_INVALID = 0;
806  n_gem_matched_INVALID = 0;
807 
808  std::vector<SimHitIdpr> SimTrackIds;
809 
810  // main loop on TrackingRecHits
811  int iloop = 0;
812  int iH = -1;
813  for (trackingRecHit_iterator it = begin; it != end; it++, iloop++) {
814  stringstream hit_index;
815  hit_index<<iloop;
816 
817  const TrackingRecHit * hitp = getHitPtr(it);
818  DetId geoid = hitp->geographicalId();
819 
820  unsigned int detid = geoid.rawId();
821  stringstream detector_id;
822  detector_id<<detid;
823 
824  string hitlog = "TrackingRecHit "+hit_index.str();
825  string wireidlog;
826  std::vector<string> DTSimHits;
827 
828  DetId::Detector det = geoid.det();
829  int subdet = geoid.subdetId();
830 
831  bool valid_Hit = hitp->isValid();
832 
833  // Si-Tracker Hits
834  if (det == DetId::Tracker && UseTracker) {
835  stringstream detector_id;
836  detector_id<< tTopo->print(detid);
837 
838  if (valid_Hit) hitlog = hitlog+" -Tracker - detID = "+detector_id.str();
839  else hitlog = hitlog+" *** INVALID ***"+" -Tracker - detID = "+detector_id.str();
840 
841  iH++;
842  SimTrackIds = trackertruth->associateHitId(*hitp);
843 
844  if (valid_Hit) {
845  n_tracker_valid++;
846 
847  if(!SimTrackIds.empty()) {
848  n_tracker_matched_valid++;
849  //tracker_matchedIds_valid[iH] = SimTrackIds;
850  tracker_matchedIds_valid.push_back( new uint_SimHitIdpr_pair(iH, SimTrackIds));
851  }
852  } else {
853  n_tracker_INVALID++;
854 
855  if(!SimTrackIds.empty()) {
856  n_tracker_matched_INVALID++;
857  //tracker_matchedIds_INVALID[iH] = SimTrackIds;
858  tracker_matchedIds_INVALID.push_back( new uint_SimHitIdpr_pair(iH, SimTrackIds));
859  }
860  }
861  }
862  // Muon detector Hits
863  else if (det == DetId::Muon && UseMuon) {
864 
865  // DT Hits
866  if (subdet == MuonSubdetId::DT) {
867  DTWireId dtdetid = DTWireId(detid);
868  stringstream dt_detector_id;
869  dt_detector_id << dtdetid;
870  if (valid_Hit) hitlog = hitlog+" -Muon DT - detID = "+dt_detector_id.str();
871  else hitlog = hitlog+" *** INVALID ***"+" -Muon DT - detID = "+dt_detector_id.str();
872 
873  const DTRecHit1D * dtrechit = dynamic_cast<const DTRecHit1D *>(hitp);
874 
875  // single DT hits
876  if (dtrechit) {
877  iH++;
878  SimTrackIds = dttruth.associateDTHitId(dtrechit);
879 
880  if (valid_Hit) {
881  n_dt_valid++;
882 
883  if (!SimTrackIds.empty()) {
884  n_dt_matched_valid++;
885  //muon_matchedIds_valid[iH] = SimTrackIds;
886  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
887  }
888  } else {
889  n_dt_INVALID++;
890 
891  if (!SimTrackIds.empty()) {
892  n_dt_matched_INVALID++;
893  //muon_matchedIds_INVALID[iH] = SimTrackIds;
894  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
895  }
896  }
897 
898  if (dumpDT) {
899  DTWireId wireid = dtrechit->wireId();
900  stringstream wid;
901  wid<<wireid;
902  std::vector<PSimHit> dtSimHits = dttruth.associateHit(*hitp);
903 
904  stringstream ndthits;
905  ndthits<<dtSimHits.size();
906  wireidlog = "\t DTWireId :"+wid.str()+", "+ndthits.str()+" associated PSimHit :";
907 
908  for (unsigned int j=0; j<dtSimHits.size(); j++) {
909  stringstream index;
910  index<<j;
911  stringstream simhit;
912  simhit<<dtSimHits[j];
913  string simhitlog = "\t\t PSimHit "+index.str()+": "+simhit.str();
914  DTSimHits.push_back(simhitlog);
915  }
916  } // if (dumpDT)
917  }
918 
919  // DT segments
920  else {
921  const DTRecSegment4D * dtsegment = dynamic_cast<const DTRecSegment4D *>(hitp);
922 
923  if (dtsegment) {
924 
925  std::vector<const TrackingRecHit *> componentHits, phiHits, zHits;
926  if (dtsegment->hasPhi()) {
927  phiHits = dtsegment->phiSegment()->recHits();
928  componentHits.insert(componentHits.end(),phiHits.begin(),phiHits.end());
929  }
930  if (dtsegment->hasZed()) {
931  zHits = dtsegment->zSegment()->recHits();
932  componentHits.insert(componentHits.end(),zHits.begin(),zHits.end());
933  }
934  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
935  <<"\n\t this TrackingRecHit is a DTRecSegment4D with "
936  <<componentHits.size()<<" hits (phi:"<<phiHits.size()<<", z:"<<zHits.size()<<")";
937 
938  std::vector<SimHitIdpr> i_SimTrackIds;
939  int i_compHit = 0;
940  for (std::vector<const TrackingRecHit *>::const_iterator ithit =componentHits.begin();
941  ithit != componentHits.end(); ++ithit) {
942  i_compHit++;
943 
944  const DTRecHit1D * dtrechit1D = dynamic_cast<const DTRecHit1D *>(*ithit);
945 
946  i_SimTrackIds.clear();
947  if (dtrechit1D) {
948  iH++;
949  i_SimTrackIds = dttruth.associateDTHitId(dtrechit1D);
950 
951  if (valid_Hit) {
952  // validity check is on the segment, but hits are counted one-by-one
953  n_dt_valid++;
954 
955  if (!i_SimTrackIds.empty()) {
956  n_dt_matched_valid++;
957  //muon_matchedIds_valid[iH] = i_SimTrackIds;
958  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
959  }
960  } else {
961  n_dt_INVALID++;
962 
963  if (!i_SimTrackIds.empty()) {
964  n_dt_matched_INVALID++;
965  //muon_matchedIds_INVALID[iH] = i_SimTrackIds;
966  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
967 
968  }
969  }
970  } else if (printRtS) edm::LogWarning("MuonAssociatorByHitsHelper")
971  <<"*** WARNING in MuonAssociatorByHitsHelper::getMatchedIds, null dynamic_cast of a DT TrackingRecHit !";
972 
973  unsigned int i_detid = (*ithit)->geographicalId().rawId();
974  DTWireId i_dtdetid = DTWireId(i_detid);
975 
976  stringstream i_dt_detector_id;
977  i_dt_detector_id << i_dtdetid;
978 
979  stringstream i_ss;
980  i_ss<<"\t\t hit "<<i_compHit<<" -Muon DT - detID = "<<i_dt_detector_id.str();
981 
982  string i_hitlog = i_ss.str();
983  i_hitlog = i_hitlog + write_matched_simtracks(i_SimTrackIds);
984  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper") << i_hitlog;
985 
986  SimTrackIds.insert(SimTrackIds.end(),i_SimTrackIds.begin(),i_SimTrackIds.end());
987  }
988  } // if (dtsegment)
989 
990  else if (printRtS) edm::LogWarning("MuonAssociatorByHitsHelper")
991  <<"*** WARNING in MuonAssociatorByHitsHelper::getMatchedIds, DT TrackingRecHit is neither DTRecHit1D nor DTRecSegment4D ! ";
992  }
993  }
994 
995  // CSC Hits
996  else if (subdet == MuonSubdetId::CSC) {
997  CSCDetId cscdetid = CSCDetId(detid);
998  stringstream csc_detector_id;
999  csc_detector_id << cscdetid;
1000  if (valid_Hit) hitlog = hitlog+" -Muon CSC- detID = "+csc_detector_id.str();
1001  else hitlog = hitlog+" *** INVALID ***"+" -Muon CSC- detID = "+csc_detector_id.str();
1002 
1003  const CSCRecHit2D * cscrechit = dynamic_cast<const CSCRecHit2D *>(hitp);
1004 
1005  // single CSC hits
1006  if (cscrechit) {
1007  iH++;
1008  SimTrackIds = csctruth.associateCSCHitId(cscrechit);
1009 
1010  if (valid_Hit) {
1011  n_csc_valid++;
1012 
1013  if (!SimTrackIds.empty()) {
1014  n_csc_matched_valid++;
1015  //muon_matchedIds_valid[iH] = SimTrackIds;
1016  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1017  }
1018  } else {
1019  n_csc_INVALID++;
1020 
1021  if (!SimTrackIds.empty()) {
1022  n_csc_matched_INVALID++;
1023  //muon_matchedIds_INVALID[iH] = SimTrackIds;
1024  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1025  }
1026  }
1027  }
1028 
1029  // CSC segments
1030  else {
1031  const CSCSegment * cscsegment = dynamic_cast<const CSCSegment *>(hitp);
1032 
1033  if (cscsegment) {
1034 
1035  std::vector<const TrackingRecHit *> componentHits = cscsegment->recHits();
1036  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
1037  <<"\n\t this TrackingRecHit is a CSCSegment with "<<componentHits.size()<<" hits";
1038 
1039  std::vector<SimHitIdpr> i_SimTrackIds;
1040  int i_compHit = 0;
1041  for (std::vector<const TrackingRecHit *>::const_iterator ithit =componentHits.begin();
1042  ithit != componentHits.end(); ++ithit) {
1043  i_compHit++;
1044 
1045  const CSCRecHit2D * cscrechit2D = dynamic_cast<const CSCRecHit2D *>(*ithit);
1046 
1047  i_SimTrackIds.clear();
1048  if (cscrechit2D) {
1049  iH++;
1050  i_SimTrackIds = csctruth.associateCSCHitId(cscrechit2D);
1051 
1052  if (valid_Hit) {
1053  // validity check is on the segment, but hits are counted one-by-one
1054  n_csc_valid++;
1055 
1056  if (!i_SimTrackIds.empty()) {
1057  n_csc_matched_valid++;
1058  //muon_matchedIds_valid[iH] = i_SimTrackIds;
1059  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
1060  }
1061  } else {
1062  n_csc_INVALID++;
1063 
1064  if (!i_SimTrackIds.empty()) {
1065  n_csc_matched_INVALID++;
1066  //muon_matchedIds_INVALID[iH] = i_SimTrackIds;
1067  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
1068  }
1069  }
1070  } else if (printRtS) edm::LogWarning("MuonAssociatorByHitsHelper")
1071  <<"*** WARNING in MuonAssociatorByHitsHelper::getMatchedIds, null dynamic_cast of a CSC TrackingRecHit !";
1072 
1073  unsigned int i_detid = (*ithit)->geographicalId().rawId();
1074  CSCDetId i_cscdetid = CSCDetId(i_detid);
1075 
1076  stringstream i_csc_detector_id;
1077  i_csc_detector_id << i_cscdetid;
1078 
1079  stringstream i_ss;
1080  i_ss<<"\t\t hit "<<i_compHit<<" -Muon CSC- detID = "<<i_csc_detector_id.str();
1081 
1082  string i_hitlog = i_ss.str();
1083  i_hitlog = i_hitlog + write_matched_simtracks(i_SimTrackIds);
1084  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper") << i_hitlog;
1085 
1086  SimTrackIds.insert(SimTrackIds.end(),i_SimTrackIds.begin(),i_SimTrackIds.end());
1087  }
1088  } // if (cscsegment)
1089 
1090  else if (printRtS) edm::LogWarning("MuonAssociatorByHitsHelper")
1091  <<"*** WARNING in MuonAssociatorByHitsHelper::getMatchedIds, CSC TrackingRecHit is neither CSCRecHit2D nor CSCSegment ! ";
1092  }
1093  }
1094 
1095  // RPC Hits
1096  else if (subdet == MuonSubdetId::RPC) {
1097  RPCDetId rpcdetid = RPCDetId(detid);
1098  stringstream rpc_detector_id;
1099  rpc_detector_id << rpcdetid;
1100  if (valid_Hit) hitlog = hitlog+" -Muon RPC- detID = "+rpc_detector_id.str();
1101  else hitlog = hitlog+" *** INVALID ***"+" -Muon RPC- detID = "+rpc_detector_id.str();
1102 
1103  iH++;
1104  SimTrackIds = rpctruth.associateRecHit(*hitp);
1105 
1106  if (valid_Hit) {
1107  n_rpc_valid++;
1108 
1109  if (!SimTrackIds.empty()) {
1110  n_rpc_matched_valid++;
1111  //muon_matchedIds_valid[iH] = SimTrackIds;
1112  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1113 
1114  }
1115  } else {
1116  n_rpc_INVALID++;
1117 
1118  if (!SimTrackIds.empty()) {
1119  n_rpc_matched_INVALID++;
1120  //muon_matchedIds_INVALID[iH] = SimTrackIds;
1121  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1122  }
1123  }
1124  }
1125 
1126  // GEM Hits
1127  else if (subdet == MuonSubdetId::GEM) {
1128  GEMDetId gemdetid = GEMDetId(detid);
1129  stringstream gem_detector_id;
1130  gem_detector_id << gemdetid;
1131  if (valid_Hit) hitlog = hitlog+" -Muon GEM- detID = "+gem_detector_id.str();
1132  else hitlog = hitlog+" *** INVALID ***"+" -Muon GEM- detID = "+gem_detector_id.str();
1133 
1134  const GEMRecHit * gemrechit = dynamic_cast<const GEMRecHit *>(hitp);
1135  if (gemrechit){
1136  iH++;
1137  SimTrackIds = gemtruth.associateRecHit(gemrechit);
1138 
1139  if (valid_Hit) {
1140  n_gem_valid++;
1141 
1142  if (!SimTrackIds.empty()) {
1143  n_gem_matched_valid++;
1144  //muon_matchedIds_valid[iH] = SimTrackIds;
1145  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1146 
1147  }
1148  } else {
1149  n_gem_INVALID++;
1150 
1151  if (!SimTrackIds.empty()) {
1152  n_gem_matched_INVALID++;
1153  //muon_matchedIds_INVALID[iH] = SimTrackIds;
1154  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,SimTrackIds));
1155  }
1156  }
1157  }
1158  else {
1159  const GEMSegment * gemsegment = dynamic_cast<const GEMSegment *>(hitp);
1160  if (gemsegment) {
1161 
1162  std::vector<const TrackingRecHit *> componentHits = gemsegment->recHits();
1163  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
1164  <<"\n\t this TrackingRecHit is a GEMSegment with "<<componentHits.size()<<" hits";
1165 
1166  std::vector<SimHitIdpr> i_SimTrackIds;
1167  int i_compHit = 0;
1168 
1169  for ( auto const & ithit : componentHits) {
1170 
1171  i_compHit++;
1172 
1173  const GEMRecHit * gemrechitseg = dynamic_cast<const GEMRecHit *>(ithit);
1174 
1175  i_SimTrackIds.clear();
1176  if (gemrechitseg) {
1177  iH++;
1178  i_SimTrackIds = gemtruth.associateRecHit(gemrechitseg);
1179 
1180  if (valid_Hit) {
1181  // validity check is on the segment, but hits are counted one-by-one
1182  n_gem_valid++;
1183 
1184  if (!i_SimTrackIds.empty()) {
1185  n_gem_matched_valid++;
1186  //muon_matchedIds_valid[iH] = i_SimTrackIds;
1187  muon_matchedIds_valid.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
1188  }
1189  } else {
1190  n_gem_INVALID++;
1191 
1192  if (!i_SimTrackIds.empty()) {
1193  n_gem_matched_INVALID++;
1194  //muon_matchedIds_INVALID[iH] = i_SimTrackIds;
1195  muon_matchedIds_INVALID.push_back (new uint_SimHitIdpr_pair(iH,i_SimTrackIds));
1196  }
1197  }
1198  } else if (printRtS) edm::LogWarning("MuonAssociatorByHitsHelper")
1199  <<"*** WARNING in MuonAssociatorByHitsHelper::getMatchedIds, null dynamic_cast of a GEM TrackingRecHit !";
1200 
1201  if (printRtS){
1202  unsigned int i_detid = ithit->geographicalId().rawId();
1203  GEMDetId i_gemdetid = GEMDetId(i_detid);
1204 
1205  string i_hitlog = std::to_string(i_gemdetid);
1206  i_hitlog = i_hitlog + write_matched_simtracks(i_SimTrackIds);
1207  edm::LogVerbatim("MuonAssociatorByHitsHelper") << i_hitlog;
1208  }
1209 
1210  SimTrackIds.insert(SimTrackIds.end(),i_SimTrackIds.begin(),i_SimTrackIds.end());
1211  }
1212  } // if (gemsegment)
1213 
1214  } // if (gemrechit
1215  }
1216  else if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper")
1217  <<"TrackingRecHit "<<iloop<<" *** WARNING *** Unexpected Hit from Detector = "<<det;
1218  }
1219  else continue;
1220 
1221  hitlog = hitlog + write_matched_simtracks(SimTrackIds);
1222 
1223  if (printRtS) edm::LogVerbatim("MuonAssociatorByHitsHelper") << hitlog;
1224  if (printRtS && dumpDT && det==DetId::Muon && subdet==MuonSubdetId::DT) {
1225  edm::LogVerbatim("MuonAssociatorByHitsHelper") <<wireidlog;
1226  for (unsigned int j=0; j<DTSimHits.size(); j++) {
1227  edm::LogVerbatim("MuonAssociatorByHitsHelper") <<DTSimHits[j];
1228  }
1229  }
1230 
1231  } //trackingRecHit loop
1232 }
MuonAssociatorByHitsHelper::write_matched_simtracks
std::string write_matched_simtracks(const std::vector< SimHitIdpr > &) const
Definition: MuonAssociatorByHitsHelper.cc:1271
DTRecSegment4D::phiSegment
const DTChamberRecSegment2D * phiSegment() const
The superPhi segment: 0 if no phi projection available.
Definition: DTRecSegment4D.h:96
MuonSubdetId::GEM
static const int GEM
Definition: MuonSubdetId.h:15
CSCHitAssociator::associateCSCHitId
std::vector< SimHitIdpr > associateCSCHitId(const CSCRecHit2D *) const
Definition: CSCHitAssociator.cc:35
TrackerTopology::print
std::string print(DetId detid) const
Definition: TrackerTopology.cc:266
DTHitAssociator::associateHit
std::vector< PSimHit > associateHit(const TrackingRecHit &hit) const
Definition: DTHitAssociator.cc:370
GEMSegment::recHits
virtual std::vector< const TrackingRecHit * > recHits() const
Access to component RecHits (if any)
Definition: GEMSegment.cc:72
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
RPCHitAssociator::associateRecHit
std::vector< SimHitIdpr > associateRecHit(const TrackingRecHit &hit) const
Definition: RPCHitAssociator.cc:79
MuonSubdetId::CSC
static const int CSC
Definition: MuonSubdetId.h:13
DTRecSegment2D::recHits
virtual std::vector< const TrackingRecHit * > recHits() const
Access to component RecHits (if any)
Definition: DTRecSegment2D.cc:88
end
#define end
Definition: vmac.h:37
DTRecSegment4D::hasPhi
bool hasPhi() const
Does it have the Phi projection?
Definition: DTRecSegment4D.h:90
DetId::subdetId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
CSCSegment::recHits
virtual std::vector< const TrackingRecHit * > recHits() const
Access to component RecHits (if any)
Definition: CSCSegment.cc:30
DTRecSegment4D::hasZed
bool hasZed() const
Does it have the Z projection?
Definition: DTRecSegment4D.h:93
DetId
Definition: DetId.h:18
DTRecSegment4D::zSegment
const DTSLRecSegment2D * zSegment() const
The Z segment: 0 if not zed projection available.
Definition: DTRecSegment4D.h:101
GEMHitAssociator::associateRecHit
std::vector< SimHitIdpr > associateRecHit(const GEMRecHit *gemrechit) const
Definition: GEMHitAssociator.cc:82
DetId::Detector
Detector
Definition: DetId.h:24
TrackingRecHit::isValid
bool isValid() const
Definition: TrackingRecHit.h:139
MuonAssociatorByHitsHelper::uint_SimHitIdpr_pair
std::pair< unsigned int, std::vector< SimHitIdpr > > uint_SimHitIdpr_pair
Definition: MuonAssociatorByHitsHelper.h:32
TrackerHitAssociator::associateHitId
std::vector< SimHitIdpr > associateHitId(const TrackingRecHit &thit) const
Definition: TrackerHitAssociator.cc:334
begin
#define begin
Definition: vmac.h:30
MuonSubdetId::RPC
static const int RPC
Definition: MuonSubdetId.h:14
MuonAssociatorByHitsHelper::getHitPtr
const TrackingRecHit * getHitPtr(edm::OwnVector< TrackingRecHit >::const_iterator iter) const
Definition: MuonAssociatorByHitsHelper.h:99
MuonSubdetId::DT
static const int DT
Definition: MuonSubdetId.h:12
TrackingRecHit::geographicalId
DetId geographicalId() const
Definition: TrackingRecHit.h:116
DetId::det
Detector det() const
get the detector field from this detid
Definition: DetId.h:35
DTHitAssociator::associateDTHitId
std::vector< SimHitIdpr > associateDTHitId(const DTRecHit1D *dtrechit) const
Definition: DTHitAssociator.cc:299
trackingRecHit_iterator
TrackingRecHitCollection::base::const_iterator trackingRecHit_iterator
iterator over a vector of reference to TrackingRecHit in the same collection
Definition: TrackingRecHitFwd.h:19
DTRecHit1D::wireId
DTWireId wireId() const
Return the wireId.
Definition: DTRecHit1D.h:107
int MuonAssociatorByHitsHelper::getShared ( MapOfMatchedIds &  matchedIds,
TrackingParticleCollection::const_iterator  trpart 
) const
private

Definition at line 1234 of file MuonAssociatorByHitsHelper.cc.

References runEdmFileComparison::found.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

1234  {
1235 
1236  int nshared = 0;
1237  const std::vector<SimTrack>& g4Tracks = trpart->g4Tracks();
1238 
1239  // map is indexed over the rechits of the reco::Track (no double-countings allowed)
1240  for (MapOfMatchedIds::const_iterator iRecH=matchedIds.begin(); iRecH!=matchedIds.end(); ++iRecH) {
1241 
1242  // vector of associated simhits associated to the current rechit
1243  std::vector<SimHitIdpr> const & SimTrackIds = (*iRecH).second;
1244 
1245  bool found = false;
1246 
1247  for (const auto& iSimH : SimTrackIds) {
1248 
1249  uint32_t simtrackId = iSimH.first;
1250  EncodedEventId evtId = iSimH.second;
1251 
1252  // look for shared hits with the given TrackingParticle (looping over component SimTracks)
1253  for (const auto& simtrack : g4Tracks) {
1254 
1255  if (simtrack.trackId() == simtrackId && simtrack.eventId() == evtId) {
1256  found = true;
1257  break;
1258  }
1259  }
1260 
1261  if (found) {
1262  nshared++;
1263  break;
1264  }
1265  }
1266  }
1267 
1268  return nshared;
1269 }
int MuonAssociatorByHitsHelper::LayerFromDetid ( const DetId &  ) const
private
std::string MuonAssociatorByHitsHelper::write_matched_simtracks ( const std::vector< SimHitIdpr > &  SimTrackIds) const
private

Definition at line 1271 of file MuonAssociatorByHitsHelper.cc.

References plotBeamSpotDB::first, and edm::second().

Referenced by getHitPtr(), and getMatchedIds().

1271  {
1272  if (SimTrackIds.empty())
1273  return " *** UNMATCHED ***";
1274 
1275  string hitlog(" matched to SimTrack");
1276 
1277  for(size_t j=0; j<SimTrackIds.size(); j++)
1278  {
1279  char buf[64];
1280  snprintf(buf, 64, " Id:%i/Evt:(%i,%i) ", SimTrackIds[j].first, SimTrackIds[j].second.event(), SimTrackIds[j].second.bunchCrossing());
1281  hitlog += buf;
1282  }
1283  return hitlog;
1284 }
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250

Member Data Documentation

const bool MuonAssociatorByHitsHelper::AbsoluteNumberOfHits_muon
private

Definition at line 88 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::AbsoluteNumberOfHits_track
private

Definition at line 84 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::acceptOneStubMatchings
private

Definition at line 81 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::dumpDT
private

Definition at line 96 of file MuonAssociatorByHitsHelper.h.

Referenced by getMatchedIds().

double MuonAssociatorByHitsHelper::EfficiencyCut_muon
private

Definition at line 90 of file MuonAssociatorByHitsHelper.h.

Referenced by associateSimToRecoIndices(), and MuonAssociatorByHitsHelper().

double MuonAssociatorByHitsHelper::EfficiencyCut_track
private

Definition at line 86 of file MuonAssociatorByHitsHelper.h.

Referenced by associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::includeZeroHitMuons
private

Definition at line 80 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), associateSimToRecoIndices(), and MuonAssociatorByHitsHelper().

unsigned int MuonAssociatorByHitsHelper::NHitCut_muon
private

Definition at line 89 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), associateSimToRecoIndices(), and MuonAssociatorByHitsHelper().

unsigned int MuonAssociatorByHitsHelper::NHitCut_track
private

Definition at line 85 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

double MuonAssociatorByHitsHelper::PurityCut_muon
private

Definition at line 91 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), associateSimToRecoIndices(), and MuonAssociatorByHitsHelper().

double MuonAssociatorByHitsHelper::PurityCut_track
private

Definition at line 87 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::ThreeHitTracksAreSpecial
private

Definition at line 95 of file MuonAssociatorByHitsHelper.h.

Referenced by associateRecoToSimIndices(), and associateSimToRecoIndices().

const bool MuonAssociatorByHitsHelper::UseGrouped
private

Definition at line 93 of file MuonAssociatorByHitsHelper.h.

bool MuonAssociatorByHitsHelper::UseMuon
private

Definition at line 83 of file MuonAssociatorByHitsHelper.h.

Referenced by associateSimToRecoIndices(), getMatchedIds(), and MuonAssociatorByHitsHelper().

const bool MuonAssociatorByHitsHelper::UsePixels
private

Definition at line 92 of file MuonAssociatorByHitsHelper.h.

const bool MuonAssociatorByHitsHelper::UseSplitting
private

Definition at line 94 of file MuonAssociatorByHitsHelper.h.

bool MuonAssociatorByHitsHelper::UseTracker
private

Definition at line 82 of file MuonAssociatorByHitsHelper.h.

Referenced by associateSimToRecoIndices(), getMatchedIds(), and MuonAssociatorByHitsHelper().

Generated for CMSSW Reference Manual by doxygen 1.8.11