CMS 3D CMS Logo
ResidualRefitting.cc
Go to the documentation of this file.
1 #include <iostream>
2 #include "ResidualRefitting.h"
3 #include <iomanip>
4 
5 //framework includes
6 #include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
7 #include "DataFormats/MuonDetId/interface/DTWireId.h"
8 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
9 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
10 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
11 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
12 
13 #include "FWCore/Framework/interface/ConsumesCollector.h"
14 #include "FWCore/Framework/interface/Event.h"
15 #include "FWCore/Framework/interface/EventSetup.h"
16 #include "FWCore/Framework/interface/ESHandle.h"
17 #include "FWCore/Utilities/interface/EDMException.h"
18 #include "FWCore/ParameterSet/interface/ParameterSet.h"
19 #include "FWCore/Framework/interface/MakerMacros.h"
20 
21 #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
22 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
23 #include "Geometry/CommonDetUnit/interface/GeomDetEnumerators.h"
24 
25 #include "RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h"
26 #include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHitBuilder.h"
27 #include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h"
28 
29 #include "RecoVertex/KalmanVertexFit/interface/KalmanVertexFitter.h"
30 
31 #include "TrackingTools/DetLayers/interface/DetLayer.h"
32 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
33 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
34 
35 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
36 
37 ResidualRefitting::ResidualRefitting(const edm::ParameterSet& cfg)
38  : outputFileName_(cfg.getUntrackedParameter<std::string>("histoutputFile")),
39  PropagatorSource_(cfg.getParameter<std::string>("propagator")),
40  muons_(cfg.getParameter<edm::InputTag>("muons")),
41  muonsRemake_(cfg.getParameter<edm::InputTag>("muonsRemake")), //This Feels Misalignment
42  muonsNoStation1_(cfg.getParameter<edm::InputTag>("muonsNoStation1")),
43  muonsNoStation2_(cfg.getParameter<edm::InputTag>("muonsNoStation2")),
44  muonsNoStation3_(cfg.getParameter<edm::InputTag>("muonsNoStation3")),
45  muonsNoStation4_(cfg.getParameter<edm::InputTag>("muonsNoStation4")),
46 
47  /*
48  muonsNoPXBLayer1_ ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1" ) ),
49  muonsNoPXBLayer2_ ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1" ) ),
50  muonsNoPXBLayer3_ ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1" ) ),
51 
52  muonsNoTIBLayer1_ ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer1" ) ),
53  muonsNoTIBLayer2_ ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer2" ) ),
54  muonsNoTIBLayer3_ ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer3" ) ),
55  muonsNoTIBLayer4_ ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer4" ) ),
56 
57  muonsNoTOBLayer1_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer1" ) ),
58  muonsNoTOBLayer2_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer2" ) ),
59  muonsNoTOBLayer3_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer3" ) ),
60  muonsNoTOBLayer4_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer4" ) ),
61  muonsNoTOBLayer5_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer5" ) ),
62  muonsNoTOBLayer6_ ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer6" ) ),*/
63  debug_(cfg.getUntrackedParameter<bool>("doDebug")),
64  outputFile_(nullptr),
65  outputTree_(nullptr),
66  outputBranch_(nullptr),
67  theField(nullptr) {
68  eventInfo_.evtNum_ = 0;
69  eventInfo_.evtNum_ = 0;
70 
71  // service parameters
72  edm::ParameterSet serviceParameters = cfg.getParameter<edm::ParameterSet>("ServiceParameters");
73 
74  // the services
75  theService = new MuonServiceProxy(serviceParameters, consumesCollector());
76 
77 } //The constructor
78 
79 void ResidualRefitting::analyze(const edm::Event& event, const edm::EventSetup& eventSetup) {
80  if (debug_)
81  printf("STARTING EVENT\n");
82 
83  eventInfo_.evtNum_ = (int)event.id().run();
84  eventInfo_.runNum_ = (int)event.id().event();
85 
86  // Generator Collection
87 
88  // The original muon collection that is sitting in memory
89  edm::Handle<reco::MuonCollection> muons;
90 
91  edm::Handle<reco::TrackCollection> muonTracks;
92  edm::Handle<reco::TrackCollection> muonsNoSt1;
93  edm::Handle<reco::TrackCollection> muonsNoSt2;
94  edm::Handle<reco::TrackCollection> muonsNoSt3;
95  edm::Handle<reco::TrackCollection> muonsNoSt4;
96 
97  event.getByLabel(muons_, muons); //set label to muons
98  event.getByLabel(muonsRemake_, muonTracks);
99  event.getByLabel(muonsNoStation1_, muonsNoSt1);
100  event.getByLabel(muonsNoStation2_, muonsNoSt2);
101  event.getByLabel(muonsNoStation3_, muonsNoSt3);
102  event.getByLabel(muonsNoStation4_, muonsNoSt4);
103 
104  /*
105 // std::cout<<"Muon Collection No PXB "<<std::endl;
106 //Tracker Barrel Pixel Refits
107  edm::Handle<MuonCollection> muonsNoPXBLayer1Coll;
108  event.getByLabel(muonsNoPXBLayer1_, muonsNoPXBLayer1Coll);
109  edm::Handle<MuonCollection> muonsNoPXBLayer2Coll;
110  event.getByLabel(muonsNoPXBLayer2_, muonsNoPXBLayer2Coll);
111  edm::Handle<MuonCollection> muonsNoPXBLayer3Coll;
112  event.getByLabel(muonsNoPXBLayer3_, muonsNoPXBLayer3Coll);
113 // std::cout<<"Muon Collection No TIB "<<std::endl;
114 // Tracker Inner Barrel Refits
115  edm::Handle<MuonCollection> muonsNoTIBLayer1Coll;
116  event.getByLabel(muonsNoTIBLayer1_, muonsNoTIBLayer1Coll);
117  edm::Handle<MuonCollection> muonsNoTIBLayer2Coll;
118  event.getByLabel(muonsNoTIBLayer2_, muonsNoTIBLayer2Coll);
119  edm::Handle<MuonCollection> muonsNoTIBLayer3Coll;
120  event.getByLabel(muonsNoTIBLayer3_, muonsNoTIBLayer3Coll);
121  edm::Handle<MuonCollection> muonsNoTIBLayer4Coll;
122  event.getByLabel(muonsNoTIBLayer4_, muonsNoTIBLayer4Coll);
123 
124 // std::cout<<"Muon Collection No TOB "<<std::endl;
125 
126 //Tracker outer barrel refits
127  edm::Handle<MuonCollection> muonsNoTOBLayer1Coll;
128  event.getByLabel(muonsNoTOBLayer1_, muonsNoTOBLayer1Coll);
129  edm::Handle<MuonCollection> muonsNoTOBLayer2Coll;
130  event.getByLabel(muonsNoTOBLayer2_, muonsNoTOBLayer2Coll);
131  edm::Handle<MuonCollection> muonsNoTOBLayer3Coll;
132  event.getByLabel(muonsNoTOBLayer3_, muonsNoTOBLayer3Coll);
133  edm::Handle<MuonCollection> muonsNoTOBLayer4Coll;
134  event.getByLabel(muonsNoTOBLayer4_, muonsNoTOBLayer4Coll);
135  edm::Handle<MuonCollection> muonsNoTOBLayer5Coll;
136  event.getByLabel(muonsNoTOBLayer5_, muonsNoTOBLayer5Coll);
137  edm::Handle<MuonCollection> muonsNoTOBLayer6Coll;
138  event.getByLabel(muonsNoTOBLayer6_, muonsNoTOBLayer6Coll);
139 */
140  //magnetic field information
141  edm::ESHandle<MagneticField> field;
142  edm::ESHandle<GlobalTrackingGeometry> globalTrackingGeometry;
143  eventSetup.get<IdealMagneticFieldRecord>().get(field);
144  eventSetup.get<GlobalTrackingGeometryRecord>().get(globalTrackingGeometry);
145  eventSetup.get<TrackingComponentsRecord>().get(PropagatorSource_, thePropagator);
146  theField = &*field;
147 
148  theService->update(eventSetup);
149 
150  //Zero storage
151  zero_storage();
152 
153  //Do the Gmr Muons from the unModified Collection
154 
155  /*
156  int iGmr = 0;
157  if ( (muons->end() - muons->begin()) > 0) printf("Data Dump:: Original GMR Muons\n");
158  for ( MuonCollection::const_iterator muon = muons->begin(); muon!=muons->end(); muon++, iGmr++) {
159  if ( iGmr >= ResidualRefitting::N_MAX_STORED) break; // error checking
160  if (!debug
161 
162  dumpTrackRef(muon->combinedMuon(), "cmb");
163  dumpTrackRef(muon->standAloneMuon(), "sam");
164  dumpTrackRef(muon->track(), "trk");
165 
166 
167  }
168  storageGmrOld_.n_ = iGmr;
169  storageSamNew_.n_ = iGmr;
170 */
171 
172  //Refitted muons
173  if (debug_)
174  printf("Data Dump:: Rebuilt GMR Muon Track With TeV refitter default\n");
175  int iGmrRemake = 0;
176  for (reco::TrackCollection::const_iterator muon = muonTracks->begin(); muon != muonTracks->end();
177  muon++, iGmrRemake++) {
178  if (iGmrRemake >= ResidualRefitting::N_MAX_STORED)
179  break; // error checking
180  // from TrackInfoProducer/test/TrackInfoAnalyzerExample.cc
181  reco::TrackRef trackref = reco::TrackRef(muonTracks, iGmrRemake);
182 
183  if (debug_)
184  dumpTrackRef(trackref, "gmr");
185  muonInfo(storageGmrNew_, trackref, iGmrRemake);
186  }
187  storageGmrNew_.n_ = iGmrRemake;
188 
189  if (debug_)
190  printf("muons Remake");
191  if (debug_)
192  printf("-----------------------------------------\n");
193  CollectTrackHits(muonTracks, storageTrackExtrapRec_, eventSetup);
194 
195  if (true) {
196  printf("muons No Station 1");
197  printf("-----------------------------------------\n");
198  }
199  NewTrackMeasurements(muonTracks, muonsNoSt1, storageTrackExtrapRecNoSt1_);
200 
201  if (true) {
202  printf("muons No Station 2");
203  printf("-----------------------------------------\n");
204  }
205  NewTrackMeasurements(muonTracks, muonsNoSt2, storageTrackExtrapRecNoSt2_);
206 
207  if (true) {
208  printf("muons No Station 3");
209  printf("-----------------------------------------\n");
210  }
211  NewTrackMeasurements(muonTracks, muonsNoSt3, storageTrackExtrapRecNoSt3_);
212 
213  if (true) {
214  printf("muons No Station 4");
215  printf("-----------------------------------------\n");
216  }
217  NewTrackMeasurements(muonTracks, muonsNoSt4, storageTrackExtrapRecNoSt4_);
218 
219  // dumpMuonRecHits(storageRecMuon_);
220 
221  /****************************************************************************************************************************************/
222 
223  /*
224  * extrapolates track to a cylinder.
225  * commented for cosmic runs with no tracker in reco muons!!
226  *
227 */
228 
229  int iGmrCyl = 0;
230  for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); muon++, iGmrCyl++) {
231  dumpTrackRef(muon->combinedMuon(), "cmb");
232  dumpTrackRef(muon->standAloneMuon(), "sam");
233  dumpTrackRef(muon->track(), "trk");
234 
235  cylExtrapTrkSam(iGmrCyl, muon->standAloneMuon(), samExtrap120_, 120.);
236  cylExtrapTrkSam(iGmrCyl, muon->track(), trackExtrap120_, 120.);
237  }
238  samExtrap120_.n_ = iGmrCyl;
239  trackExtrap120_.n_ = iGmrCyl;
240 
241  if (iGmrRemake > 0 || iGmrCyl > 0) {
242  outputTree_->Fill();
243  std::cout << "FILLING NTUPLE!" << std::endl;
244  std::cout << "Entries Recorded: " << outputTree_->GetEntries() << " Branch :: " << outputBranch_->GetEntries()
245  << std::endl
246  << std::endl;
247  } else
248  std::cout << "no tracks -- no fill!\n" << std::endl << std::endl;
249 
250  // /*************************************************************************************************************/
251  // //END OF ntuple dumper
252  // //END OF ntuple dumper
253  // /***********************************************************************************************************/
254 }
255 //end Analyze() main function
256 
257 //------------------------------------------------------------------------------
258 //
259 // Destructor
260 //
261 ResidualRefitting::~ResidualRefitting() {
262  delete outputFile_;
263  delete theService;
264 }
265 //
266 // Track Collection Analysis
267 //
268 void ResidualRefitting::CollectTrackHits(edm::Handle<reco::TrackCollection> trackColl,
269  ResidualRefitting::storage_trackExtrap& trackExtrap,
270  const edm::EventSetup& eventSetup) {
271  //Retrieve tracker topology from geometry
272  edm::ESHandle<TrackerTopology> tTopoHandle;
273  eventSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
274  const TrackerTopology* const tTopo = tTopoHandle.product();
275 
276  int iMuonHit = 0;
277  int iTrackHit = 0;
278  int numTracks = 0;
279 
280  for (reco::TrackCollection::const_iterator muon = trackColl->begin(); muon != trackColl->end(); muon++) {
281  int iTrack = muon - trackColl->begin();
282  reco::TrackRef trackref = reco::TrackRef(trackColl, iTrack);
283  FreeTrajectoryState recoStart = ResidualRefitting::freeTrajStateMuon(trackref);
284 
285  if (debug_)
286  dumpTrackRef(trackref, "CollectTrackHits Track");
287 
288  int iRec = 0;
289  for (auto const& rec : muon->recHits()) {
290  DetId detid = rec->geographicalId();
291 
292  if (detid.det() != DetId::Muon && detid.det() != DetId::Tracker) {
293  if (debug_)
294  printf("Rec Hit not from muon system or tracker... continuing...\n");
295  continue;
296  }
297  // numTracks++;
298  // Get Local and Global Position of Hits
299 
300  LocalPoint lp = rec->localPosition();
301  float lpX = lp.x();
302  float lpY = lp.y();
303  float lpZ = lp.z();
304 
305  auto mrhp = MuonTransientTrackingRecHit::specificBuild(
306  theService->trackingGeometry()->idToDet(rec->geographicalId()), rec);
307 
308  GlobalPoint gp = mrhp->globalPosition();
309  float gpRecX = gp.x();
310  float gpRecY = gp.y();
311  float gpRecZ = gp.z();
312  float gpRecEta = gp.eta();
313  float gpRecPhi = gp.phi();
314 
315  if (detid.det() == DetId::Muon) {
316  int systemMuon = detid.subdetId(); // 1 DT; 2 CSC; 3 RPC
317  int endcap = -999;
318  int station = -999;
319  int ring = -999;
320  int chamber = -999;
321  int layer = -999;
322  int superLayer = -999;
323  int wheel = -999;
324  int sector = -999;
325  if (systemMuon == MuonSubdetId::CSC) {
326  CSCDetId id(detid.rawId());
327  endcap = id.endcap();
328  station = id.station();
329  ring = id.ring();
330  chamber = id.chamber();
331  layer = id.layer();
332  if (debug_)
333  printf("CSC\t[endcap][station][ringN][chamber][layer]:[%d][%d][%d][%d][%d]\t",
334  endcap,
335  station,
336  ring,
337  chamber,
338  layer);
339 
340  } else if (systemMuon == MuonSubdetId::DT) {
341  DTWireId id(detid.rawId());
342  station = id.station();
343  layer = id.layer();
344  superLayer = id.superLayer();
345  wheel = id.wheel();
346  sector = id.sector();
347  if (debug_)
348  printf("DT \t[station][layer][superlayer]:[%d][%d][%d]\n", station, layer, superLayer);
349 
350  } else if (systemMuon == MuonSubdetId::RPC) {
351  RPCDetId id(detid.rawId());
352  station = id.station();
353  if (debug_)
354  printf("RPC\t[station]:[%d]\n", station);
355  }
356 
357  storageRecMuon_.muonLink_[iMuonHit] = iTrack;
358  storageRecMuon_.system_[iMuonHit] = systemMuon;
359  storageRecMuon_.endcap_[iMuonHit] = endcap;
360  storageRecMuon_.station_[iMuonHit] = station;
361  storageRecMuon_.ring_[iMuonHit] = ring;
362  storageRecMuon_.chamber_[iMuonHit] = chamber;
363  storageRecMuon_.layer_[iMuonHit] = layer;
364  storageRecMuon_.superLayer_[iMuonHit] = superLayer;
365  storageRecMuon_.wheel_[iMuonHit] = wheel;
366  storageRecMuon_.sector_[iMuonHit] = sector;
367 
368  storageRecMuon_.gpX_[iMuonHit] = gpRecX;
369  storageRecMuon_.gpY_[iMuonHit] = gpRecY;
370  storageRecMuon_.gpZ_[iMuonHit] = gpRecZ;
371  storageRecMuon_.gpEta_[iMuonHit] = gpRecEta;
372  storageRecMuon_.gpPhi_[iMuonHit] = gpRecPhi;
373  storageRecMuon_.lpX_[iMuonHit] = lpX;
374  storageRecMuon_.lpY_[iMuonHit] = lpY;
375  storageRecMuon_.lpZ_[iMuonHit] = lpZ;
376  iMuonHit++;
377 
378  } else if (detid.det() == DetId::Tracker) {
379  if (debug_)
380  printf("Tracker\n");
381 
382  StoreTrackerRecHits(detid, tTopo, iTrack, iTrackHit);
383 
384  storageTrackHit_.gpX_[iTrackHit] = gpRecX;
385  storageTrackHit_.gpY_[iTrackHit] = gpRecY;
386  storageTrackHit_.gpZ_[iTrackHit] = gpRecZ;
387  storageTrackHit_.gpEta_[iTrackHit] = gpRecEta;
388  storageTrackHit_.gpPhi_[iTrackHit] = gpRecPhi;
389  storageTrackHit_.lpX_[iTrackHit] = lpX;
390  storageTrackHit_.lpY_[iTrackHit] = lpY;
391  storageTrackHit_.lpZ_[iTrackHit] = lpZ;
392  iTrackHit++;
393  } else
394  printf("THIS CAN NOT HAPPEN\n");
395 
396  trkExtrap(detid, numTracks, iTrack, iRec, recoStart, lp, trackExtrap);
397  numTracks++;
398 
399  if (debug_)
400  printf("\tLocal Positon: \tx = %2.2f\ty = %2.2f\tz = %2.2f\n", lpX, lpY, lpZ);
401  if (debug_)
402  printf("\tGlobal Position: \tx = %6.2f\ty = %6.2f\tz = %6.2f\teta = %4.2f\tphi = %3.2f\n",
403  gpRecX,
404  gpRecY,
405  gpRecZ,
406  gpRecEta,
407  gpRecPhi);
408 
409  ++iRec;
410  }
411  }
412 
413  storageRecMuon_.n_ = iMuonHit;
414  storageTrackHit_.n_ = iTrackHit;
415  trackExtrap.n_ = numTracks;
416 }
417 //
418 // Deal with Re-Fitted Track with some station omitted.
419 //
420 // This should take the new track, match it to its track before refitting with the hits dumped, and extrapolate out to the
421 // rec hits that were removed from the fit.
422 //
423 //
424 
425 void ResidualRefitting::NewTrackMeasurements(edm::Handle<reco::TrackCollection> trackCollOrig,
426  edm::Handle<reco::TrackCollection> trackColl,
427  ResidualRefitting::storage_trackExtrap& trackExtrap) {
428  int numTracks = 0;
429  int recCounter = 0;
430 
431  for (reco::TrackCollection::const_iterator muon = trackColl->begin(); muon != trackColl->end(); muon++) {
432  int iTrack = muon - trackColl->begin();
433 
434  reco::TrackRef trackref = reco::TrackRef(trackColl, iTrack);
435  FreeTrajectoryState recoStart = ResidualRefitting::freeTrajStateMuon(trackref);
436 
437  int iTrackLink = MatchTrackWithRecHits(muon, trackCollOrig);
438  reco::TrackRef ref = reco::TrackRef(trackCollOrig, iTrackLink);
439 
440  for (auto const& rec1 : ref->recHits()) {
441  bool unbiasedRec = true;
442 
443  for (auto const& rec2 : muon->recHits()) {
444  if (IsSameHit(*rec1, *rec2)) {
445  unbiasedRec = false;
446  break;
447  }
448  }
449  if (!unbiasedRec)
450  continue;
451 
452  DetId detid = rec1->geographicalId();
453 
454  auto mrhp = MuonTransientTrackingRecHit::specificBuild(
455  theService->trackingGeometry()->idToDet(rec1->geographicalId()), rec1);
456 
457  trkExtrap(detid, numTracks, iTrackLink, recCounter, recoStart, rec1->localPosition(), trackExtrap);
458  numTracks++;
459  }
460  }
461 
462  trackExtrap.n_ = numTracks;
463 }
464 //
465 // Find the original track that corresponds to the re-fitted track
466 //
467 int ResidualRefitting::MatchTrackWithRecHits(reco::TrackCollection::const_iterator trackIt,
468  edm::Handle<reco::TrackCollection> ref) {
469  if (debug_)
470  printf("Matching a re-fitted track to the original track.\n");
471 
472  int TrackMatch = -1;
473 
474  for (auto const& rec : trackIt->recHits()) {
475  bool foundMatch = false;
476  for (reco::TrackCollection::const_iterator refIt = ref->begin(); refIt != ref->end(); refIt++) {
477  int iTrackMatch = refIt - ref->begin();
478  if (foundMatch && TrackMatch != iTrackMatch)
479  break;
480  for (auto const& recRef : refIt->recHits()) {
481  if (!IsSameHit(*rec, *recRef))
482  continue;
483 
484  foundMatch = true;
485  TrackMatch = iTrackMatch;
486  // printf("Rec hit match for original track %d\n", iTrackMatch);
487  }
488  }
489  if (!foundMatch) {
490  printf("SOMETHING WENT WRONG! Could not match Track with original track!");
491  exit(1);
492  }
493  }
494  if (debug_)
495  printf("Rec hit match for original track %d\n", TrackMatch);
496 
497  // reco::TrackRef trackref=reco::TrackRef(ref,TrackMatch);
498  return TrackMatch;
499 }
500 /*
501 //
502 // Match two tracks to see if one is a subset of the other
503 //
504 
505 bool ResidualRefitting::TrackSubset(reco::TrackRef trackSub, reco::TrackRef trackTop) {
506 
507 
508  bool matchAll = true;
509 
510  for (trackingRecHit_iterator recSub = trackSub->recHits().begin(); recSub!=trackSub->recHits().end(); recSub++) {
511 
512  bool matchSub = false;
513 
514 
515  for (trackingRecHit_iterator recTop = trackTop->recHits().begin(); recTop!=trackTop->recHits().end(); recTop++) {
516 
517  if ( recSub == recTop ) matchSub = true;
518  if (matchSub) break;
519 
520  }
521  if (!matchSub) return false;
522 
523  }
524 
525  return matchAll;
526 
527 }
528 */
529 
530 //
531 // Check to see if the rec hits are the same
532 //
533 bool ResidualRefitting::IsSameHit(TrackingRecHit const& hit1, TrackingRecHit const& hit2) {
534  double lpx1 = hit1.localPosition().x();
535  double lpy1 = hit1.localPosition().y();
536  double lpz1 = hit1.localPosition().z();
537 
538  double lpx2 = hit2.localPosition().x();
539  double lpy2 = hit2.localPosition().y();
540  double lpz2 = hit2.localPosition().z();
541  if (fabs(lpx1 - lpx2) > 1e-3)
542  return false;
543  // printf("Match lpx...\n");
544  if (fabs(lpy1 - lpy2) > 1e-3)
545  return false;
546  // printf("Match lpy...\n");
547  if (fabs(lpz1 - lpz2) > 1e-3)
548  return false;
549  // printf("Match lpz...\n");
550 
551  return true;
552 }
553 
554 //
555 // Store Tracker Rec Hits
556 //
557 void ResidualRefitting::StoreTrackerRecHits(DetId detid, const TrackerTopology* tTopo, int iTrack, int iRec) {
558  int detector = -1;
559  int subdetector = -1;
560  int blade = -1;
561  int disk = -1;
562  int ladder = -1;
563  int layer = -1;
564  int module = -1;
565  int panel = -1;
566  int ring = -1;
567  int side = -1;
568  int wheel = -1;
569 
570  //Detector Info
571 
572  detector = detid.det();
573  subdetector = detid.subdetId();
574 
575  if (detector != DetId::Tracker) {
576  std::cout << "OMFG NOT THE TRACKER\n" << std::endl;
577  return;
578  }
579 
580  if (debug_)
581  std::cout << "Tracker:: ";
582  if (subdetector == ResidualRefitting::PXB) {
583  layer = tTopo->pxbLayer(detid.rawId());
584  ladder = tTopo->pxbLadder(detid.rawId());
585  module = tTopo->pxbModule(detid.rawId());
586  if (debug_)
587  std::cout << "PXB"
588  << "\tlayer = " << layer << "\tladder = " << ladder << "\tmodule = " << module;
589 
590  } else if (subdetector == ResidualRefitting::PXF) {
591  side = tTopo->pxfSide(detid.rawId());
592  disk = tTopo->pxfDisk(detid.rawId());
593  blade = tTopo->pxfBlade(detid.rawId());
594  panel = tTopo->pxfPanel(detid.rawId());
595  module = tTopo->pxfModule(detid.rawId());
596  if (debug_)
597  std::cout << "PXF"
598  << "\tside = " << side << "\tdisk = " << disk << "\tblade = " << blade << "\tpanel = " << panel
599  << "\tmodule = " << module;
600 
601  } else if (subdetector == ResidualRefitting::TIB) {
602  layer = tTopo->tibLayer(detid.rawId());
603  module = tTopo->tibModule(detid.rawId());
604  if (debug_)
605  std::cout << "TIB"
606  << "\tlayer = " << layer << "\tmodule = " << module;
607  } else if (subdetector == ResidualRefitting::TID) {
608  side = tTopo->tidSide(detid.rawId());
609  wheel = tTopo->tidWheel(detid.rawId());
610  ring = tTopo->tidRing(detid.rawId());
611  if (debug_)
612  std::cout << "TID"
613  << "\tside = " << side << "\twheel = " << wheel << "\tring = " << ring;
614 
615  } else if (subdetector == ResidualRefitting::TOB) {
616  layer = tTopo->tobLayer(detid.rawId());
617  module = tTopo->tobModule(detid.rawId());
618  if (debug_)
619  std::cout << "TOB"
620  << "\tlayer = " << layer << "\tmodule = " << module;
621 
622  } else if (subdetector == ResidualRefitting::TEC) {
623  ring = tTopo->tecRing(detid.rawId());
624  module = tTopo->tecModule(detid.rawId());
625  if (debug_)
626  std::cout << "TEC"
627  << "\tring = " << ring << "\tmodule = " << module;
628  }
629 
630  //Do Storage
631 
632  storageTrackHit_.muonLink_[iRec] = iTrack;
633  storageTrackHit_.detector_[iRec] = detector;
634  storageTrackHit_.subdetector_[iRec] = subdetector;
635  storageTrackHit_.blade_[iRec] = blade;
636  storageTrackHit_.disk_[iRec] = disk;
637  storageTrackHit_.ladder_[iRec] = ladder;
638  storageTrackHit_.layer_[iRec] = layer;
639  storageTrackHit_.module_[iRec] = module;
640  storageTrackHit_.panel_[iRec] = panel;
641  storageTrackHit_.ring_[iRec] = ring;
642  storageTrackHit_.side_[iRec] = side;
643  storageTrackHit_.wheel_[iRec] = wheel;
644 }
645 
646 //
647 // Store Muon info on P, Pt, eta, phi
648 //
649 void ResidualRefitting::muonInfo(ResidualRefitting::storage_muon& storeMuon, reco::TrackRef muon, int val) {
650  storeMuon.pt_[val] = muon->pt();
651  storeMuon.p_[val] = muon->p();
652  storeMuon.eta_[val] = muon->eta();
653  storeMuon.phi_[val] = muon->phi();
654  storeMuon.charge_[val] = muon->charge();
655  storeMuon.numRecHits_[val] = muon->numberOfValidHits();
656  storeMuon.chiSq_[val] = muon->chi2();
657  storeMuon.ndf_[val] = muon->ndof();
658  storeMuon.chiSqOvrNdf_[val] = muon->normalizedChi2();
659 }
660 //
661 // Fill a track extrapolation
662 //
663 void ResidualRefitting::trkExtrap(const DetId& detid,
664  int iTrk,
665  int iTrkLink,
666  int iRec,
667  const FreeTrajectoryState& freeTrajState,
668  const LocalPoint& recPoint,
669  storage_trackExtrap& storeTemp) {
670  bool dump_ = debug_;
671 
672  if (dump_)
673  std::cout << "In the trkExtrap function" << std::endl;
674 
675  float gpExtrapX = -99999;
676  float gpExtrapY = -99999;
677  float gpExtrapZ = -99999;
678  float gpExtrapEta = -99999;
679  float gpExtrapPhi = -99999;
680 
681  float lpX = -99999;
682  float lpY = -99999;
683  float lpZ = -99999;
684 
685  //
686  // Get the local positions for the recHits
687  //
688 
689  float recLpX = recPoint.x();
690  float recLpY = recPoint.y();
691  float recLpZ = recPoint.z();
692 
693  float resX = -9999;
694  float resY = -9999;
695  float resZ = -9999;
696 
697  const GeomDet* gdet = theService->trackingGeometry()->idToDet(detid);
698 
699  // TrajectoryStateOnSurface surfTest = prop.propagate(freeTrajState, gdet->surface());
700  TrajectoryStateOnSurface surfTest = thePropagator->propagate(freeTrajState, gdet->surface());
701 
702  if (surfTest.isValid()) {
703  GlobalPoint globTest = surfTest.globalPosition();
704  gpExtrapX = globTest.x();
705  gpExtrapY = globTest.y();
706  gpExtrapZ = globTest.z();
707  gpExtrapEta = globTest.eta();
708  gpExtrapPhi = globTest.phi();
709  LocalPoint loc = surfTest.localPosition();
710  if (detid.det() == DetId::Muon || detid.det() == DetId::Tracker) {
711  lpX = loc.x();
712  lpY = loc.y();
713  lpZ = loc.z();
714 
715  resX = lpX - recLpX;
716  resY = lpY - recLpY;
717  resZ = lpZ - recLpZ;
718  }
719  }
720  storeTemp.muonLink_[iTrk] = iTrkLink;
721  storeTemp.recLink_[iTrk] = iRec;
722  storeTemp.gpX_[iTrk] = gpExtrapX;
723  storeTemp.gpY_[iTrk] = gpExtrapY;
724  storeTemp.gpZ_[iTrk] = gpExtrapZ;
725  storeTemp.gpEta_[iTrk] = gpExtrapEta;
726  storeTemp.gpPhi_[iTrk] = gpExtrapPhi;
727  storeTemp.lpX_[iTrk] = lpX;
728  storeTemp.lpY_[iTrk] = lpY;
729  storeTemp.lpZ_[iTrk] = lpZ;
730  storeTemp.resX_[iTrk] = resX;
731  storeTemp.resY_[iTrk] = resY;
732  storeTemp.resZ_[iTrk] = resZ;
733 
734  printf("station: %d\tsector: %d\tresX storage: %4.2f\n", ReturnStation(detid), ReturnSector(detid), resX);
735 }
736 //
737 // Return the station
738 //
739 int ResidualRefitting::ReturnStation(DetId detid) {
740  int station = -999;
741 
742  if (detid.det() == DetId::Muon) {
743  int systemMuon = detid.subdetId(); // 1 DT; 2 CSC; 3 RPC
744  if (systemMuon == MuonSubdetId::CSC) {
745  CSCDetId id(detid.rawId());
746  station = id.station();
747 
748  } else if (systemMuon == MuonSubdetId::DT) {
749  DTWireId id(detid.rawId());
750  station = id.station();
751 
752  } else if (systemMuon == MuonSubdetId::RPC) {
753  RPCDetId id(detid.rawId());
754  station = id.station();
755  }
756  }
757 
758  return station;
759 }
760 //
761 // Return the sector
762 //
763 int ResidualRefitting::ReturnSector(DetId detid) {
764  int sector = -999;
765 
766  if (detid.det() == DetId::Muon) {
767  int systemMuon = detid.subdetId(); // 1 DT; 2 CSC; 3 RPC
768  if (systemMuon == MuonSubdetId::DT) {
769  DTWireId id(detid.rawId());
770  sector = id.sector();
771  }
772  }
773 
774  return sector;
775 }
776 
777 //
778 // Store the SAM and Track position info at a particular rho
779 //
780 void ResidualRefitting::cylExtrapTrkSam(int recNum,
781  reco::TrackRef track,
782  ResidualRefitting::storage_trackExtrap& storage,
783  double rho) {
784  Cylinder::PositionType pos(0, 0, 0);
785  Cylinder::RotationType rot;
786 
787  Cylinder::CylinderPointer myCylinder = Cylinder::build(pos, rot, rho);
788  // SteppingHelixPropagator inwardProp ( theField, oppositeToMomentum );
789  // SteppingHelixPropagator outwardProp ( theField, alongMomentum );
790  FreeTrajectoryState recoStart = freeTrajStateMuon(track);
791  // TrajectoryStateOnSurface recoProp = outwardProp.propagate(recoStart, *myCylinder);
792  TrajectoryStateOnSurface recoProp = thePropagator->propagate(recoStart, *myCylinder);
793 
794  double xVal = -9999;
795  double yVal = -9999;
796  double zVal = -9999;
797  double phiVal = -9999;
798  double etaVal = -9999;
799 
800  if (recoProp.isValid()) {
801  GlobalPoint recoPoint = recoProp.globalPosition();
802  xVal = recoPoint.x();
803  yVal = recoPoint.y();
804  zVal = recoPoint.z();
805  phiVal = recoPoint.phi();
806  etaVal = recoPoint.eta();
807  }
808  storage.muonLink_[recNum] = recNum;
809  storage.gpX_[recNum] = xVal;
810  storage.gpY_[recNum] = yVal;
811  storage.gpZ_[recNum] = zVal;
812  storage.gpEta_[recNum] = etaVal;
813  storage.gpPhi_[recNum] = phiVal;
814 
815  float rhoVal = sqrt(xVal * xVal + yVal * yVal);
816 
817  printf("Cylinder: rho = %4.2f\tphi = %4.2f\teta = %4.2f\n", rhoVal, phiVal, etaVal);
818  if (debug_)
819  printf("Cylinder: rho = %4.2f\tphi = %4.2f\teta = %4.2f\n", rhoVal, phiVal, etaVal);
820 }
822 //Pre-Job junk
824 
825 //
826 // zero storage
827 //
828 void ResidualRefitting::zero_storage() {
829  if (debug_)
830  printf("zero_storage\n");
831 
832  zero_muon(&storageGmrOld_);
833  zero_muon(&storageGmrNew_);
834  zero_muon(&storageSamNew_);
835  zero_muon(&storageTrkNew_);
836  zero_muon(&storageGmrNoSt1_);
837  zero_muon(&storageSamNoSt1_);
838  zero_muon(&storageGmrNoSt2_);
839  zero_muon(&storageSamNoSt2_);
840  zero_muon(&storageGmrNoSt3_);
841  zero_muon(&storageSamNoSt3_);
842  zero_muon(&storageGmrNoSt4_);
843  zero_muon(&storageSamNoSt4_);
844  //zero out the tracker
845  zero_muon(&storageGmrNoPXBLayer1);
846  zero_muon(&storageGmrNoPXBLayer2);
847  zero_muon(&storageGmrNoPXBLayer3);
848 
849  zero_muon(&storageGmrNoPXF);
850 
851  zero_muon(&storageGmrNoTIBLayer1);
852  zero_muon(&storageGmrNoTIBLayer2);
853  zero_muon(&storageGmrNoTIBLayer3);
854  zero_muon(&storageGmrNoTIBLayer4);
855 
856  zero_muon(&storageGmrNoTID);
857 
858  zero_muon(&storageGmrNoTOBLayer1);
859  zero_muon(&storageGmrNoTOBLayer2);
860  zero_muon(&storageGmrNoTOBLayer3);
861  zero_muon(&storageGmrNoTOBLayer4);
862  zero_muon(&storageGmrNoTOBLayer5);
863  zero_muon(&storageGmrNoTOBLayer6);
864 
865  zero_muon(&storageGmrNoTEC);
866 
867  zero_muon(&storageTrkNoPXBLayer1);
868  zero_muon(&storageTrkNoPXBLayer2);
869  zero_muon(&storageTrkNoPXBLayer3);
870 
871  zero_muon(&storageTrkNoPXF);
872 
873  zero_muon(&storageTrkNoTIBLayer1);
874  zero_muon(&storageTrkNoTIBLayer2);
875  zero_muon(&storageTrkNoTIBLayer3);
876  zero_muon(&storageTrkNoTIBLayer4);
877 
878  zero_muon(&storageTrkNoTID);
879 
880  zero_muon(&storageTrkNoTOBLayer1);
881  zero_muon(&storageTrkNoTOBLayer2);
882  zero_muon(&storageTrkNoTOBLayer3);
883  zero_muon(&storageTrkNoTOBLayer4);
884  zero_muon(&storageTrkNoTOBLayer5);
885  zero_muon(&storageTrkNoTOBLayer6);
886 
887  zero_muon(&storageTrkNoTEC);
888 
889  zero_trackExtrap(&storageTrackExtrapRec_);
890  zero_trackExtrap(&storageTrackExtrapTracker_);
891  zero_trackExtrap(&storageTrackExtrapRecNoSt1_);
892  zero_trackExtrap(&storageTrackExtrapRecNoSt2_);
893  zero_trackExtrap(&storageTrackExtrapRecNoSt3_);
894  zero_trackExtrap(&storageTrackExtrapRecNoSt4_);
895 
896  zero_trackExtrap(&trackExtrap120_);
897 
898  zero_trackExtrap(&samExtrap120_);
899 
900  zero_trackExtrap(&storageTrackNoPXBLayer1);
901  zero_trackExtrap(&storageTrackNoPXBLayer2);
902  zero_trackExtrap(&storageTrackNoPXBLayer3);
903 
904  zero_trackExtrap(&storageTrackNoPXF);
905 
906  zero_trackExtrap(&storageTrackNoTIBLayer1);
907  zero_trackExtrap(&storageTrackNoTIBLayer2);
908  zero_trackExtrap(&storageTrackNoTIBLayer3);
909  zero_trackExtrap(&storageTrackNoTIBLayer4);
910 
911  zero_trackExtrap(&storageTrackNoTOBLayer1);
912  zero_trackExtrap(&storageTrackNoTOBLayer2);
913  zero_trackExtrap(&storageTrackNoTOBLayer3);
914  zero_trackExtrap(&storageTrackNoTOBLayer4);
915  zero_trackExtrap(&storageTrackNoTOBLayer5);
916  zero_trackExtrap(&storageTrackNoTOBLayer6);
917 
918  zero_trackExtrap(&storageTrackNoTEC);
919 
920  zero_trackExtrap(&storageTrackNoTID);
921 
922  storageRecMuon_.n_ = 0;
923  storageTrackHit_.n_ = 0;
924 }
925 //
926 // Zero out a muon reference
927 //
928 void ResidualRefitting::zero_muon(ResidualRefitting::storage_muon* str) {
929  str->n_ = 0;
930 
931  for (int i = 0; i < ResidualRefitting::N_MAX_STORED; i++) {
932  str->pt_[i] = -9999;
933  str->eta_[i] = -9999;
934  str->p_[i] = -9999;
935  str->phi_[i] = -9999;
936  str->numRecHits_[i] = -9999;
937  str->chiSq_[i] = -9999;
938  str->ndf_[i] = -9999;
939  str->chiSqOvrNdf_[i] = -9999;
940  }
941 }
942 //
943 // Zero track extrapolation
944 //
945 void ResidualRefitting::zero_trackExtrap(ResidualRefitting::storage_trackExtrap* str) {
946  str->n_ = 0;
947  for (int i = 0; i < ResidualRefitting::N_MAX_STORED_HIT; i++) {
948  str->muonLink_[i] = -9999;
949  str->recLink_[i] = -9999;
950  str->gpX_[i] = -9999;
951  str->gpY_[i] = -9999;
952  str->gpZ_[i] = -9999;
953  str->gpEta_[i] = -9999;
954  str->gpPhi_[i] = -9999;
955  str->lpX_[i] = -9999;
956  str->lpY_[i] = -9999;
957  str->lpZ_[i] = -9999;
958  str->resX_[i] = -9999;
959  str->resY_[i] = -9999;
960  str->resZ_[i] = -9999;
961  }
962 }
963 //
964 // Begin Job
965 //
966 void ResidualRefitting::beginJob() {
967  std::cout << "Creating file " << outputFileName_.c_str() << std::endl;
968 
969  outputFile_ = new TFile(outputFileName_.c_str(), "RECREATE");
970 
971  outputTree_ = new TTree("outputTree", "outputTree");
972 
973  outputTree_->Branch("eventInfo",
974  &eventInfo_,
975  "evtNum_/I:"
976  "runNum_/I");
977 
978  ResidualRefitting::branchMuon(storageGmrOld_, "gmrOld");
979  ResidualRefitting::branchMuon(storageGmrNew_, "gmrNew");
980  ResidualRefitting::branchMuon(storageGmrNoSt1_, "gmrNoSt1");
981  ResidualRefitting::branchMuon(storageGmrNoSt2_, "gmrNoSt2");
982  ResidualRefitting::branchMuon(storageGmrNoSt3_, "gmrNoSt3");
983  ResidualRefitting::branchMuon(storageGmrNoSt4_, "gmrNoSt4");
984 
985  ResidualRefitting::branchMuon(storageSamNew_, "samNew");
986  ResidualRefitting::branchMuon(storageSamNoSt1_, "samNoSt1");
987  ResidualRefitting::branchMuon(storageSamNoSt2_, "samNoSt2");
988  ResidualRefitting::branchMuon(storageSamNoSt3_, "samNoSt3");
989  ResidualRefitting::branchMuon(storageSamNoSt4_, "samNoSt4");
990 
991  ResidualRefitting::branchMuon(storageTrkNew_, "trkNew");
992  ResidualRefitting::branchMuon(storageGmrNoPXBLayer1, "gmrNoPXBLayer1");
993  ResidualRefitting::branchMuon(storageGmrNoPXBLayer2, "gmrNoPXBLayer2");
994  ResidualRefitting::branchMuon(storageGmrNoPXBLayer3, "gmrNoPXBLayer3");
995  ResidualRefitting::branchMuon(storageGmrNoPXF, "gmrNoPXF");
996  ResidualRefitting::branchMuon(storageGmrNoTIBLayer1, "gmrNoTIBLayer1");
997  ResidualRefitting::branchMuon(storageGmrNoTIBLayer2, "gmrNoTIBLayer2");
998  ResidualRefitting::branchMuon(storageGmrNoTIBLayer3, "gmrNoTIBLayer3");
999  ResidualRefitting::branchMuon(storageGmrNoTIBLayer4, "gmrNoTIBLayer4");
1000  ResidualRefitting::branchMuon(storageGmrNoTID, "gmrNoTID");
1001  ResidualRefitting::branchMuon(storageGmrNoTOBLayer1, "gmrNoTOBLayer1");
1002  ResidualRefitting::branchMuon(storageGmrNoTOBLayer2, "gmrNoTOBLayer2");
1003  ResidualRefitting::branchMuon(storageGmrNoTOBLayer3, "gmrNoTOBLayer3");
1004  ResidualRefitting::branchMuon(storageGmrNoTOBLayer4, "gmrNoTOBLayer4");
1005  ResidualRefitting::branchMuon(storageGmrNoTOBLayer5, "gmrNoTOBLayer5");
1006  ResidualRefitting::branchMuon(storageGmrNoTOBLayer6, "gmrNoTOBLayer6");
1007  ResidualRefitting::branchMuon(storageGmrNoTEC, "gmrNoTEC");
1008 
1009  ResidualRefitting::branchMuon(storageTrkNoPXBLayer1, "trkNoPXBLayer1");
1010  ResidualRefitting::branchMuon(storageTrkNoPXBLayer2, "trkNoPXBLayer2");
1011  ResidualRefitting::branchMuon(storageTrkNoPXBLayer3, "trkNoPXBLayer3");
1012  ResidualRefitting::branchMuon(storageTrkNoPXF, "trkNoPXF");
1013  ResidualRefitting::branchMuon(storageTrkNoTIBLayer1, "trkNoTIBLayer1");
1014  ResidualRefitting::branchMuon(storageTrkNoTIBLayer2, "trkNoTIBLayer2");
1015  ResidualRefitting::branchMuon(storageTrkNoTIBLayer3, "trkNoTIBLayer3");
1016  ResidualRefitting::branchMuon(storageTrkNoTIBLayer4, "trkNoTIBLayer4");
1017  ResidualRefitting::branchMuon(storageTrkNoTID, "trkNoTID");
1018  ResidualRefitting::branchMuon(storageTrkNoTOBLayer1, "trkNoTOBLayer1");
1019  ResidualRefitting::branchMuon(storageTrkNoTOBLayer2, "trkNoTOBLayer2");
1020  ResidualRefitting::branchMuon(storageTrkNoTOBLayer3, "trkNoTOBLayer3");
1021  ResidualRefitting::branchMuon(storageTrkNoTOBLayer4, "trkNoTOBLayer4");
1022  ResidualRefitting::branchMuon(storageTrkNoTOBLayer5, "trkNoTOBLayer5");
1023  ResidualRefitting::branchMuon(storageTrkNoTOBLayer6, "trkNoTOBLayer6");
1024  ResidualRefitting::branchMuon(storageTrkNoTEC, "trkNoTEC");
1025 
1026  outputBranch_ = outputTree_->Branch("recHitsNew",
1027  &storageRecMuon_,
1028 
1029  "n_/I:"
1030  "muonLink_[1000]/I:"
1031 
1032  "system_[1000]/I:"
1033  "endcap_[1000]/I:"
1034  "station_[1000]/I:"
1035  "ring_[1000]/I:"
1036  "chamber_[1000]/I:"
1037  "layer_[1000]/I:"
1038  "superLayer_[1000]/I:"
1039  "wheel_[1000]/I:"
1040  "sector_[1000]/I:"
1041 
1042  "gpX_[1000]/F:"
1043  "gpY_[1000]/F:"
1044  "gpZ_[1000]/F:"
1045  "gpEta_[1000]/F:"
1046  "gpPhi_[1000]/F:"
1047  "lpX_[1000]/F:"
1048  "lpY_[1000]/F:"
1049  "lpZ_[1000]/F");
1050 
1051  outputBranch_ = outputTree_->Branch("recHitsTracker",
1052  &storageTrackHit_,
1053 
1054  "n_/I:"
1055 
1056  "muonLink_[1000]/I:"
1057  "detector_[1000]/I:"
1058  "subdetector_[1000]/I:"
1059  "blade_[1000]/I:"
1060  "disk_[1000]/I:"
1061  "ladder_[1000]/I:"
1062  "layer_[1000]/I:"
1063  "module_[1000]/I:"
1064  "panel_[1000]/I:"
1065  "ring_[1000]/I:"
1066  "side_[1000]/I:"
1067  "wheel_[1000]/I:"
1068 
1069  "gpX_[1000]/F:"
1070  "gpY_[1000]/F:"
1071  "gpZ_[1000]/F:"
1072  "gpEta_[1000]/F:"
1073  "gpPhi_[1000]/F:"
1074  "lpX_[1000]/F:"
1075  "lpY_[1000]/F:"
1076  "lpZ_[1000]/F");
1077 
1078  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRec_, "trkExtrap");
1079  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt1_, "trkExtrapNoSt1");
1080  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt2_, "trkExtrapNoSt2");
1081  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt3_, "trkExtrapNoSt3");
1082  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt4_, "trkExtrapNoSt4");
1083 
1084  ResidualRefitting::branchTrackExtrap(storageTrackExtrapTracker_, "trkExtrapTracker");
1085  ResidualRefitting::branchTrackExtrap(storageTrackNoPXF, "trkExtrapNoPXF");
1086  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer1, "trkExtrapNoPXBLayer1");
1087  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer2, "trkExtrapNoPXBLayer2");
1088  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer3, "trkExtrapNoPXBLayer3");
1089  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer1, "trkExtrapNoTIBLayer1");
1090  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer2, "trkExtrapNoTIBLayer2");
1091  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer3, "trkExtrapNoTIBLayer3");
1092  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer4, "trkExtrapNoTIBLayer4");
1093  ResidualRefitting::branchTrackExtrap(storageTrackNoTID, "trkExtrapNoTID");
1094  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer1, "trkExtrapNoTOBLayer1");
1095  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer2, "trkExtrapNoTOBLayer2");
1096  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer3, "trkExtrapNoTOBLayer3");
1097  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer4, "trkExtrapNoTOBLayer4");
1098  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer5, "trkExtrapNoTOBLayer5");
1099  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer6, "trkExtrapNoTOBLayer6");
1100  ResidualRefitting::branchTrackExtrap(storageTrackNoTEC, "trkExtrapNoTEC");
1101 
1102  ResidualRefitting::branchTrackExtrap(trackExtrap120_, "trackCyl120");
1103  ResidualRefitting::branchTrackExtrap(samExtrap120_, "samCyl120");
1104 }
1105 //
1106 // Set the Muon Branches
1107 //
1108 void ResidualRefitting::branchMuon(ResidualRefitting::storage_muon& storageTmp, std::string branchName) {
1109  outputBranch_ = outputTree_->Branch(branchName.c_str(),
1110  &storageTmp,
1111  "n_/I:"
1112  "charge_[10]/I:"
1113  "pt_[10]/F:"
1114  "eta_[10]/F:"
1115  "p_[10]/F:"
1116  "phi_[10]/F:"
1117  "numRecHits_[10]/I:"
1118  "chiSq_[10]/F:"
1119  "ndf_[10]/F:"
1120  "chiSqOvrNdf_[10]/F"
1121 
1122  );
1123 }
1124 //
1125 // Set the Branches for Track Extrapolations
1126 //
1127 void ResidualRefitting::branchTrackExtrap(ResidualRefitting::storage_trackExtrap& storageTmp, std::string branchName) {
1128  outputBranch_ = outputTree_->Branch(branchName.c_str(),
1129  &storageTmp,
1130  "n_/I:"
1131  "muonLink_[1000]/I:"
1132  "recLink_[1000]/I:"
1133  "gpX_[1000]/F:"
1134  "gpY_[1000]/F:"
1135  "gpZ_[1000]/F:"
1136  "gpEta_[1000]/F:"
1137  "gpPhi_[1000]/F:"
1138  "lpX_[1000]/F:"
1139  "lpY_[1000]/F:"
1140  "lpZ_[1000]/F:"
1141  "resX_[1000]/F:"
1142  "resY_[1000]/F:"
1143  "resZ_[1000]/F"
1144 
1145  );
1146 }
1147 //
1148 // End Job
1149 //
1150 void ResidualRefitting::endJob() {
1151  outputFile_->Write();
1152 
1153  outputFile_->Close();
1154 }
1155 //
1156 // Return a Free Trajectory state for a muon track
1157 //
1158 FreeTrajectoryState ResidualRefitting::freeTrajStateMuon(reco::TrackRef muon) {
1159  math::XYZPoint innerPos = muon->referencePoint();
1160  math::XYZVector innerMom = muon->momentum();
1161  if (debug_)
1162  std::cout << "Inner Pos: "
1163  << "\tx = " << innerPos.X() << "\ty = " << innerPos.Y() << "\tz = " << innerPos.Z() << std::endl;
1164 
1165  GlobalPoint innerPoint(innerPos.X(), innerPos.Y(), innerPos.Z());
1166  GlobalVector innerVec(innerMom.X(), innerMom.Y(), innerMom.Z());
1167 
1168  FreeTrajectoryState recoStart(innerPoint, innerVec, muon->charge(), theField);
1169  return recoStart;
1170 }
1171 
1173 // nTuple value Dumps
1175 
1176 //
1177 // dump Track Extrapolation
1178 //
1179 void ResidualRefitting::dumpTrackExtrap(const ResidualRefitting::storage_trackExtrap& track) {
1180  std::cout << "\n\nExtrapolation Dump:\n";
1181  for (unsigned int i = 0; i < (unsigned int)track.n_; i++) {
1182  // double rho = sqrt( (float)track.gpX_[i] * (float)track.gpX_[i] + (float)track.gpY_[i] * (float)track.gpY_[i] );
1183 
1184  printf("%d\tmuonLink= %d", i, (int)track.muonLink_[i]);
1185  printf("\trecLink = %d", (int)track.recLink_[i]);
1186  // printf ("\tGlobal\tx = %0.3f" , (float)track.gpX_[i] );
1187  // printf ("\ty = %0.3f" , (float)track.gpY_[i] );
1188  // printf ("\tz = %0.3f" , (float)track.gpZ_[i] );
1189  // printf ("\trho =%0.3f" , rho );
1190  // printf ("\teta = %0.3f" , (float)track.gpEta_[i] );
1191  // printf ("\tphi = %0.3f" , (float)track.gpPhi_[i] );
1192  printf("\t\tLocal\tx = %0.3f", (float)track.lpX_[i]);
1193  printf("\ty = %0.3f", (float)track.lpY_[i]);
1194  printf("\tz = %0.3f\n", (float)track.lpZ_[i]);
1195  }
1196 }
1197 //
1198 // dump Muon Rec Hits
1199 //
1200 void ResidualRefitting::dumpMuonRecHits(const ResidualRefitting::storage_hit& hit) {
1201  std::cout << "Muon Rec Hits Dump:\n";
1202  for (unsigned int i = 0; i < (unsigned int)hit.n_; i++) {
1203  // double rho = sqrt( (float)hit.gpX_[i] * (float)hit.gpX_[i] + (float)hit.gpY_[i] * (float)hit.gpY_[i] );
1204 
1205  printf("%d\tsubdetector = %d\t superLayer =%d", i, (int)hit.system_[i], (int)hit.superLayer_[i]);
1206  // printf ("\tGlobal\tx = %0.3f" , (float)hit.gpX_[i] );
1207  // printf ("\ty = %0.3f" , (float)hit.gpY_[i] );
1208  // printf ("\tz = %0.3f" , (float)hit.gpZ_[i] );
1209  // printf ("\trho =%0.3f" , rho );
1210  // printf ("\teta = %0.3f" , (float)hit.gpEta_[i] );
1211  // printf ("\tphi = %0.3f\n" , (float)hit.gpPhi_[i] );
1212  printf("\t\tLocal\tx = %0.3f", (float)hit.lpX_[i]);
1213  printf("\ty = %0.3f", (float)hit.lpY_[i]);
1214  printf("\tz = %0.3f\n", (float)hit.lpZ_[i]);
1215  }
1216 }
1217 //
1218 // dump Tracker Rec Hits
1219 //
1220 void ResidualRefitting::dumpTrackHits(const ResidualRefitting::storage_trackHit& hit) {
1221  std::cout << "Tracker Rec Hits Dump:\n";
1222  for (unsigned int i = 0; i < (unsigned int)hit.n_; i++) {
1223  // double rho = sqrt( (float)hit.gpX_[i] * (float)hit.gpX_[i] + (float)hit.gpY_[i] * (float)hit.gpY_[i] );
1224 
1225  printf("%d\tsubdetector = %d", i, (int)hit.subdetector_[i]);
1226  printf("\tlayer = %d", (int)hit.layer_[i]);
1227  // printf ("\tGlobal\tx = %0.3f" , (float)hit.gpX_[i] );
1228  // printf ("\ty = %0.3f" , (float)hit.gpY_[i] );
1229  // printf ("\tz = %0.3f" , (float)hit.gpZ_[i] );
1230  // printf ("\trho =%0.3f" , rho );
1231  // printf ("\teta = %0.3f" , (float)hit.gpEta_[i] );
1232  // printf ("\tphi = %0.3f\n" , (float)hit.gpPhi_[i] );
1233  printf("\t\tLocal\tx = %0.3f", (float)hit.lpX_[i]);
1234  printf("\ty = %0.3f", (float)hit.lpY_[i]);
1235  printf("\tz = %0.3f\n", (float)hit.lpZ_[i]);
1236  }
1237 }
1238 //
1239 //Dump a TrackRef
1240 //
1241 void ResidualRefitting::dumpTrackRef(reco::TrackRef muon, std::string str) {
1242  float pt = muon->pt();
1243  float p = muon->p();
1244  float eta = muon->eta();
1245  float phi = muon->phi();
1246  printf("\t%s: \tp = %4.2f \t pt = %4.2f \t eta = %4.2f \t phi = %4.2f\n", str.c_str(), p, pt, eta, phi);
1247 }
1248 
1249 DEFINE_FWK_MODULE(ResidualRefitting);
1250 
1252 //Deprecated
Vector3DBase
Definition: Vector3DBase.h:8
ResidualRefitting::StorageTrackHit
Definition: ResidualRefitting.h:172
ResidualRefitting::storageGmrNoPXF
ResidualRefitting::storage_muon storageGmrNoPXF
Definition: ResidualRefitting.h:224
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
TkRotation< float >
ResidualRefitting::storageTrkNoPXBLayer3
ResidualRefitting::storage_muon storageTrkNoPXBLayer3
Definition: ResidualRefitting.h:224
ResidualRefitting::storageGmrNoTIBLayer1
ResidualRefitting::storage_muon storageGmrNoTIBLayer1
Definition: ResidualRefitting.h:224
TrajectoryStateOnSurface.h
ResidualRefitting::PXB
static const int PXB
Definition: ResidualRefitting.h:43
ResidualRefitting::StoreTrackerRecHits
void StoreTrackerRecHits(DetId detid, const TrackerTopology *tTopo, int iTrack, int iRec)
Definition: ResidualRefitting.cc:557
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
pfDisplacedTrackerVertex_cfi.trackColl
trackColl
Definition: pfDisplacedTrackerVertex_cfi.py:6
electrons_cff.bool
bool
Definition: electrons_cff.py:372
ResidualRefitting::StorageTrackHit::disk_
int disk_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:179
mps_fire.i
i
Definition: mps_fire.py:355
ResidualRefitting::dumpTrackRef
void dumpTrackRef(reco::TrackRef muon, std::string str)
Definition: ResidualRefitting.cc:1241
ResidualRefitting::StorageHit::station_
int station_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:95
ResidualRefitting::dumpMuonRecHits
void dumpMuonRecHits(const ResidualRefitting::storage_hit &hit)
Definition: ResidualRefitting.cc:1200
MuonTransientTrackingRecHit::specificBuild
static MuonRecHitPointer specificBuild(const GeomDet *geom, const TrackingRecHit *rh)
Definition: MuonTransientTrackingRecHit.h:75
ResidualRefitting::storageGmrNoPXBLayer1
ResidualRefitting::storage_muon storageGmrNoPXBLayer1
Definition: ResidualRefitting.h:224
ResidualRefitting::storageGmrNoTOBLayer5
ResidualRefitting::storage_muon storageGmrNoTOBLayer5
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageTrackExtrap::lpX_
float lpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:146
ResidualRefitting::StorageTrackExtrap::gpX_
float gpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:141
GeomDet
Definition: GeomDet.h:27
ResidualRefitting::storageTrackNoTIBLayer3
ResidualRefitting::storage_trackExtrap storageTrackNoTIBLayer3
Definition: ResidualRefitting.h:251
ResidualRefitting::storageTrkNoTOBLayer4
ResidualRefitting::storage_muon storageTrkNoTOBLayer4
Definition: ResidualRefitting.h:224
KalmanVertexFitter.h
ESHandle.h
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:192
muon
Definition: MuonCocktails.h:17
ResidualRefitting::storageTrkNoTOBLayer6
ResidualRefitting::storage_muon storageTrkNoTOBLayer6
Definition: ResidualRefitting.h:224
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
ResidualRefitting::StorageTrackHit::panel_
int panel_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:183
ResidualRefitting::StorageHit::system_
int system_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:93
ResidualRefitting::theField
const MagneticField * theField
Definition: ResidualRefitting.h:347
relativeConstraints.station
station
Definition: relativeConstraints.py:67
ResidualRefitting::StorageTrackHit::lpY_
float lpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:194
electrons_cff.branchName
branchName
Definition: electrons_cff.py:492
edm
HLT enums.
Definition: AlignableModifier.h:19
ResidualRefitting::zero_trackExtrap
void zero_trackExtrap(ResidualRefitting::storage_trackExtrap *str)
Definition: ResidualRefitting.cc:945
TrackerTopology
Definition: TrackerTopology.h:16
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
ResidualRefitting::StorageTrackHit::side_
int side_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:185
ResidualRefitting::CollectTrackHits
void CollectTrackHits(edm::Handle< reco::TrackCollection > trackColl, ResidualRefitting::storage_trackExtrap &trackExtrap, const edm::EventSetup &eventSetup)
Definition: ResidualRefitting.cc:268
ResidualRefitting::ReturnStation
int ReturnStation(DetId detid)
Definition: ResidualRefitting.cc:739
DetId::det
constexpr Detector det() const
get the detector field from this detid
Definition: DetId.h:46
ResidualRefitting::storageGmrNoTOBLayer1
ResidualRefitting::storage_muon storageGmrNoTOBLayer1
Definition: ResidualRefitting.h:224
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
RPCDetId
Definition: RPCDetId.h:16
TrajectoryStateOnSurface::globalPosition
GlobalPoint globalPosition() const
Definition: TrajectoryStateOnSurface.h:65
ResidualRefitting::StorageTrackExtrap::gpPhi_
float gpPhi_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:145
gather_cfg.cout
cout
Definition: gather_cfg.py:144
pos
Definition: PixelAliasList.h:18
ResidualRefitting::StorageMuon::phi_
float phi_[N_MAX_STORED]
Definition: ResidualRefitting.h:68
ZElectronSkim_cff.rho
rho
Definition: ZElectronSkim_cff.py:38
ResidualRefitting::storageTrackNoTEC
ResidualRefitting::storage_trackExtrap storageTrackNoTEC
Definition: ResidualRefitting.h:251
ResidualRefitting::TEC
static const int TEC
Definition: ResidualRefitting.h:48
ResidualRefitting.h
ResidualRefitting::StorageTrackHit::gpY_
float gpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:189
ResidualRefitting::StorageMuon::numRecHits_
int numRecHits_[N_MAX_STORED]
Definition: ResidualRefitting.h:69
ResidualRefitting::storageTrackNoTOBLayer4
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer4
Definition: ResidualRefitting.h:251
ResidualRefitting::storageTrackNoTIBLayer4
ResidualRefitting::storage_trackExtrap storageTrackNoTIBLayer4
Definition: ResidualRefitting.h:251
ResidualRefitting::StorageHit::chamber_
int chamber_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:97
ResidualRefitting::storageTrkNoTID
ResidualRefitting::storage_muon storageTrkNoTID
Definition: ResidualRefitting.h:224
ResidualRefitting::zero_muon
void zero_muon(ResidualRefitting::storage_muon *str)
Definition: ResidualRefitting.cc:928
ResidualRefitting::storageTrackExtrapTracker_
ResidualRefitting::storage_trackExtrap storageTrackExtrapTracker_
Definition: ResidualRefitting.h:251
ResidualRefitting::storageTrkNoTIBLayer2
ResidualRefitting::storage_muon storageTrkNoTIBLayer2
Definition: ResidualRefitting.h:224
GlobalTrackingGeometryRecord
Definition: GlobalTrackingGeometryRecord.h:17
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:71
ResidualRefitting::endJob
void endJob() override
Definition: ResidualRefitting.cc:1150
ResidualRefitting::storageTrackExtrapRec_
ResidualRefitting::storage_trackExtrap storageTrackExtrapRec_
Definition: ResidualRefitting.h:244
ResidualRefitting::StorageHit::superLayer_
int superLayer_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:99
ResidualRefitting::ReturnSector
int ReturnSector(DetId detid)
Definition: ResidualRefitting.cc:763
ResidualRefitting::StorageTrackExtrap::n_
int n_
Definition: ResidualRefitting.h:137
ResidualRefitting::StorageHit::n_
int n_
Definition: ResidualRefitting.h:90
ResidualRefitting::N_MAX_STORED
static const int N_MAX_STORED
Definition: ResidualRefitting.h:40
ResidualRefitting::StorageHit
Definition: ResidualRefitting.h:89
ReferenceCountingPointer< Cylinder >
ResidualRefitting::PropagatorSource_
std::string PropagatorSource_
Definition: ResidualRefitting.h:327
ResidualRefitting::StorageTrackExtrap::recLink_
int recLink_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:140
ResidualRefitting::storageGmrNoSt1_
ResidualRefitting::storage_muon storageGmrNoSt1_
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageTrackExtrap::resY_
float resY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:150
MuonDetLayerGeometry.h
MuonTransientTrackingRecHit.h
ResidualRefitting::storageTrackNoTOBLayer6
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer6
Definition: ResidualRefitting.h:251
ResidualRefitting::storageTrackExtrapRecNoSt1_
ResidualRefitting::storage_trackExtrap storageTrackExtrapRecNoSt1_
Definition: ResidualRefitting.h:244
makeMuonMisalignmentScenario.endcap
endcap
Definition: makeMuonMisalignmentScenario.py:320
ResidualRefitting::StorageHit::ring_
int ring_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:96
ResidualRefitting::outputFile_
TFile * outputFile_
Definition: ResidualRefitting.h:340
ResidualRefitting::storageTrackExtrapRecNoSt3_
ResidualRefitting::storage_trackExtrap storageTrackExtrapRecNoSt3_
Definition: ResidualRefitting.h:244
edm::Handle< reco::MuonCollection >
TrackingRecHit::localPosition
virtual LocalPoint localPosition() const =0
ResidualRefitting::storageTrackNoPXBLayer1
ResidualRefitting::storage_trackExtrap storageTrackNoPXBLayer1
Definition: ResidualRefitting.h:251
ResidualRefitting
Definition: ResidualRefitting.h:39
ResidualRefitting::StorageHit::gpX_
float gpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:103
MuonServiceProxy_cff.MuonServiceProxy
MuonServiceProxy
Definition: MuonServiceProxy_cff.py:15
ResidualRefitting::StorageTrackExtrap::resZ_
float resZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:151
ResidualRefitting::storageTrackNoTIBLayer2
ResidualRefitting::storage_trackExtrap storageTrackNoTIBLayer2
Definition: ResidualRefitting.h:251
TrackerTopology::tidRing
unsigned int tidRing(const DetId &id) const
Definition: TrackerTopology.h:218
ResidualRefitting::StorageHit::gpZ_
float gpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:105
CSCDetId.h
edm::Ref< TrackCollection >
TrackerTopology::tidWheel
unsigned int tidWheel(const DetId &id) const
Definition: TrackerTopology.h:201
ResidualRefitting::StorageTrackExtrap::lpZ_
float lpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:148
ResidualRefitting::TID
static const int TID
Definition: ResidualRefitting.h:46
ResidualRefitting::storageGmrNoTID
ResidualRefitting::storage_muon storageGmrNoTID
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageTrackHit::n_
int n_
Definition: ResidualRefitting.h:173
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
ResidualRefitting::storageGmrNoTOBLayer4
ResidualRefitting::storage_muon storageGmrNoTOBLayer4
Definition: ResidualRefitting.h:224
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
TrackerTopology::pxfPanel
unsigned int pxfPanel(const DetId &id) const
Definition: TrackerTopology.h:450
EDMException.h
ResidualRefitting::StorageTrackHit::wheel_
int wheel_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:186
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
ResidualRefitting::storageTrackHit_
ResidualRefitting::storage_trackHit storageTrackHit_
Definition: ResidualRefitting.h:241
ResidualRefitting::muonsNoStation2_
edm::InputTag muonsNoStation2_
Definition: ResidualRefitting.h:330
DetId
Definition: DetId.h:17
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
ResidualRefitting::storageTrackNoTOBLayer2
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer2
Definition: ResidualRefitting.h:251
MakerMacros.h
TrackerTopology.h
ResidualRefitting::storageGmrNoTOBLayer6
ResidualRefitting::storage_muon storageGmrNoTOBLayer6
Definition: ResidualRefitting.h:224
ResidualRefitting::storageGmrNoSt3_
ResidualRefitting::storage_muon storageGmrNoSt3_
Definition: ResidualRefitting.h:224
ResidualRefitting::trkExtrap
void trkExtrap(const DetId &detid, int iTrkLink, int iTrk, int iRec, const FreeTrajectoryState &freeTrajState, const LocalPoint &recPoint, storage_trackExtrap &storeTemp)
Definition: ResidualRefitting.cc:663
ResidualRefitting::outputBranch_
TBranch * outputBranch_
Definition: ResidualRefitting.h:343
TrackerTopologyRcd.h
ResidualRefitting::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: ResidualRefitting.cc:79
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
ResidualRefitting::storageTrkNoTOBLayer5
ResidualRefitting::storage_muon storageTrkNoTOBLayer5
Definition: ResidualRefitting.h:224
ResidualRefitting::storageSamNoSt4_
ResidualRefitting::storage_muon storageSamNoSt4_
Definition: ResidualRefitting.h:224
ResidualRefitting::TOB
static const int TOB
Definition: ResidualRefitting.h:47
DTWireId
Definition: DTWireId.h:12
ResidualRefitting::StorageMuon::chiSq_
float chiSq_[N_MAX_STORED]
Definition: ResidualRefitting.h:70
ResidualRefitting::outputTree_
TTree * outputTree_
Definition: ResidualRefitting.h:342
PVValHelper::eta
Definition: PVValidationHelpers.h:69
ResidualRefitting::N_MAX_STORED_HIT
static const int N_MAX_STORED_HIT
Definition: ResidualRefitting.h:41
ResidualRefitting::storageTrackExtrapRecNoSt2_
ResidualRefitting::storage_trackExtrap storageTrackExtrapRecNoSt2_
Definition: ResidualRefitting.h:244
ResidualRefitting::StorageTrackExtrap
Definition: ResidualRefitting.h:136
ResidualRefitting::storageGmrNoTOBLayer2
ResidualRefitting::storage_muon storageGmrNoTOBLayer2
Definition: ResidualRefitting.h:224
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
ResidualRefitting::debug_
bool debug_
Definition: ResidualRefitting.h:337
str
#define str(s)
Definition: TestProcessor.cc:48
ResidualRefitting::StorageTrackHit::muonLink_
int muonLink_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:175
edm::ESHandle< MagneticField >
ResidualRefitting::StorageTrackHit::lpZ_
float lpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:195
ResidualRefitting::storageTrkNoPXF
ResidualRefitting::storage_muon storageTrkNoPXF
Definition: ResidualRefitting.h:224
ResidualRefitting::muonsNoStation1_
edm::InputTag muonsNoStation1_
Definition: ResidualRefitting.h:330
ResidualRefitting::storageGmrNoSt4_
ResidualRefitting::storage_muon storageGmrNoSt4_
Definition: ResidualRefitting.h:224
ResidualRefitting::storageTrackExtrapRecNoSt4_
ResidualRefitting::storage_trackExtrap storageTrackExtrapRecNoSt4_
Definition: ResidualRefitting.h:244
ResidualRefitting::storageGmrNoTEC
ResidualRefitting::storage_muon storageGmrNoTEC
Definition: ResidualRefitting.h:224
ResidualRefitting::NewTrackMeasurements
void NewTrackMeasurements(edm::Handle< reco::TrackCollection > trackCollOrig, edm::Handle< reco::TrackCollection > trackColl, ResidualRefitting::storage_trackExtrap &trackExtrap)
Definition: ResidualRefitting.cc:425
ResidualRefitting::StorageMuon::chiSqOvrNdf_
float chiSqOvrNdf_[N_MAX_STORED]
Definition: ResidualRefitting.h:72
ResidualRefitting::branchMuon
void branchMuon(ResidualRefitting::storage_muon &storageTmp, std::string branchName)
Definition: ResidualRefitting.cc:1108
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
ResidualRefitting::storage_event::evtNum_
int evtNum_
Definition: ResidualRefitting.h:55
ResidualRefitting::MatchTrackWithRecHits
int MatchTrackWithRecHits(reco::TrackCollection::const_iterator trackIt, edm::Handle< reco::TrackCollection > ref)
Definition: ResidualRefitting.cc:467
ResidualRefitting::storageSamNew_
ResidualRefitting::storage_muon storageSamNew_
Definition: ResidualRefitting.h:224
Point3DBase< float, LocalTag >
ResidualRefitting::StorageTrackExtrap::lpY_
float lpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:147
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
DDAxes::rho
ResidualRefitting::dumpTrackExtrap
void dumpTrackExtrap(const ResidualRefitting::storage_trackExtrap &track)
Definition: ResidualRefitting.cc:1179
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
ResidualRefitting::StorageHit::lpZ_
float lpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:110
ResidualRefitting::StorageHit::gpPhi_
float gpPhi_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:107
RPCDetId.h
ResidualRefitting::StorageTrackExtrap::gpEta_
float gpEta_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:144
MuonServiceProxy::update
void update(const edm::EventSetup &setup, bool duringEvent=true)
update the services each event
Definition: MuonServiceProxy.cc:111
runTauDisplay.gp
gp
Definition: runTauDisplay.py:431
ResidualRefitting::outputFileName_
std::string outputFileName_
Definition: ResidualRefitting.h:325
ResidualRefitting::muonsRemake_
edm::InputTag muonsRemake_
Definition: ResidualRefitting.h:330
ResidualRefitting::StorageHit::wheel_
int wheel_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:100
TrajectoryStateOnSurface::localPosition
LocalPoint localPosition() const
Definition: TrajectoryStateOnSurface.h:74
ResidualRefitting::StorageHit::gpEta_
float gpEta_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:106
ResidualRefitting::StorageTrackExtrap::resX_
float resX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:149
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
ResidualRefitting::StorageHit::endcap_
int endcap_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:94
edm::ParameterSet
Definition: ParameterSet.h:36
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
ResidualRefitting::StorageTrackHit::gpEta_
float gpEta_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:191
DetId::Tracker
Definition: DetId.h:25
Event.h
ResidualRefitting::storageGmrNoSt2_
ResidualRefitting::storage_muon storageGmrNoSt2_
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageMuon
Definition: ResidualRefitting.h:61
ResidualRefitting::StorageTrackHit::ring_
int ring_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:184
ResidualRefitting::StorageTrackExtrap::gpY_
float gpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:142
ResidualRefitting::StorageMuon::p_
float p_[N_MAX_STORED]
Definition: ResidualRefitting.h:67
ResidualRefitting::storage_event::runNum_
int runNum_
Definition: ResidualRefitting.h:56
ResidualRefitting::muonsNoStation3_
edm::InputTag muonsNoStation3_
Definition: ResidualRefitting.h:330
ResidualRefitting::muonInfo
void muonInfo(ResidualRefitting::storage_muon &storeMuon, reco::TrackRef muon, int val)
Definition: ResidualRefitting.cc:649
CSCDetId
Definition: CSCDetId.h:26
ResidualRefitting::StorageTrackExtrap::muonLink_
int muonLink_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:139
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
ResidualRefitting::StorageHit::gpY_
float gpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:104
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
Cylinder::build
static CylinderPointer build(const PositionType &pos, const RotationType &rot, Scalar radius, Bounds *bounds=nullptr)
Definition: Cylinder.h:45
TrackerTopology::tibModule
unsigned int tibModule(const DetId &id) const
Definition: TrackerTopology.h:172
TrackerTopology::tidSide
unsigned int tidSide(const DetId &id) const
Definition: TrackerTopology.h:190
ResidualRefitting::ResidualRefitting
ResidualRefitting(const edm::ParameterSet &)
Definition: ResidualRefitting.cc:37
makeMuonMisalignmentScenario.wheel
wheel
Definition: makeMuonMisalignmentScenario.py:319
createfilelist.int
int
Definition: createfilelist.py:10
TrackerTopology::tecRing
unsigned int tecRing(const DetId &id) const
ring id
Definition: TrackerTopology.h:217
ResidualRefitting::storageGmrOld_
ResidualRefitting::storage_muon storageGmrOld_
Definition: ResidualRefitting.h:224
TrackerTopology::pxfModule
unsigned int pxfModule(const DetId &id) const
Definition: TrackerTopology.h:163
ResidualRefitting::~ResidualRefitting
~ResidualRefitting() override
Definition: ResidualRefitting.cc:261
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:446
ResidualRefitting::storageTrkNoPXBLayer2
ResidualRefitting::storage_muon storageTrkNoPXBLayer2
Definition: ResidualRefitting.h:224
ResidualRefitting::storageTrkNoTOBLayer1
ResidualRefitting::storage_muon storageTrkNoTOBLayer1
Definition: ResidualRefitting.h:224
ResidualRefitting::storageTrkNoTEC
ResidualRefitting::storage_muon storageTrkNoTEC
Definition: ResidualRefitting.h:224
edm::EventSetup
Definition: EventSetup.h:57
ResidualRefitting::StorageMuon::ndf_
float ndf_[N_MAX_STORED]
Definition: ResidualRefitting.h:71
Propagator::propagate
TrajectoryStateOnSurface propagate(STA const &state, SUR const &surface) const
Definition: Propagator.h:50
module
Definition: vlib.h:198
get
#define get
ResidualRefitting::muons_
edm::InputTag muons_
Definition: ResidualRefitting.h:330
ResidualRefitting::storageGmrNoTOBLayer3
ResidualRefitting::storage_muon storageGmrNoTOBLayer3
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageTrackHit::layer_
int layer_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:181
MuonSubdetId.h
ResidualRefitting::theService
MuonServiceProxy * theService
Definition: ResidualRefitting.h:349
ResidualRefitting::storageGmrNoTIBLayer3
ResidualRefitting::storage_muon storageGmrNoTIBLayer3
Definition: ResidualRefitting.h:224
looper.cfg
cfg
Definition: looper.py:297
ResidualRefitting::storageGmrNoPXBLayer2
ResidualRefitting::storage_muon storageGmrNoPXBLayer2
Definition: ResidualRefitting.h:224
TrackingRecHit
Definition: TrackingRecHit.h:21
ResidualRefitting::StorageTrackHit::blade_
int blade_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:178
ResidualRefitting::StorageTrackHit::ladder_
int ladder_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:180
ResidualRefitting::freeTrajStateMuon
FreeTrajectoryState freeTrajStateMuon(reco::TrackRef muon)
Definition: ResidualRefitting.cc:1158
DDAxes::phi
ResidualRefitting::storageGmrNoTIBLayer2
ResidualRefitting::storage_muon storageGmrNoTIBLayer2
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageHit::sector_
int sector_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:101
GeomDet.h
TrackerTopology::tobLayer
unsigned int tobLayer(const DetId &id) const
Definition: TrackerTopology.h:147
ResidualRefitting::storageTrkNew_
ResidualRefitting::storage_muon storageTrkNew_
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageMuon::eta_
float eta_[N_MAX_STORED]
Definition: ResidualRefitting.h:66
heppy_batch.val
val
Definition: heppy_batch.py:351
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
ResidualRefitting::trackExtrap120_
ResidualRefitting::storage_trackExtrap trackExtrap120_
Definition: ResidualRefitting.h:248
ResidualRefitting::storageGmrNoPXBLayer3
ResidualRefitting::storage_muon storageGmrNoPXBLayer3
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageTrackHit::module_
int module_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:182
TrackerTopology::tobModule
unsigned int tobModule(const DetId &id) const
Definition: TrackerTopology.h:166
ResidualRefitting::PXF
static const int PXF
Definition: ResidualRefitting.h:44
DTWireId.h
TrackerTopology::pxbModule
unsigned int pxbModule(const DetId &id) const
Definition: TrackerTopology.h:160
FreeTrajectoryState
Definition: FreeTrajectoryState.h:27
ResidualRefitting::storageTrkNoPXBLayer1
ResidualRefitting::storage_muon storageTrkNoPXBLayer1
Definition: ResidualRefitting.h:224
MuonSubdetId::RPC
static constexpr int RPC
Definition: MuonSubdetId.h:13
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
MuonTransientTrackingRecHitBuilder.h
ResidualRefitting::storageTrackNoTID
ResidualRefitting::storage_trackExtrap storageTrackNoTID
Definition: ResidualRefitting.h:251
MuonServiceProxy::trackingGeometry
edm::ESHandle< GlobalTrackingGeometry > trackingGeometry() const
get the tracking geometry
Definition: MuonServiceProxy.h:59
ResidualRefitting::eventInfo_
ResidualRefitting::storage_event eventInfo_
Definition: ResidualRefitting.h:59
TrackingComponentsRecord.h
ResidualRefitting::storageTrkNoTOBLayer2
ResidualRefitting::storage_muon storageTrkNoTOBLayer2
Definition: ResidualRefitting.h:224
ResidualRefitting::StorageMuon::pt_
float pt_[N_MAX_STORED]
Definition: ResidualRefitting.h:65
GlobalTrackingGeometry::idToDet
const GeomDet * idToDet(DetId) const override
Definition: GlobalTrackingGeometry.cc:44
ResidualRefitting::storageRecMuon_
ResidualRefitting::storage_hit storageRecMuon_
Definition: ResidualRefitting.h:240
ResidualRefitting::StorageTrackHit::gpX_
float gpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:188
ResidualRefitting::storageGmrNew_
ResidualRefitting::storage_muon storageGmrNew_
Definition: ResidualRefitting.h:224
ResidualRefitting::storageTrackNoPXBLayer2
ResidualRefitting::storage_trackExtrap storageTrackNoPXBLayer2
Definition: ResidualRefitting.h:251
PVValHelper::ladder
Definition: PVValidationHelpers.h:72
relativeConstraints.ring
ring
Definition: relativeConstraints.py:68
makeMuonMisalignmentScenario.rot
rot
Definition: makeMuonMisalignmentScenario.py:322
ResidualRefitting::dumpTrackHits
void dumpTrackHits(const ResidualRefitting::storage_trackHit &hit)
Definition: ResidualRefitting.cc:1220
DetLayer.h
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
ResidualRefitting::thePropagator
edm::ESHandle< Propagator > thePropagator
Definition: ResidualRefitting.h:350
EventSetup.h
ResidualRefitting::storageTrackNoTOBLayer3
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer3
Definition: ResidualRefitting.h:251
ResidualRefitting::cylExtrapTrkSam
void cylExtrapTrkSam(int recNum, reco::TrackRef track, ResidualRefitting::storage_trackExtrap &storage, double rho)
Definition: ResidualRefitting.cc:780
ResidualRefitting::storageTrkNoTIBLayer4
ResidualRefitting::storage_muon storageTrkNoTIBLayer4
Definition: ResidualRefitting.h:224
TrajectoryStateTransform.h
ResidualRefitting::StorageHit::muonLink_
int muonLink_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:91
GeomDetEnumerators.h
TrackerTopology::tecModule
unsigned int tecModule(const DetId &id) const
Definition: TrackerTopology.h:169
ResidualRefitting::zero_storage
void zero_storage()
Definition: ResidualRefitting.cc:828
ResidualRefitting::storageSamNoSt3_
ResidualRefitting::storage_muon storageSamNoSt3_
Definition: ResidualRefitting.h:224
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
ResidualRefitting::StorageMuon::charge_
int charge_[N_MAX_STORED]
Definition: ResidualRefitting.h:64
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
TrackerTopology::pxfBlade
unsigned int pxfBlade(const DetId &id) const
Definition: TrackerTopology.h:447
ResidualRefitting::storageTrkNoTIBLayer3
ResidualRefitting::storage_muon storageTrkNoTIBLayer3
Definition: ResidualRefitting.h:224
ConsumesCollector.h
DetId::Muon
Definition: DetId.h:26
ResidualRefitting::storageTrackNoTIBLayer1
ResidualRefitting::storage_trackExtrap storageTrackNoTIBLayer1
Definition: ResidualRefitting.h:251
ResidualRefitting::StorageTrackHit::gpPhi_
float gpPhi_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:192
ResidualRefitting::StorageTrackHit::lpX_
float lpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:193
TrackerTopologyRcd
Definition: TrackerTopologyRcd.h:10
ResidualRefitting::beginJob
void beginJob() override
Definition: ResidualRefitting.cc:966
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:53
ParameterSet.h
ResidualRefitting::StorageMuon::n_
int n_
Definition: ResidualRefitting.h:62
ResidualRefitting::storageTrackNoTOBLayer1
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer1
Definition: ResidualRefitting.h:251
event
Definition: event.py:1
ResidualRefitting::storageTrackNoPXBLayer3
ResidualRefitting::storage_trackExtrap storageTrackNoPXBLayer3
Definition: ResidualRefitting.h:251
GlobalTrackingGeometry.h
ResidualRefitting::branchTrackExtrap
void branchTrackExtrap(ResidualRefitting::storage_trackExtrap &storageTmp, std::string branchName)
Definition: ResidualRefitting.cc:1127
ResidualRefitting::storageSamNoSt2_
ResidualRefitting::storage_muon storageSamNoSt2_
Definition: ResidualRefitting.h:224
edm::Event
Definition: Event.h:73
ResidualRefitting::StorageHit::layer_
int layer_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:98
ResidualRefitting::storageTrkNoTOBLayer3
ResidualRefitting::storage_muon storageTrkNoTOBLayer3
Definition: ResidualRefitting.h:224
ResidualRefitting::storageTrackNoTOBLayer5
ResidualRefitting::storage_trackExtrap storageTrackNoTOBLayer5
Definition: ResidualRefitting.h:251
ResidualRefitting::StorageHit::lpY_
float lpY_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:109
ResidualRefitting::samExtrap120_
ResidualRefitting::storage_trackExtrap samExtrap120_
Definition: ResidualRefitting.h:248
ResidualRefitting::storageTrackNoPXF
ResidualRefitting::storage_trackExtrap storageTrackNoPXF
Definition: ResidualRefitting.h:251
ResidualRefitting::storageSamNoSt1_
ResidualRefitting::storage_muon storageSamNoSt1_
Definition: ResidualRefitting.h:224
ResidualRefitting::storageGmrNoTIBLayer4
ResidualRefitting::storage_muon storageGmrNoTIBLayer4
Definition: ResidualRefitting.h:224
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
ResidualRefitting::StorageHit::lpX_
float lpX_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:108
ResidualRefitting::StorageTrackHit::subdetector_
int subdetector_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:177
TrajectoryStateOnSurface::isValid
bool isValid() const
Definition: TrajectoryStateOnSurface.h:54
hit
Definition: SiStripHitEffFromCalibTree.cc:88
ResidualRefitting::TIB
static const int TIB
Definition: ResidualRefitting.h:45
ResidualRefitting::StorageTrackExtrap::gpZ_
float gpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:143
ResidualRefitting::IsSameHit
bool IsSameHit(TrackingRecHit const &hit1, TrackingRecHit const &hit2)
Definition: ResidualRefitting.cc:533
ResidualRefitting::StorageTrackHit::detector_
int detector_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:176
ResidualRefitting::storageTrkNoTIBLayer1
ResidualRefitting::storage_muon storageTrkNoTIBLayer1
Definition: ResidualRefitting.h:224
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
ResidualRefitting::muonsNoStation4_
edm::InputTag muonsNoStation4_
Definition: ResidualRefitting.h:330
TrackerTopology::tibLayer
unsigned int tibLayer(const DetId &id) const
Definition: TrackerTopology.h:150
ResidualRefitting::StorageTrackHit::gpZ_
float gpZ_[N_MAX_STORED_HIT]
Definition: ResidualRefitting.h:190
TrackingComponentsRecord
Definition: TrackingComponentsRecord.h:12
subdetector
TString subdetector
Definition: trackSplitPlot.h:54
Generated for CMSSW Reference Manual by doxygen 1.8.16