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