CMS 3D CMS Logo
TrackExtenderWithMTD.cc
Go to the documentation of this file.
1 #include "FWCore/Framework/interface/Frameworkfwd.h"
2 #include "FWCore/Framework/interface/stream/EDProducer.h"
3 #include "FWCore/Framework/interface/Event.h"
4 #include "FWCore/Framework/interface/EventSetup.h"
5 #include "FWCore/Framework/interface/ESHandle.h"
6 #include "FWCore/ParameterSet/interface/ParameterSet.h"
7 
8 #include "RecoMTD/DetLayers/interface/MTDDetLayerGeometry.h"
9 #include "RecoMTD/Records/interface/MTDRecoGeometryRecord.h"
10 
11 #include "MagneticField/Engine/interface/MagneticField.h"
12 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
13 
14 #include "TrackingTools/KalmanUpdators/interface/Chi2MeasurementEstimator.h"
15 
16 #include "DataFormats/TrackerRecHit2D/interface/MTDTrackingRecHit.h"
17 
18 #include "RecoMTD/DetLayers/interface/MTDTrayBarrelLayer.h"
19 #include "RecoMTD/DetLayers/interface/MTDDetTray.h"
20 #include "RecoMTD/DetLayers/interface/MTDRingForwardDoubleLayer.h"
21 #include "RecoMTD/DetLayers/interface/MTDDetRing.h"
22 
23 #include "DataFormats/ForwardDetId/interface/BTLDetId.h"
24 #include "DataFormats/ForwardDetId/interface/ETLDetId.h"
25 #include "DataFormats/ForwardDetId/interface/MTDChannelIdentifier.h"
26 #include "Geometry/CommonTopologies/interface/PixelTopology.h"
27 
28 #include "TrackingTools/PatternTools/interface/Trajectory.h"
29 
30 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
31 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
32 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
33 
34 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
35 
36 #include "RecoMTD/TransientTrackingRecHit/interface/MTDTransientTrackingRecHitBuilder.h"
37 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"
38 
39 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
40 #include "TrackingTools/GeomPropagators/interface/Propagator.h"
41 
42 #include "TrackingTools/PatternTools/interface/TSCBLBuilderWithPropagator.h"
43 
44 #include "RecoTracker/TransientTrackingRecHit/interface/Traj2TrackHits.h"
45 #include "TrackingTools/TrackRefitter/interface/TrackTransformer.h"
46 
47 #include <sstream>
48 
49 #include "Geometry/CommonTopologies/interface/Topology.h"
50 
51 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
52 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
53 
54 #include "DataFormats/Math/interface/GeantUnits.h"
55 #include "DataFormats/Math/interface/LorentzVector.h"
56 #include "CLHEP/Units/GlobalPhysicalConstants.h"
57 #include "DataFormats/Math/interface/Rounding.h"
58 
59 #include "DataFormats/VertexReco/interface/VertexFwd.h"
60 #include "DataFormats/VertexReco/interface/Vertex.h"
61 
62 using namespace std;
63 using namespace edm;
64 using namespace reco;
65 
66 namespace {
67  class MTDHitMatchingInfo {
68  public:
69  MTDHitMatchingInfo() {
70  hit = nullptr;
71  estChi2 = std::numeric_limits<double>::max();
72  timeChi2 = std::numeric_limits<double>::max();
73  }
74 
75  //Operator used to sort the hits while performing the matching step at the MTD
76  inline bool operator<(const MTDHitMatchingInfo& m2) const {
77  //only for good matching in time use estChi2, otherwise use mostly time compatibility
78  constexpr double chi2_cut = 10.;
79  constexpr double low_weight = 3.;
80  constexpr double high_weight = 8.;
81  if (timeChi2 < chi2_cut && m2.timeChi2 < chi2_cut)
82  return chi2(low_weight) < m2.chi2(low_weight);
83  else
84  return chi2(high_weight) < m2.chi2(high_weight);
85  }
86 
87  inline double chi2(double timeWeight = 1.) const { return estChi2 + timeWeight * timeChi2; }
88 
89  const MTDTrackingRecHit* hit;
90  double estChi2;
91  double timeChi2;
92  };
93 
94  struct TrackTofPidInfo {
95  double tmtd;
96  double tmtderror;
97  double pathlength;
98 
99  double betaerror;
100 
101  double dt;
102  double dterror;
103  double dtchi2;
104 
105  double dt_best;
106  double dterror_best;
107  double dtchi2_best;
108 
109  double gammasq_pi;
110  double beta_pi;
111  double dt_pi;
112 
113  double gammasq_k;
114  double beta_k;
115  double dt_k;
116 
117  double gammasq_p;
118  double beta_p;
119  double dt_p;
120 
121  double prob_pi;
122  double prob_k;
123  double prob_p;
124  };
125 
126  const TrackTofPidInfo computeTrackTofPidInfo(double magp2,
127  double length,
128  double t_mtd,
129  double t_mtderr,
130  double t_vtx,
131  double t_vtx_err,
132  bool addPIDError = true) {
133  constexpr double m_pi = 0.13957018;
134  constexpr double m_pi_inv2 = 1.0 / m_pi / m_pi;
135  constexpr double m_k = 0.493677;
136  constexpr double m_k_inv2 = 1.0 / m_k / m_k;
137  constexpr double m_p = 0.9382720813;
138  constexpr double m_p_inv2 = 1.0 / m_p / m_p;
139  constexpr double c_cm_ns = geant_units::operators::convertMmToCm(CLHEP::c_light); // [mm/ns] -> [cm/ns]
140  constexpr double c_inv = 1.0 / c_cm_ns;
141 
142  TrackTofPidInfo tofpid;
143 
144  tofpid.tmtd = t_mtd;
145  tofpid.tmtderror = t_mtderr;
146  tofpid.pathlength = length;
147 
148  tofpid.gammasq_pi = 1. + magp2 * m_pi_inv2;
149  tofpid.beta_pi = std::sqrt(1. - 1. / tofpid.gammasq_pi);
150  tofpid.dt_pi = tofpid.pathlength / tofpid.beta_pi * c_inv;
151 
152  tofpid.gammasq_k = 1. + magp2 * m_k_inv2;
153  tofpid.beta_k = std::sqrt(1. - 1. / tofpid.gammasq_k);
154  tofpid.dt_k = tofpid.pathlength / tofpid.beta_k * c_inv;
155 
156  tofpid.gammasq_p = 1. + magp2 * m_p_inv2;
157  tofpid.beta_p = std::sqrt(1. - 1. / tofpid.gammasq_p);
158  tofpid.dt_p = tofpid.pathlength / tofpid.beta_p * c_inv;
159 
160  tofpid.dt = tofpid.tmtd - tofpid.dt_pi - t_vtx; //assume by default the pi hypothesis
161  tofpid.dterror = sqrt(tofpid.tmtderror * tofpid.tmtderror + t_vtx_err * t_vtx_err);
162  tofpid.betaerror = 0;
163  if (addPIDError) {
164  tofpid.dterror =
165  sqrt(tofpid.dterror * tofpid.dterror + (tofpid.dt_p - tofpid.dt_pi) * (tofpid.dt_p - tofpid.dt_pi));
166  tofpid.betaerror = tofpid.beta_p - tofpid.beta_pi;
167  }
168 
169  tofpid.dtchi2 = (tofpid.dt * tofpid.dt) / (tofpid.dterror * tofpid.dterror);
170 
171  tofpid.dt_best = tofpid.dt;
172  tofpid.dterror_best = tofpid.dterror;
173  tofpid.dtchi2_best = tofpid.dtchi2;
174 
175  tofpid.prob_pi = -1.;
176  tofpid.prob_k = -1.;
177  tofpid.prob_p = -1.;
178 
179  if (!addPIDError) {
180  //*TODO* deal with heavier nucleons and/or BSM case here?
181  double chi2_pi = tofpid.dtchi2;
182  double chi2_k =
183  (tofpid.tmtd - tofpid.dt_k - t_vtx) * (tofpid.tmtd - tofpid.dt_k - t_vtx) / (tofpid.dterror * tofpid.dterror);
184  double chi2_p =
185  (tofpid.tmtd - tofpid.dt_p - t_vtx) * (tofpid.tmtd - tofpid.dt_p - t_vtx) / (tofpid.dterror * tofpid.dterror);
186 
187  double rawprob_pi = exp(-0.5 * chi2_pi);
188  double rawprob_k = exp(-0.5 * chi2_k);
189  double rawprob_p = exp(-0.5 * chi2_p);
190  double normprob = 1. / (rawprob_pi + rawprob_k + rawprob_p);
191 
192  tofpid.prob_pi = rawprob_pi * normprob;
193  tofpid.prob_k = rawprob_k * normprob;
194  tofpid.prob_p = rawprob_p * normprob;
195 
196  double prob_heavy = 1. - tofpid.prob_pi;
197  constexpr double heavy_threshold = 0.75;
198 
199  if (prob_heavy > heavy_threshold) {
200  if (chi2_k < chi2_p) {
201  tofpid.dt_best = (tofpid.tmtd - tofpid.dt_k - t_vtx);
202  tofpid.dtchi2_best = chi2_k;
203  } else {
204  tofpid.dt_best = (tofpid.tmtd - tofpid.dt_p - t_vtx);
205  tofpid.dtchi2_best = chi2_p;
206  }
207  }
208  }
209  return tofpid;
210  }
211 
212  bool getTrajectoryStateClosestToBeamLine(const Trajectory& traj,
213  const reco::BeamSpot& bs,
214  const Propagator* thePropagator,
215  TrajectoryStateClosestToBeamLine& tscbl) {
216  // get the state closest to the beamline
217  TrajectoryStateOnSurface stateForProjectionToBeamLineOnSurface =
218  traj.closestMeasurement(GlobalPoint(bs.x0(), bs.y0(), bs.z0())).updatedState();
219 
220  if (!stateForProjectionToBeamLineOnSurface.isValid()) {
221  edm::LogError("CannotPropagateToBeamLine") << "the state on the closest measurement isnot valid. skipping track.";
222  return false;
223  }
224 
225  const FreeTrajectoryState& stateForProjectionToBeamLine = *stateForProjectionToBeamLineOnSurface.freeState();
226 
227  TSCBLBuilderWithPropagator tscblBuilder(*thePropagator);
228  tscbl = tscblBuilder(stateForProjectionToBeamLine, bs);
229 
230  return tscbl.isValid();
231  }
232 
233  bool trackPathLength(const Trajectory& traj,
234  const TrajectoryStateClosestToBeamLine& tscbl,
235  const Propagator* thePropagator,
236  double& pathlength) {
237  pathlength = 0.;
238 
239  bool validpropagation = true;
240  double pathlength1 = 0.;
241  double pathlength2 = 0.;
242 
243  //add pathlength layer by layer
244  for (auto it = traj.measurements().begin(); it != traj.measurements().end() - 1; ++it) {
245  const auto& propresult = thePropagator->propagateWithPath(it->updatedState(), (it + 1)->updatedState().surface());
246  double layerpathlength = std::abs(propresult.second);
247  if (layerpathlength == 0.) {
248  validpropagation = false;
249  }
250  pathlength1 += layerpathlength;
251  }
252 
253  //add distance from bs to first measurement
254  auto const& tscblPCA = tscbl.trackStateAtPCA();
255  auto const& aSurface = traj.direction() == alongMomentum ? traj.firstMeasurement().updatedState().surface()
256  : traj.lastMeasurement().updatedState().surface();
257  pathlength2 = thePropagator->propagateWithPath(tscblPCA, aSurface).second;
258  if (pathlength2 == 0.) {
259  validpropagation = false;
260  }
261  pathlength = pathlength1 + pathlength2;
262 
263  return validpropagation;
264  }
265 
266  bool trackPathLength(const Trajectory& traj,
267  const reco::BeamSpot& bs,
268  const Propagator* thePropagator,
269  double& pathlength) {
270  pathlength = 0.;
271 
272  TrajectoryStateClosestToBeamLine tscbl;
273  bool tscbl_status = getTrajectoryStateClosestToBeamLine(traj, bs, thePropagator, tscbl);
274 
275  if (!tscbl_status)
276  return false;
277 
278  return trackPathLength(traj, tscbl, thePropagator, pathlength);
279  }
280 
281 } // namespace
282 
283 template <class TrackCollection>
284 class TrackExtenderWithMTDT : public edm::stream::EDProducer<> {
285 public:
286  typedef typename TrackCollection::value_type TrackType;
287  typedef edm::View<TrackType> InputCollection;
288 
289  TrackExtenderWithMTDT(const ParameterSet& pset);
290 
291  template <class H, class T>
292  void fillValueMap(edm::Event& iEvent, const H& handle, const std::vector<T>& vec, const edm::EDPutToken& token) const;
293 
294  void produce(edm::Event& ev, const edm::EventSetup& es) final;
295 
296  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
297 
298  TransientTrackingRecHit::ConstRecHitContainer tryBTLLayers(const TrajectoryStateOnSurface&,
299  const Trajectory& traj,
300  const double,
301  const double,
302  const MTDTrackingDetSetVector&,
303  const MTDDetLayerGeometry*,
304  const MagneticField* field,
305  const Propagator* prop,
306  const reco::BeamSpot& bs,
307  const double vtxTime,
308  const bool matchVertex,
309  MTDHitMatchingInfo& bestHit) const;
310 
311  TransientTrackingRecHit::ConstRecHitContainer tryETLLayers(const TrajectoryStateOnSurface&,
312  const Trajectory& traj,
313  const double,
314  const double,
315  const MTDTrackingDetSetVector&,
316  const MTDDetLayerGeometry*,
317  const MagneticField* field,
318  const Propagator* prop,
319  const reco::BeamSpot& bs,
320  const double vtxTime,
321  const bool matchVertex,
322  MTDHitMatchingInfo& bestHit) const;
323 
324  void fillMatchingHits(const DetLayer*,
325  const TrajectoryStateOnSurface&,
326  const Trajectory&,
327  const double,
328  const double,
329  const MTDTrackingDetSetVector&,
330  const Propagator*,
331  const reco::BeamSpot&,
332  const double&,
333  const bool,
334  TransientTrackingRecHit::ConstRecHitContainer&,
335  MTDHitMatchingInfo&) const;
336 
337  RefitDirection::GeometricalDirection checkRecHitsOrdering(
338  TransientTrackingRecHit::ConstRecHitContainer const& recHits) const {
339  if (!recHits.empty()) {
340  GlobalPoint first = gtg_->idToDet(recHits.front()->geographicalId())->position();
341  GlobalPoint last = gtg_->idToDet(recHits.back()->geographicalId())->position();
342 
343  // maybe perp2?
344  auto rFirst = first.mag2();
345  auto rLast = last.mag2();
346  if (rFirst < rLast)
347  return RefitDirection::insideOut;
348  if (rFirst > rLast)
349  return RefitDirection::outsideIn;
350  }
351  LogDebug("TrackExtenderWithMTD") << "Impossible to determine the rechits order" << endl;
352  return RefitDirection::undetermined;
353  }
354 
355  reco::Track buildTrack(const reco::Track&,
356  const Trajectory&,
357  const Trajectory&,
358  const reco::BeamSpot&,
359  const MagneticField* field,
360  const Propagator* prop,
361  bool hasMTD,
362  float& pathLength,
363  float& tmtdOut,
364  float& sigmatmtdOut) const;
365  reco::TrackExtra buildTrackExtra(const Trajectory& trajectory) const;
366 
367  string dumpLayer(const DetLayer* layer) const;
368 
369 private:
370  edm::EDPutToken btlMatchChi2Token;
371  edm::EDPutToken etlMatchChi2Token;
372  edm::EDPutToken btlMatchTimeChi2Token;
373  edm::EDPutToken etlMatchTimeChi2Token;
374  edm::EDPutToken npixBarrelToken;
375  edm::EDPutToken npixEndcapToken;
376  edm::EDPutToken pOrigTrkToken;
377  edm::EDPutToken betaOrigTrkToken;
378  edm::EDPutToken t0OrigTrkToken;
379  edm::EDPutToken sigmat0OrigTrkToken;
380  edm::EDPutToken pathLengthOrigTrkToken;
381  edm::EDPutToken tmtdOrigTrkToken;
382  edm::EDPutToken sigmatmtdOrigTrkToken;
383  edm::EDPutToken assocOrigTrkToken;
384 
385  edm::EDGetTokenT<InputCollection> tracksToken_;
386  edm::EDGetTokenT<MTDTrackingDetSetVector> hitsToken_;
387  edm::EDGetTokenT<reco::BeamSpot> bsToken_;
388  edm::EDGetTokenT<GlobalPoint> genVtxPositionToken_;
389  edm::EDGetTokenT<float> genVtxTimeToken_;
390  edm::EDGetTokenT<VertexCollection> vtxToken_;
391 
392  const bool updateTraj_, updateExtra_, updatePattern_;
393  const std::string mtdRecHitBuilder_, propagator_, transientTrackBuilder_;
394  std::unique_ptr<MeasurementEstimator> theEstimator;
395  std::unique_ptr<TrackTransformer> theTransformer;
396  edm::ESHandle<TransientTrackBuilder> builder_;
397  edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> builderToken_;
398  edm::ESHandle<TransientTrackingRecHitBuilder> hitbuilder_;
399  edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> hitbuilderToken_;
400  edm::ESHandle<GlobalTrackingGeometry> gtg_;
401  edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> gtgToken_;
402 
403  edm::ESGetToken<MTDDetLayerGeometry, MTDRecoGeometryRecord> dlgeoToken_;
404  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magfldToken_;
405  edm::ESGetToken<Propagator, TrackingComponentsRecord> propToken_;
406  edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> ttopoToken_;
407 
408  const float estMaxChi2_;
409  const float estMaxNSigma_;
410  const float btlChi2Cut_;
411  const float btlTimeChi2Cut_;
412  const float etlChi2Cut_;
413  const float etlTimeChi2Cut_;
414 
415  const bool useVertex_;
416  const bool useSimVertex_;
417  const float dzCut_;
418  const float bsTimeSpread_;
419 };
420 
421 template <class TrackCollection>
422 TrackExtenderWithMTDT<TrackCollection>::TrackExtenderWithMTDT(const ParameterSet& iConfig)
423  : tracksToken_(consumes<InputCollection>(iConfig.getParameter<edm::InputTag>("tracksSrc"))),
424  hitsToken_(consumes<MTDTrackingDetSetVector>(iConfig.getParameter<edm::InputTag>("hitsSrc"))),
425  bsToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpotSrc"))),
426  updateTraj_(iConfig.getParameter<bool>("updateTrackTrajectory")),
427  updateExtra_(iConfig.getParameter<bool>("updateTrackExtra")),
428  updatePattern_(iConfig.getParameter<bool>("updateTrackHitPattern")),
429  mtdRecHitBuilder_(iConfig.getParameter<std::string>("MTDRecHitBuilder")),
430  propagator_(iConfig.getParameter<std::string>("Propagator")),
431  transientTrackBuilder_(iConfig.getParameter<std::string>("TransientTrackBuilder")),
432  estMaxChi2_(iConfig.getParameter<double>("estimatorMaxChi2")),
433  estMaxNSigma_(iConfig.getParameter<double>("estimatorMaxNSigma")),
434  btlChi2Cut_(iConfig.getParameter<double>("btlChi2Cut")),
435  btlTimeChi2Cut_(iConfig.getParameter<double>("btlTimeChi2Cut")),
436  etlChi2Cut_(iConfig.getParameter<double>("etlChi2Cut")),
437  etlTimeChi2Cut_(iConfig.getParameter<double>("etlTimeChi2Cut")),
438  useVertex_(iConfig.getParameter<bool>("useVertex")),
439  useSimVertex_(iConfig.getParameter<bool>("useSimVertex")),
440  dzCut_(iConfig.getParameter<double>("dZCut")),
441  bsTimeSpread_(iConfig.getParameter<double>("bsTimeSpread")) {
442  if (useVertex_) {
443  if (useSimVertex_) {
444  genVtxPositionToken_ = consumes<GlobalPoint>(iConfig.getParameter<edm::InputTag>("genVtxPositionSrc"));
445  genVtxTimeToken_ = consumes<float>(iConfig.getParameter<edm::InputTag>("genVtxTimeSrc"));
446  } else
447  vtxToken_ = consumes<VertexCollection>(iConfig.getParameter<edm::InputTag>("vtxSrc"));
448  }
449 
450  theEstimator = std::make_unique<Chi2MeasurementEstimator>(estMaxChi2_, estMaxNSigma_);
451  theTransformer = std::make_unique<TrackTransformer>(iConfig.getParameterSet("TrackTransformer"));
452 
453  btlMatchChi2Token = produces<edm::ValueMap<float>>("btlMatchChi2");
454  etlMatchChi2Token = produces<edm::ValueMap<float>>("etlMatchChi2");
455  btlMatchTimeChi2Token = produces<edm::ValueMap<float>>("btlMatchTimeChi2");
456  etlMatchTimeChi2Token = produces<edm::ValueMap<float>>("etlMatchTimeChi2");
457  npixBarrelToken = produces<edm::ValueMap<int>>("npixBarrel");
458  npixEndcapToken = produces<edm::ValueMap<int>>("npixEndcap");
459  pOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackp");
460  betaOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackBeta");
461  t0OrigTrkToken = produces<edm::ValueMap<float>>("generalTrackt0");
462  sigmat0OrigTrkToken = produces<edm::ValueMap<float>>("generalTracksigmat0");
463  pathLengthOrigTrkToken = produces<edm::ValueMap<float>>("generalTrackPathLength");
464  tmtdOrigTrkToken = produces<edm::ValueMap<float>>("generalTracktmtd");
465  sigmatmtdOrigTrkToken = produces<edm::ValueMap<float>>("generalTracksigmatmtd");
466  assocOrigTrkToken = produces<edm::ValueMap<int>>("generalTrackassoc");
467 
468  builderToken_ = esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", transientTrackBuilder_));
469  hitbuilderToken_ =
470  esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(edm::ESInputTag("", mtdRecHitBuilder_));
471  gtgToken_ = esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>();
472  dlgeoToken_ = esConsumes<MTDDetLayerGeometry, MTDRecoGeometryRecord>();
473  magfldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
474  propToken_ = esConsumes<Propagator, TrackingComponentsRecord>(edm::ESInputTag("", propagator_));
475  ttopoToken_ = esConsumes<TrackerTopology, TrackerTopologyRcd>();
476 
477  produces<edm::OwnVector<TrackingRecHit>>();
478  produces<reco::TrackExtraCollection>();
479  produces<TrackCollection>();
480 }
481 
482 template <class TrackCollection>
483 void TrackExtenderWithMTDT<TrackCollection>::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
484  edm::ParameterSetDescription desc, transDesc;
485  desc.add<edm::InputTag>("tracksSrc", edm::InputTag("generalTracks"));
486  desc.add<edm::InputTag>("hitsSrc", edm::InputTag("mtdTrackingRecHits"));
487  desc.add<edm::InputTag>("beamSpotSrc", edm::InputTag("offlineBeamSpot"));
488  desc.add<edm::InputTag>("genVtxPositionSrc", edm::InputTag("genParticles:xyz0"));
489  desc.add<edm::InputTag>("genVtxTimeSrc", edm::InputTag("genParticles:t0"));
490  desc.add<edm::InputTag>("vtxSrc", edm::InputTag("offlinePrimaryVertices4D"));
491  desc.add<bool>("updateTrackTrajectory", true);
492  desc.add<bool>("updateTrackExtra", true);
493  desc.add<bool>("updateTrackHitPattern", true);
494  desc.add<std::string>("TransientTrackBuilder", "TransientTrackBuilder");
495  desc.add<std::string>("MTDRecHitBuilder", "MTDRecHitBuilder");
496  desc.add<std::string>("Propagator", "PropagatorWithMaterialForMTD");
497  TrackTransformer::fillPSetDescription(transDesc,
498  false,
499  "KFFitterForRefitInsideOut",
500  "KFSmootherForRefitInsideOut",
501  "PropagatorWithMaterialForMTD",
502  "alongMomentum",
503  true,
504  "WithTrackAngle",
505  "MuonRecHitBuilder",
506  "MTDRecHitBuilder");
507  desc.add<edm::ParameterSetDescription>("TrackTransformer", transDesc);
508  desc.add<double>("estimatorMaxChi2", 500.);
509  desc.add<double>("estimatorMaxNSigma", 10.);
510  desc.add<double>("btlChi2Cut", 50.);
511  desc.add<double>("btlTimeChi2Cut", 10.);
512  desc.add<double>("etlChi2Cut", 50.);
513  desc.add<double>("etlTimeChi2Cut", 10.);
514  desc.add<bool>("useVertex", false);
515  desc.add<bool>("useSimVertex", false);
516  desc.add<double>("dZCut", 0.1);
517  desc.add<double>("bsTimeSpread", 0.2);
518  descriptions.add("trackExtenderWithMTDBase", desc);
519 }
520 
521 template <class TrackCollection>
522 template <class H, class T>
523 void TrackExtenderWithMTDT<TrackCollection>::fillValueMap(edm::Event& iEvent,
524  const H& handle,
525  const std::vector<T>& vec,
526  const edm::EDPutToken& token) const {
527  auto out = std::make_unique<edm::ValueMap<T>>();
528  typename edm::ValueMap<T>::Filler filler(*out);
529  filler.insert(handle, vec.begin(), vec.end());
530  filler.fill();
531  iEvent.put(token, std::move(out));
532 }
533 
534 template <class TrackCollection>
535 void TrackExtenderWithMTDT<TrackCollection>::produce(edm::Event& ev, const edm::EventSetup& es) {
536  //this produces pieces of the track extra
537  Traj2TrackHits t2t;
538 
539  theTransformer->setServices(es);
540 
541  TrackingRecHitRefProd hitsRefProd = ev.getRefBeforePut<TrackingRecHitCollection>();
542  reco::TrackExtraRefProd extrasRefProd = ev.getRefBeforePut<reco::TrackExtraCollection>();
543 
544  gtg_ = es.getHandle(gtgToken_);
545 
546  auto geo = es.getTransientHandle(dlgeoToken_);
547 
548  auto magfield = es.getTransientHandle(magfldToken_);
549 
550  builder_ = es.getHandle(builderToken_);
551  hitbuilder_ = es.getHandle(hitbuilderToken_);
552 
553  auto propH = es.getTransientHandle(propToken_);
554  const Propagator* prop = propH.product();
555 
556  auto httopo = es.getTransientHandle(ttopoToken_);
557  const TrackerTopology& ttopo = *httopo;
558 
559  auto output = std::make_unique<TrackCollection>();
560  auto extras = std::make_unique<reco::TrackExtraCollection>();
561  auto outhits = std::make_unique<edm::OwnVector<TrackingRecHit>>();
562 
563  std::vector<float> btlMatchChi2;
564  std::vector<float> etlMatchChi2;
565  std::vector<float> btlMatchTimeChi2;
566  std::vector<float> etlMatchTimeChi2;
567  std::vector<int> npixBarrel;
568  std::vector<int> npixEndcap;
569  std::vector<float> pOrigTrkRaw;
570  std::vector<float> betaOrigTrkRaw;
571  std::vector<float> t0OrigTrkRaw;
572  std::vector<float> sigmat0OrigTrkRaw;
573  std::vector<float> pathLengthsOrigTrkRaw;
574  std::vector<float> tmtdOrigTrkRaw;
575  std::vector<float> sigmatmtdOrigTrkRaw;
576  std::vector<int> assocOrigTrkRaw;
577 
578  auto const tracksH = ev.getHandle(tracksToken_);
579  const auto& tracks = *tracksH;
580 
581  //MTD hits DetSet
582  const auto& hits = ev.get(hitsToken_);
583 
584  //beam spot
585  const auto& bs = ev.get(bsToken_);
586 
587  const Vertex* pv = nullptr;
588  if (useVertex_ && !useSimVertex_) {
589  auto const& vtxs = ev.get(vtxToken_);
590  if (!vtxs.empty())
591  pv = &vtxs[0];
592  }
593 
594  std::unique_ptr<math::XYZTLorentzVectorF> genPV(nullptr);
595  if (useVertex_ && useSimVertex_) {
596  const auto& genVtxPosition = ev.get(genVtxPositionToken_);
597  const auto& genVtxTime = ev.get(genVtxTimeToken_);
598  genPV = std::make_unique<math::XYZTLorentzVectorF>(
599  genVtxPosition.x(), genVtxPosition.y(), genVtxPosition.z(), genVtxTime);
600  }
601 
602  double vtxTime = 0.;
603  if (useVertex_) {
604  if (useSimVertex_ && genPV) {
605  vtxTime = genPV->t();
606  } else if (pv)
607  vtxTime = pv->t(); //already in ns
608  }
609 
610  std::vector<unsigned> track_indices;
611  unsigned itrack = 0;
612 
613  for (const auto& track : tracks) {
614  double trackVtxTime = 0.;
615  if (useVertex_) {
616  double dz;
617  if (useSimVertex_)
618  dz = std::abs(track.dz(math::XYZPoint(*genPV)));
619  else
620  dz = std::abs(track.dz(pv->position()));
621 
622  if (dz < dzCut_)
623  trackVtxTime = vtxTime;
624  }
625 
626  reco::TransientTrack ttrack(track, magfield.product(), gtg_);
627  const auto& trajs = theTransformer->transform(track);
628  auto thits = theTransformer->getTransientRecHits(ttrack);
629  TransientTrackingRecHit::ConstRecHitContainer mtdthits;
630  MTDHitMatchingInfo mBTL, mETL;
631  if (!trajs.empty()) {
632  // get the outermost trajectory point on the track
633  TrajectoryStateOnSurface tsos = builder_->build(track).outermostMeasurementState();
634  TrajectoryStateClosestToBeamLine tscbl;
635  bool tscbl_status = getTrajectoryStateClosestToBeamLine(trajs.front(), bs, prop, tscbl);
636 
637  if (tscbl_status) {
638  double pmag2 = tscbl.trackStateAtPCA().momentum().mag2();
639  double pathlength0;
640  trackPathLength(trajs.front(), tscbl, prop, pathlength0);
641 
642  const auto& btlhits = tryBTLLayers(tsos,
643  trajs.front(),
644  pmag2,
645  pathlength0,
646  hits,
647  geo.product(),
648  magfield.product(),
649  prop,
650  bs,
651  trackVtxTime,
652  trackVtxTime != 0.,
653  mBTL);
654  mtdthits.insert(mtdthits.end(), btlhits.begin(), btlhits.end());
655 
656  // in the future this should include an intermediate refit before propagating to the ETL
657  // for now it is ok
658  const auto& etlhits = tryETLLayers(tsos,
659  trajs.front(),
660  pmag2,
661  pathlength0,
662  hits,
663  geo.product(),
664  magfield.product(),
665  prop,
666  bs,
667  trackVtxTime,
668  trackVtxTime != 0.,
669  mETL);
670  mtdthits.insert(mtdthits.end(), etlhits.begin(), etlhits.end());
671  }
672  }
673 
674  auto ordering = checkRecHitsOrdering(thits);
675  if (ordering == RefitDirection::insideOut) {
676  thits.insert(thits.end(), mtdthits.begin(), mtdthits.end());
677  } else {
678  std::reverse(mtdthits.begin(), mtdthits.end());
679  mtdthits.insert(mtdthits.end(), thits.begin(), thits.end());
680  thits.swap(mtdthits);
681  }
682 
683  const auto& trajwithmtd = mtdthits.empty() ? trajs : theTransformer->transform(ttrack, thits);
684  float pMap = 0.f, betaMap = 0.f, t0Map = 0.f, sigmat0Map = -1.f, pathLengthMap = -1.f, tmtdMap = 0.f,
685  sigmatmtdMap = -1.f;
686  int iMap = -1;
687 
688  for (const auto& trj : trajwithmtd) {
689  const auto& thetrj = (updateTraj_ ? trj : trajs.front());
690  float pathLength = 0.f, tmtd = 0.f, sigmatmtd = -1.f;
691  reco::Track result = buildTrack(track,
692  thetrj,
693  trj,
694  bs,
695  magfield.product(),
696  prop,
697  !trajwithmtd.empty() && !mtdthits.empty(),
698  pathLength,
699  tmtd,
700  sigmatmtd);
701  if (result.ndof() >= 0) {
703  reco::TrackExtra::TrajParams trajParams;
704  reco::TrackExtra::Chi2sFive chi2s;
705  size_t hitsstart = outhits->size();
706  if (updatePattern_) {
707  t2t(trj, *outhits, trajParams, chi2s); // this fills the output hit collection
708  } else {
709  t2t(thetrj, *outhits, trajParams, chi2s);
710  }
711  size_t hitsend = outhits->size();
712  extras->push_back(buildTrackExtra(trj)); // always push back the fully built extra, update by setting in track
713  extras->back().setHits(hitsRefProd, hitsstart, hitsend - hitsstart);
714  extras->back().setTrajParams(trajParams, chi2s);
715  //create the track
716  output->push_back(result);
717  btlMatchChi2.push_back(mBTL.hit ? mBTL.estChi2 : -1);
718  etlMatchChi2.push_back(mETL.hit ? mETL.estChi2 : -1);
719  btlMatchTimeChi2.push_back(mBTL.hit ? mBTL.timeChi2 : -1);
720  etlMatchTimeChi2.push_back(mETL.hit ? mETL.timeChi2 : -1);
721  pathLengthMap = pathLength;
722  tmtdMap = tmtd;
723  sigmatmtdMap = sigmatmtd;
724  auto& backtrack = output->back();
725  iMap = output->size() - 1;
726  pMap = backtrack.p();
727  betaMap = backtrack.beta();
728  t0Map = backtrack.t0();
729  sigmat0Map = std::copysign(std::sqrt(std::abs(backtrack.covt0t0())), backtrack.covt0t0());
730  reco::TrackExtraRef extraRef(extrasRefProd, extras->size() - 1);
731  backtrack.setExtra((updateExtra_ ? extraRef : track.extra()));
732  for (unsigned ihit = hitsstart; ihit < hitsend; ++ihit) {
733  backtrack.appendHitPattern((*outhits)[ihit], ttopo);
734  }
735  npixBarrel.push_back(backtrack.hitPattern().numberOfValidPixelBarrelHits());
736  npixEndcap.push_back(backtrack.hitPattern().numberOfValidPixelEndcapHits());
737  } else {
738  LogTrace("TrackExtenderWithMTD") << "Error in the MTD track refitting. This should not happen";
739  }
740  }
741 
742  pOrigTrkRaw.push_back(pMap);
743  betaOrigTrkRaw.push_back(betaMap);
744  t0OrigTrkRaw.push_back(t0Map);
745  sigmat0OrigTrkRaw.push_back(sigmat0Map);
746  pathLengthsOrigTrkRaw.push_back(pathLengthMap);
747  tmtdOrigTrkRaw.push_back(tmtdMap);
748  sigmatmtdOrigTrkRaw.push_back(sigmatmtdMap);
749  assocOrigTrkRaw.push_back(iMap);
750 
751  if (iMap == -1) {
752  btlMatchChi2.push_back(-1.);
753  etlMatchChi2.push_back(-1.);
754  btlMatchTimeChi2.push_back(-1.);
755  etlMatchTimeChi2.push_back(-1.);
756  npixBarrel.push_back(-1.);
757  npixEndcap.push_back(-1.);
758  }
759 
760  ++itrack;
761  }
762 
763  auto outTrksHandle = ev.put(std::move(output));
764  ev.put(std::move(extras));
765  ev.put(std::move(outhits));
766 
767  fillValueMap(ev, tracksH, btlMatchChi2, btlMatchChi2Token);
768  fillValueMap(ev, tracksH, etlMatchChi2, etlMatchChi2Token);
769  fillValueMap(ev, tracksH, btlMatchTimeChi2, btlMatchTimeChi2Token);
770  fillValueMap(ev, tracksH, etlMatchTimeChi2, etlMatchTimeChi2Token);
771  fillValueMap(ev, tracksH, npixBarrel, npixBarrelToken);
772  fillValueMap(ev, tracksH, npixEndcap, npixEndcapToken);
773  fillValueMap(ev, tracksH, pOrigTrkRaw, pOrigTrkToken);
774  fillValueMap(ev, tracksH, betaOrigTrkRaw, betaOrigTrkToken);
775  fillValueMap(ev, tracksH, t0OrigTrkRaw, t0OrigTrkToken);
776  fillValueMap(ev, tracksH, sigmat0OrigTrkRaw, sigmat0OrigTrkToken);
777  fillValueMap(ev, tracksH, pathLengthsOrigTrkRaw, pathLengthOrigTrkToken);
778  fillValueMap(ev, tracksH, tmtdOrigTrkRaw, tmtdOrigTrkToken);
779  fillValueMap(ev, tracksH, sigmatmtdOrigTrkRaw, sigmatmtdOrigTrkToken);
780  fillValueMap(ev, tracksH, assocOrigTrkRaw, assocOrigTrkToken);
781 }
782 
783 namespace {
784  bool cmp_for_detset(const unsigned one, const unsigned two) { return one < two; };
785 
786  void find_hits_in_dets(const MTDTrackingDetSetVector& hits,
787  const Trajectory& traj,
788  const DetLayer* layer,
789  const TrajectoryStateOnSurface& tsos,
790  const double pmag2,
791  const double pathlength0,
792  const double vtxTime,
793  const reco::BeamSpot& bs,
794  const float bsTimeSpread,
795  const Propagator* prop,
796  const MeasurementEstimator* estimator,
797  bool useVtxConstraint,
798  std::set<MTDHitMatchingInfo>& out) {
799  pair<bool, TrajectoryStateOnSurface> comp = layer->compatible(tsos, *prop, *estimator);
800  if (comp.first) {
801  const vector<DetLayer::DetWithState> compDets = layer->compatibleDets(tsos, *prop, *estimator);
802  if (!compDets.empty()) {
803  for (const auto& detWithState : compDets) {
804  auto range = hits.equal_range(detWithState.first->geographicalId(), cmp_for_detset);
805  if (range.first == range.second)
806  continue;
807 
808  auto pl = prop->propagateWithPath(tsos, detWithState.second.surface());
809  if (pl.second == 0.)
810  continue;
811 
812  const double tot_pl = pathlength0 + std::abs(pl.second);
813  const double t_vtx = useVtxConstraint ? vtxTime : 0.;
814 
815  constexpr double vtx_res = 0.008;
816  const double t_vtx_err = useVtxConstraint ? vtx_res : bsTimeSpread;
817 
818  constexpr double t_res_manual = 0.035;
819 
820  for (auto detitr = range.first; detitr != range.second; ++detitr) {
821  for (const auto& hit : *detitr) {
822  auto est = estimator->estimate(detWithState.second, hit);
823  if (!est.first)
824  continue;
825 
826  TrackTofPidInfo tof = computeTrackTofPidInfo(pmag2,
827  tot_pl,
828  hit.time(),
829  t_res_manual, //put hit error by hand for the moment
830  t_vtx,
831  t_vtx_err, //put vtx error by hand for the moment
832  false);
833  MTDHitMatchingInfo mi;
834  mi.hit = &hit;
835  mi.estChi2 = est.second;
836  mi.timeChi2 = tof.dtchi2_best; //use the chi2 for the best matching hypothesis
837 
838  out.insert(mi);
839  }
840  }
841  }
842  }
843  }
844  }
845 } // namespace
846 
847 template <class TrackCollection>
848 TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT<TrackCollection>::tryBTLLayers(
849  const TrajectoryStateOnSurface& tsos,
850  const Trajectory& traj,
851  const double pmag2,
852  const double pathlength0,
853  const MTDTrackingDetSetVector& hits,
854  const MTDDetLayerGeometry* geo,
855  const MagneticField* field,
856  const Propagator* prop,
857  const reco::BeamSpot& bs,
858  const double vtxTime,
859  const bool matchVertex,
860  MTDHitMatchingInfo& bestHit) const {
861  const vector<const DetLayer*>& layers = geo->allBTLLayers();
862 
863  TransientTrackingRecHit::ConstRecHitContainer output;
864  bestHit = MTDHitMatchingInfo();
865  for (const DetLayer* ilay : layers)
866  fillMatchingHits(ilay, tsos, traj, pmag2, pathlength0, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
867  return output;
868 }
869 
870 template <class TrackCollection>
871 TransientTrackingRecHit::ConstRecHitContainer TrackExtenderWithMTDT<TrackCollection>::tryETLLayers(
872  const TrajectoryStateOnSurface& tsos,
873  const Trajectory& traj,
874  const double pmag2,
875  const double pathlength0,
876  const MTDTrackingDetSetVector& hits,
877  const MTDDetLayerGeometry* geo,
878  const MagneticField* field,
879  const Propagator* prop,
880  const reco::BeamSpot& bs,
881  const double vtxTime,
882  const bool matchVertex,
883  MTDHitMatchingInfo& bestHit) const {
884  const vector<const DetLayer*>& layers = geo->allETLLayers();
885 
886  TransientTrackingRecHit::ConstRecHitContainer output;
887  bestHit = MTDHitMatchingInfo();
888  for (const DetLayer* ilay : layers) {
889  const BoundDisk& disk = static_cast<const MTDRingForwardDoubleLayer*>(ilay)->specificSurface();
890  const double diskZ = disk.position().z();
891 
892  if (tsos.globalPosition().z() * diskZ < 0)
893  continue; // only propagate to the disk that's on the same side
894 
895  fillMatchingHits(ilay, tsos, traj, pmag2, pathlength0, hits, prop, bs, vtxTime, matchVertex, output, bestHit);
896  }
897 
898  // the ETL hits order must be from the innermost to the outermost
899 
900  if (output.size() == 2) {
901  if (std::abs(output[0]->globalPosition().z()) > std::abs(output[1]->globalPosition().z())) {
902  std::reverse(output.begin(), output.end());
903  }
904  }
905  return output;
906 }
907 
908 template <class TrackCollection>
909 void TrackExtenderWithMTDT<TrackCollection>::fillMatchingHits(const DetLayer* ilay,
910  const TrajectoryStateOnSurface& tsos,
911  const Trajectory& traj,
912  const double pmag2,
913  const double pathlength0,
914  const MTDTrackingDetSetVector& hits,
915  const Propagator* prop,
916  const reco::BeamSpot& bs,
917  const double& vtxTime,
918  const bool matchVertex,
919  TransientTrackingRecHit::ConstRecHitContainer& output,
920  MTDHitMatchingInfo& bestHit) const {
921  std::set<MTDHitMatchingInfo> hitsInLayer;
922  bool hitMatched = false;
923 
924  using namespace std::placeholders;
925  auto find_hits = std::bind(find_hits_in_dets,
926  std::cref(hits),
927  std::cref(traj),
928  ilay,
929  std::cref(tsos),
930  pmag2,
931  pathlength0,
932  _1,
933  std::cref(bs),
934  bsTimeSpread_,
935  prop,
936  theEstimator.get(),
937  _2,
938  std::ref(hitsInLayer));
939 
940  if (useVertex_ && matchVertex)
941  find_hits(vtxTime, true);
942  else
943  find_hits(0, false);
944 
945  //just take the first hit because the hits are sorted on their matching quality
946  if (!hitsInLayer.empty()) {
947  //check hits to pass minimum quality matching requirements
948  auto const& firstHit = *hitsInLayer.begin();
949  if (firstHit.estChi2 < etlChi2Cut_ && firstHit.timeChi2 < etlTimeChi2Cut_) {
950  hitMatched = true;
951  output.push_back(hitbuilder_->build(firstHit.hit));
952  if (firstHit < bestHit)
953  bestHit = firstHit;
954  }
955  }
956 
957  if (useVertex_ && matchVertex && !hitMatched) {
958  //try a second search with beamspot hypothesis
959  hitsInLayer.clear();
960  find_hits(0, false);
961  if (!hitsInLayer.empty()) {
962  auto const& firstHit = *hitsInLayer.begin();
963  if (firstHit.timeChi2 < etlTimeChi2Cut_) {
964  if (firstHit.estChi2 < etlChi2Cut_) {
965  hitMatched = true;
966  output.push_back(hitbuilder_->build(firstHit.hit));
967  if (firstHit < bestHit)
968  bestHit = firstHit;
969  }
970  }
971  }
972  }
973 }
974 
975 //below is unfortunately ripped from other places but
976 //since track producer doesn't know about MTD we have to do this
977 template <class TrackCollection>
978 reco::Track TrackExtenderWithMTDT<TrackCollection>::buildTrack(const reco::Track& orig,
979  const Trajectory& traj,
980  const Trajectory& trajWithMtd,
981  const reco::BeamSpot& bs,
982  const MagneticField* field,
983  const Propagator* thePropagator,
984  bool hasMTD,
985  float& pathLengthOut,
986  float& tmtdOut,
987  float& sigmatmtdOut) const {
988  TrajectoryStateClosestToBeamLine tscbl;
989  bool tsbcl_status = getTrajectoryStateClosestToBeamLine(traj, bs, thePropagator, tscbl);
990 
991  if (!tsbcl_status)
992  return reco::Track();
993 
994  GlobalPoint v = tscbl.trackStateAtPCA().position();
995  math::XYZPoint pos(v.x(), v.y(), v.z());
996  GlobalVector p = tscbl.trackStateAtPCA().momentum();
997  math::XYZVector mom(p.x(), p.y(), p.z());
998 
999  int ndof = traj.ndof();
1000 
1001  double t0 = 0.;
1002  double covt0t0 = -1.;
1003  pathLengthOut = -1.f; // if there is no MTD flag the pathlength with -1
1004  tmtdOut = 0.f;
1005  sigmatmtdOut = -1.f;
1006  double betaOut = 0.;
1007  double covbetabeta = -1.;
1008 
1009  auto routput = [&]() {
1010  return reco::Track(traj.chiSquared(),
1011  int(ndof),
1012  pos,
1013  mom,
1014  tscbl.trackStateAtPCA().charge(),
1015  tscbl.trackStateAtPCA().curvilinearError(),
1016  orig.algo(),
1017  reco::TrackBase::undefQuality,
1018  t0,
1019  betaOut,
1020  covt0t0,
1021  covbetabeta);
1022  };
1023 
1024  //compute path length for time backpropagation, using first MTD hit for the momentum
1025  if (hasMTD) {
1026  double pathlength;
1027  bool validpropagation = trackPathLength(trajWithMtd, bs, thePropagator, pathlength);
1028  double thit = 0.;
1029  double thiterror = -1.;
1030  bool validmtd = false;
1031 
1032  if (!validpropagation) {
1033  return routput();
1034  }
1035 
1036  size_t ihitcount(0), ietlcount(0);
1037  for (auto const& hit : trajWithMtd.measurements()) {
1038  if (hit.recHit()->geographicalId().det() == DetId::Forward &&
1039  ForwardSubdetector(hit.recHit()->geographicalId().subdetId()) == FastTime) {
1040  ihitcount++;
1041  if (MTDDetId(hit.recHit()->geographicalId()).mtdSubDetector() == MTDDetId::MTDType::ETL) {
1042  ietlcount++;
1043  }
1044  }
1045  }
1046 
1047  auto ihit1 = trajWithMtd.measurements().cbegin();
1048  if (ihitcount == 1) {
1049  const MTDTrackingRecHit* mtdhit = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
1050  thit = mtdhit->time();
1051  thiterror = mtdhit->timeError();
1052  validmtd = true;
1053  } else if (ihitcount == 2 && ietlcount == 2) {
1054  const auto& propresult =
1055  thePropagator->propagateWithPath(ihit1->updatedState(), (ihit1 + 1)->updatedState().surface());
1056  double etlpathlength = std::abs(propresult.second);
1057  //
1058  // The information of the two ETL hits is combined and attributed to the innermost hit
1059  //
1060  if (etlpathlength == 0.) {
1061  validpropagation = false;
1062  } else {
1063  pathlength -= etlpathlength;
1064  const MTDTrackingRecHit* mtdhit1 = static_cast<const MTDTrackingRecHit*>((*ihit1).recHit()->hit());
1065  const MTDTrackingRecHit* mtdhit2 = static_cast<const MTDTrackingRecHit*>((*(ihit1 + 1)).recHit()->hit());
1066  TrackTofPidInfo tofInfo =
1067  computeTrackTofPidInfo(p.mag2(), etlpathlength, mtdhit1->time(), mtdhit1->timeError(), 0., 0., true);
1068  //
1069  // Protect against incompatible times
1070  //
1071  double err1 = tofInfo.dterror * tofInfo.dterror;
1072  double err2 = mtdhit2->timeError() * mtdhit2->timeError();
1073  if (cms_rounding::roundIfNear0(err1) == 0. || cms_rounding::roundIfNear0(err2) == 0.) {
1074  edm::LogError("TrackExtenderWithMTD")
1075  << "MTD tracking hits with zero time uncertainty: " << err1 << " " << err2;
1076  } else {
1077  if ((tofInfo.dt - mtdhit2->time()) * (tofInfo.dt - mtdhit2->time()) < (err1 + err2) * etlTimeChi2Cut_) {
1078  //
1079  // Subtract the ETL time of flight from the outermost measurement, and combine it in a weighted average with the innermost
1080  // the mass ambiguity related uncertainty on the time of flight is added as an additional uncertainty
1081  //
1082  err1 = 1. / err1;
1083  err2 = 1. / err2;
1084  thiterror = 1. / (err1 + err2);
1085  thit = (tofInfo.dt * err1 + mtdhit2->time() * err2) * thiterror;
1086  thiterror = std::sqrt(thiterror);
1087  LogDebug("TrackExtenderWithMTD") << "p trk = " << p.mag() << " ETL hits times/errors: " << mtdhit1->time()
1088  << " +/- " << mtdhit1->timeError() << " , " << mtdhit2->time() << " +/- "
1089  << mtdhit2->timeError() << " extrapolated time1: " << tofInfo.dt << " +/- "
1090  << tofInfo.dterror << " average = " << thit << " +/- " << thiterror;
1091  validmtd = true;
1092  }
1093  }
1094  }
1095  } else {
1096  edm::LogInfo("TrackExtenderWithMTD")
1097  << "MTD hits #" << ihitcount << "ETL hits #" << ietlcount << " anomalous pattern, skipping...";
1098  }
1099 
1100  if (validmtd && validpropagation) {
1101  //here add the PID uncertainty for later use in the 1st step of 4D vtx reconstruction
1102  TrackTofPidInfo tofInfo = computeTrackTofPidInfo(p.mag2(), pathlength, thit, thiterror, 0., 0., true);
1103  pathLengthOut = pathlength; // set path length if we've got a timing hit
1104  tmtdOut = thit;
1105  sigmatmtdOut = thiterror;
1106  t0 = tofInfo.dt;
1107  covt0t0 = tofInfo.dterror * tofInfo.dterror;
1108  betaOut = tofInfo.beta_pi;
1109  covbetabeta = tofInfo.betaerror * tofInfo.betaerror;
1110  }
1111  }
1112 
1113  return routput();
1114 }
1115 
1116 template <class TrackCollection>
1117 reco::TrackExtra TrackExtenderWithMTDT<TrackCollection>::buildTrackExtra(const Trajectory& trajectory) const {
1118  static const string metname = "TrackExtenderWithMTD";
1119 
1120  const Trajectory::RecHitContainer transRecHits = trajectory.recHits();
1121 
1122  // put the collection of TrackingRecHit in the event
1123 
1124  // sets the outermost and innermost TSOSs
1125  // ToDo: validation for track states with MTD
1126  TrajectoryStateOnSurface outerTSOS;
1127  TrajectoryStateOnSurface innerTSOS;
1128  unsigned int innerId = 0, outerId = 0;
1129  TrajectoryMeasurement::ConstRecHitPointer outerRecHit;
1130  DetId outerDetId;
1131 
1132  if (trajectory.direction() == alongMomentum) {
1133  LogTrace(metname) << "alongMomentum";
1134  outerTSOS = trajectory.lastMeasurement().updatedState();
1135  innerTSOS = trajectory.firstMeasurement().updatedState();
1136  outerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
1137  innerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
1138  outerRecHit = trajectory.lastMeasurement().recHit();
1139  outerDetId = trajectory.lastMeasurement().recHit()->geographicalId();
1140  } else if (trajectory.direction() == oppositeToMomentum) {
1141  LogTrace(metname) << "oppositeToMomentum";
1142  outerTSOS = trajectory.firstMeasurement().updatedState();
1143  innerTSOS = trajectory.lastMeasurement().updatedState();
1144  outerId = trajectory.firstMeasurement().recHit()->geographicalId().rawId();
1145  innerId = trajectory.lastMeasurement().recHit()->geographicalId().rawId();
1146  outerRecHit = trajectory.firstMeasurement().recHit();
1147  outerDetId = trajectory.firstMeasurement().recHit()->geographicalId();
1148  } else
1149  LogError(metname) << "Wrong propagation direction!";
1150 
1151  const GeomDet* outerDet = gtg_->idToDet(outerDetId);
1152  GlobalPoint outerTSOSPos = outerTSOS.globalParameters().position();
1153  bool inside = outerDet->surface().bounds().inside(outerDet->toLocal(outerTSOSPos));
1154 
1155  GlobalPoint hitPos =
1156  (outerRecHit->isValid()) ? outerRecHit->globalPosition() : outerTSOS.globalParameters().position();
1157 
1158  if (!inside) {
1159  LogTrace(metname) << "The Global Muon outerMostMeasurementState is not compatible with the recHit detector!"
1160  << " Setting outerMost postition to recHit position if recHit isValid: "
1161  << outerRecHit->isValid();
1162  LogTrace(metname) << "From " << outerTSOSPos << " to " << hitPos;
1163  }
1164 
1165  //build the TrackExtra
1166  GlobalPoint v = (inside) ? outerTSOSPos : hitPos;
1167  GlobalVector p = outerTSOS.globalParameters().momentum();
1168  math::XYZPoint outpos(v.x(), v.y(), v.z());
1169  math::XYZVector outmom(p.x(), p.y(), p.z());
1170 
1171  v = innerTSOS.globalParameters().position();
1172  p = innerTSOS.globalParameters().momentum();
1173  math::XYZPoint inpos(v.x(), v.y(), v.z());
1174  math::XYZVector inmom(p.x(), p.y(), p.z());
1175 
1176  reco::TrackExtra trackExtra(outpos,
1177  outmom,
1178  true,
1179  inpos,
1180  inmom,
1181  true,
1182  outerTSOS.curvilinearError(),
1183  outerId,
1184  innerTSOS.curvilinearError(),
1185  innerId,
1186  trajectory.direction(),
1187  trajectory.seedRef());
1188 
1189  return trackExtra;
1190 }
1191 
1192 template <class TrackCollection>
1193 string TrackExtenderWithMTDT<TrackCollection>::dumpLayer(const DetLayer* layer) const {
1194  stringstream output;
1195 
1196  const BoundSurface* sur = nullptr;
1197  const BoundCylinder* bc = nullptr;
1198  const BoundDisk* bd = nullptr;
1199 
1200  sur = &(layer->surface());
1201  if ((bc = dynamic_cast<const BoundCylinder*>(sur))) {
1202  output << " Cylinder of radius: " << bc->radius() << endl;
1203  } else if ((bd = dynamic_cast<const BoundDisk*>(sur))) {
1204  output << " Disk at: " << bd->position().z() << endl;
1205  }
1206  return output.str();
1207 }
1208 
1209 //define this as a plug-in
1210 #include <FWCore/Framework/interface/MakerMacros.h>
1211 #include "DataFormats/TrackReco/interface/Track.h"
1212 #include "DataFormats/TrackReco/interface/TrackFwd.h"
1213 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
1214 #include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
1215 typedef TrackExtenderWithMTDT<reco::TrackCollection> TrackExtenderWithMTD;
1216 
1217 DEFINE_FWK_MODULE(TrackExtenderWithMTD);
Vector3DBase
Definition: Vector3DBase.h:8
TrackTransformer::fillPSetDescription
static void fillPSetDescription(edm::ParameterSetDescription &descriptions, bool doPredictionsOnly=false, const std::string &fitter="KFFitterForRefitInsideOut", const std::string &smoother="KFSmootherForRefitInsideOut", const std::string &propagator="SmartPropagatorAnyRK", const std::string &refitDirection="alongMomentum", bool refitRPCHits=true, const std::string &trackerRecHitBuilder="WithTrackAngle", const std::string &muonRecHitBuilder="MuonRecHitBuilder", const std::string &mtdRecHitBuilder="MTDRecHitBuilder")
fillDescriptions
Definition: TrackTransformer.cc:58
ConfigurationDescriptions.h
edm::RefProd< TrackingRecHitCollection >
TrackExtenderWithMTDT::etlMatchChi2Token
edm::EDPutToken etlMatchChi2Token
Definition: TrackExtenderWithMTD.cc:371
Propagator.h
TrackExtenderWithMTDT::theEstimator
std::unique_ptr< MeasurementEstimator > theEstimator
Definition: TrackExtenderWithMTD.cc:394
Chi2MeasurementEstimator.h
MeasurementEstimator
Definition: MeasurementEstimator.h:19
FreeTrajectoryState::momentum
GlobalVector momentum() const
Definition: FreeTrajectoryState.h:68
TrajectoryStateClosestToBeamLine
Definition: TrajectoryStateClosestToBeamLine.h:15
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
TrackExtenderWithMTDT::genVtxTimeToken_
edm::EDGetTokenT< float > genVtxTimeToken_
Definition: TrackExtenderWithMTD.cc:389
BTLDetId.h
AlCaHLTBitMon_QueryRunRegistry.comp
string comp
Definition: AlCaHLTBitMon_QueryRunRegistry.py:249
electrons_cff.bool
bool
Definition: electrons_cff.py:366
SiPixelPI::one
Definition: SiPixelPayloadInspectorHelper.h:39
edm::ESInputTag
Definition: ESInputTag.h:87
TrackExtenderWithMTDT::etlTimeChi2Cut_
const float etlTimeChi2Cut_
Definition: TrackExtenderWithMTD.cc:413
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
GeomDet
Definition: GeomDet.h:27
PixelTopology.h
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
TrackExtenderWithMTDT::magfldToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magfldToken_
Definition: TrackExtenderWithMTD.cc:404
ESHandle.h
DetLayer
Definition: DetLayer.h:21
detailsBasic3DVector::z
float float float z
Definition: extBasic3DVector.h:14
Trajectory::seedRef
edm::RefToBase< TrajectorySeed > seedRef(void) const
Definition: Trajectory.h:303
Trajectory::chiSquared
float chiSquared() const
Definition: Trajectory.h:241
GlobalTrajectoryParameters::position
GlobalPoint position() const
Definition: GlobalTrajectoryParameters.h:60
Trajectory::direction
PropagationDirection const & direction() const
Definition: Trajectory.cc:133
convertSQLitetoXML_cfg.output
output
Definition: convertSQLitetoXML_cfg.py:72
TrackExtenderWithMTDT::useSimVertex_
const bool useSimVertex_
Definition: TrackExtenderWithMTD.cc:416
patZpeak.handle
handle
Definition: patZpeak.py:23
ForwardSubdetector
ForwardSubdetector
Definition: ForwardSubdetector.h:4
edm::EDGetTokenT< InputCollection >
m_pi
#define m_pi
Definition: RPCConst.cc:8
edm
HLT enums.
Definition: AlignableModifier.h:19
TrackerTopology
Definition: TrackerTopology.h:16
reco::TrackBase::undefQuality
Definition: TrackBase.h:151
deep_tau::DeepTauBase::BasicDiscriminator
BasicDiscriminator
Definition: DeepTauBase.h:115
TransientRecHitRecord.h
TrajectoryStateOnSurface::globalPosition
GlobalPoint globalPosition() const
Definition: TrajectoryStateOnSurface.h:65
c_cm_ns
constexpr double c_cm_ns
Definition: Phase2TrackerDigitizerAlgorithm.h:51
TrackExtenderWithMTDT::estMaxChi2_
const float estMaxChi2_
Definition: TrackExtenderWithMTD.cc:408
pos
Definition: PixelAliasList.h:18
TrackExtenderWithMTDT::btlMatchTimeChi2Token
edm::EDPutToken btlMatchTimeChi2Token
Definition: TrackExtenderWithMTD.cc:372
RefitDirection::GeometricalDirection
GeometricalDirection
Definition: RefitDirection.h:15
FreeTrajectoryState::charge
TrackCharge charge() const
Definition: FreeTrajectoryState.h:69
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
Rounding.h
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
TrackExtenderWithMTDT::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: TrackExtenderWithMTD.cc:483
oppositeToMomentum
Definition: PropagationDirection.h:4
EDProducer.h
Surface
Definition: Surface.h:36
TrackExtenderWithMTDT::tmtdOrigTrkToken
edm::EDPutToken tmtdOrigTrkToken
Definition: TrackExtenderWithMTD.cc:381
TransientTrackingRecHit.h
TrajectoryMeasurement::updatedState
TrajectoryStateOnSurface const & updatedState() const
Definition: TrajectoryMeasurement.h:184
TrackExtenderWithMTDT::btlMatchChi2Token
edm::EDPutToken btlMatchChi2Token
Definition: TrackExtenderWithMTD.cc:370
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
MTDTrayBarrelLayer.h
FreeTrajectoryState::position
GlobalPoint position() const
Definition: FreeTrajectoryState.h:67
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
TrackExtenderWithMTDT::builder_
edm::ESHandle< TransientTrackBuilder > builder_
Definition: TrackExtenderWithMTD.cc:396
TransientTrack.h
findQualityFiles.v
v
Definition: findQualityFiles.py:179
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
TrackExtenderWithMTDT::genVtxPositionToken_
edm::EDGetTokenT< GlobalPoint > genVtxPositionToken_
Definition: TrackExtenderWithMTD.cc:388
ETLDetId.h
PV3DBase::mag2
T mag2() const
Definition: PV3DBase.h:63
BoundDisk
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
TrackExtenderWithMTDT::hitbuilderToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > hitbuilderToken_
Definition: TrackExtenderWithMTD.cc:399
TrackExtenderWithMTDT::bsTimeSpread_
const float bsTimeSpread_
Definition: TrackExtenderWithMTD.cc:418
TrackExtenderWithMTDT::buildTrack
reco::Track buildTrack(const reco::Track &, const Trajectory &, const Trajectory &, const reco::BeamSpot &, const MagneticField *field, const Propagator *prop, bool hasMTD, float &pathLength, float &tmtdOut, float &sigmatmtdOut) const
Definition: TrackExtenderWithMTD.cc:978
TrackExtenderWithMTDT::fillMatchingHits
void fillMatchingHits(const DetLayer *, const TrajectoryStateOnSurface &, const Trajectory &, const double, const double, const MTDTrackingDetSetVector &, const Propagator *, const reco::BeamSpot &, const double &, const bool, TransientTrackingRecHit::ConstRecHitContainer &, MTDHitMatchingInfo &) const
Definition: TrackExtenderWithMTD.cc:909
groupFilesInBlocks.reverse
reverse
Definition: groupFilesInBlocks.py:131
edm::Ref< TrackExtraCollection >
TrackExtenderWithMTDT::updateTraj_
const bool updateTraj_
Definition: TrackExtenderWithMTD.cc:392
TrackExtenderWithMTDT::propToken_
edm::ESGetToken< Propagator, TrackingComponentsRecord > propToken_
Definition: TrackExtenderWithMTD.cc:405
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
ndof
Definition: HIMultiTrackSelector.h:49
TrackExtenderWithMTDT::buildTrackExtra
reco::TrackExtra buildTrackExtra(const Trajectory &trajectory) const
Definition: TrackExtenderWithMTD.cc:1117
TrackExtenderWithMTDT::estMaxNSigma_
const float estMaxNSigma_
Definition: TrackExtenderWithMTD.cc:409
dt
float dt
Definition: AMPTWrapper.h:136
TrackExtenderWithMTDT::useVertex_
const bool useVertex_
Definition: TrackExtenderWithMTD.cc:415
Propagator
Definition: Propagator.h:44
DetId
Definition: DetId.h:17
reco::TrackExtra
Definition: TrackExtra.h:26
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
TrajectoryStateOnSurface
Definition: TrajectoryStateOnSurface.h:16
MakerMacros.h
cms::cuda::bs
bs
Definition: HistoContainer.h:76
dqmdumpme.last
last
Definition: dqmdumpme.py:56
TrackExtenderWithMTDT::ttopoToken_
edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > ttopoToken_
Definition: TrackExtenderWithMTD.cc:406
Track.h
TrajectoryStateOnSurface::freeState
FreeTrajectoryState const * freeState(bool withErrors=true) const
Definition: TrajectoryStateOnSurface.h:58
TrackExtenderWithMTDT::tryETLLayers
TransientTrackingRecHit::ConstRecHitContainer tryETLLayers(const TrajectoryStateOnSurface &, const Trajectory &traj, const double, const double, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry *, const MagneticField *field, const Propagator *prop, const reco::BeamSpot &bs, const double vtxTime, const bool matchVertex, MTDHitMatchingInfo &bestHit) const
Definition: TrackExtenderWithMTD.cc:871
TrackExtenderWithMTDT::vtxToken_
edm::EDGetTokenT< VertexCollection > vtxToken_
Definition: TrackExtenderWithMTD.cc:390
PVValHelper::estimator
estimator
Definition: PVValidationHelpers.h:45
TrackFwd.h
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
config.ordering
ordering
Definition: config.py:7
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
TrackExtenderWithMTDT::t0OrigTrkToken
edm::EDPutToken t0OrigTrkToken
Definition: TrackExtenderWithMTD.cc:378
TrackExtenderWithMTDT::TrackExtenderWithMTDT
TrackExtenderWithMTDT(const ParameterSet &pset)
Definition: TrackExtenderWithMTD.cc:422
edm::EDPutToken
Definition: EDPutToken.h:38
FrontierCondition_GT_autoExpress_cfi.t0
t0
Definition: FrontierCondition_GT_autoExpress_cfi.py:149
Bounds::inside
virtual bool inside(const Local3DPoint &) const =0
Determine if the point is inside the bounds.
TrackExtenderWithMTDT::TrackType
TrackCollection::value_type TrackType
Definition: TrackExtenderWithMTD.cc:286
FreeTrajectoryState::curvilinearError
const CurvilinearTrajectoryError & curvilinearError() const
Definition: FreeTrajectoryState.h:89
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:87
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
reco::BeamSpot
Definition: BeamSpot.h:21
reco::Track
Definition: Track.h:27
IdealMagneticFieldRecord.h
edm::ESHandle< TransientTrackBuilder >
reco::TrackExtraCollection
std::vector< TrackExtra > TrackExtraCollection
collection of TrackExtra objects
Definition: TrackExtraFwd.h:10
TrackExtenderWithMTDT::hitbuilder_
edm::ESHandle< TransientTrackingRecHitBuilder > hitbuilder_
Definition: TrackExtenderWithMTD.cc:398
TrackExtenderWithMTDT::fillValueMap
void fillValueMap(edm::Event &iEvent, const H &handle, const std::vector< T > &vec, const edm::EDPutToken &token) const
Definition: TrackExtenderWithMTD.cc:523
TrackExtenderWithMTDT::npixEndcapToken
edm::EDPutToken npixEndcapToken
Definition: TrackExtenderWithMTD.cc:375
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
Traj2TrackHits.h
Point3DBase< float, GlobalTag >
TrackExtenderWithMTDT::assocOrigTrkToken
edm::EDPutToken assocOrigTrkToken
Definition: TrackExtenderWithMTD.cc:383
ParameterSetDescription.h
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
TrackExtenderWithMTDT::bsToken_
edm::EDGetTokenT< reco::BeamSpot > bsToken_
Definition: TrackExtenderWithMTD.cc:387
MTDTrackingRecHit::timeError
float timeError() const
Definition: MTDTrackingRecHit.h:28
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:125
GlobalTrajectoryParameters::momentum
GlobalVector momentum() const
Definition: GlobalTrajectoryParameters.h:65
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
MTDTrackingRecHit.h
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: phase1PixelTopology.h:99
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
RefitDirection::undetermined
Definition: RefitDirection.h:15
edm::View
Definition: CaloClusterFwd.h:14
TrackExtenderWithMTDT::propagator_
const std::string propagator_
Definition: TrackExtenderWithMTD.cc:393
TransientTrackBuilder.h
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
edm::ParameterSet
Definition: ParameterSet.h:47
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
TrackExtenderWithMTDT::gtg_
edm::ESHandle< GlobalTrackingGeometry > gtg_
Definition: TrackExtenderWithMTD.cc:400
Trajectory::ndof
int ndof(bool bon=true) const
Definition: Trajectory.cc:97
TrackExtenderWithMTDT::theTransformer
std::unique_ptr< TrackTransformer > theTransformer
Definition: TrackExtenderWithMTD.cc:395
MTDRingForwardDoubleLayer.h
Trajectory::RecHitContainer
ConstRecHitContainer RecHitContainer
Definition: Trajectory.h:42
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
TSCBLBuilderWithPropagator.h
Event.h
TrackExtenderWithMTDT::sigmatmtdOrigTrkToken
edm::EDPutToken sigmatmtdOrigTrkToken
Definition: TrackExtenderWithMTD.cc:382
tracks
const uint32_t *__restrict__ const HitContainer *__restrict__ TkSoA *__restrict__ tracks
Definition: CAHitNtupletGeneratorKernelsImpl.h:176
TrackingRecHit::ConstRecHitContainer
std::vector< ConstRecHitPointer > ConstRecHitContainer
Definition: TrackingRecHit.h:32
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
MTDDetRing.h
TrackExtenderWithMTDT::hitsToken_
edm::EDGetTokenT< MTDTrackingDetSetVector > hitsToken_
Definition: TrackExtenderWithMTD.cc:386
GeantUnits.h
Trajectory::lastMeasurement
TrajectoryMeasurement const & lastMeasurement() const
Definition: Trajectory.h:150
trigObjTnPSource_cfi.filler
filler
Definition: trigObjTnPSource_cfi.py:21
Traj2TrackHits
Definition: Traj2TrackHits.h:16
TrackExtenderWithMTDT::mtdRecHitBuilder_
const std::string mtdRecHitBuilder_
Definition: TrackExtenderWithMTD.cc:393
FastTime
Definition: ForwardSubdetector.h:6
TrackExtenderWithMTDT::tracksToken_
edm::EDGetTokenT< InputCollection > tracksToken_
Definition: TrackExtenderWithMTD.cc:385
MTDTrackingRecHit
A 2D TrackerRecHit with time and time error information.
Definition: MTDTrackingRecHit.h:10
math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
LorentzVector.h
TrackExtenderWithMTDT::sigmat0OrigTrkToken
edm::EDPutToken sigmat0OrigTrkToken
Definition: TrackExtenderWithMTD.cc:379
createfilelist.int
int
Definition: createfilelist.py:10
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
GsfTrack.h
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:155
edm::stream::EDProducer
Definition: EDProducer.h:36
TrackExtenderWithMTDT::betaOrigTrkToken
edm::EDPutToken betaOrigTrkToken
Definition: TrackExtenderWithMTD.cc:377
cms_rounding::roundIfNear0
constexpr valType roundIfNear0(valType value, double tolerance=1.e-7)
Definition: Rounding.h:11
MagneticField.h
TrackTransformer.h
edm::EventSetup
Definition: EventSetup.h:58
MTDRecoGeometryRecord.h
reco::JetExtendedAssociation::value_type
Container::value_type value_type
Definition: JetExtendedAssociation.h:30
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
TransientTrackRecord.h
MTDDetLayerGeometry
Definition: MTDDetLayerGeometry.h:22
TrackExtenderWithMTDT::tryBTLLayers
TransientTrackingRecHit::ConstRecHitContainer tryBTLLayers(const TrajectoryStateOnSurface &, const Trajectory &traj, const double, const double, const MTDTrackingDetSetVector &, const MTDDetLayerGeometry *, const MagneticField *field, const Propagator *prop, const reco::BeamSpot &bs, const double vtxTime, const bool matchVertex, MTDHitMatchingInfo &bestHit) const
Definition: TrackExtenderWithMTD.cc:848
edm::EventSetup::getTransientHandle
ESTransientHandle< T > getTransientHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:166
MTDDetLayerGeometry::allBTLLayers
const std::vector< const DetLayer * > & allBTLLayers() const
return the BTL DetLayers (barrel), inside-out
Definition: MTDDetLayerGeometry.cc:89
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MTDTrackingRecHit::time
float time() const
Definition: MTDTrackingRecHit.h:27
Trajectory::measurements
DataContainer const & measurements() const
Definition: Trajectory.h:178
reco::TrackBase::algo
TrackAlgorithm algo() const
Definition: TrackBase.h:547
VertexFwd.h
TrajectoryMeasurement::recHit
ConstRecHitPointer const & recHit() const
Definition: TrajectoryMeasurement.h:190
callgraph.m2
m2
Definition: callgraph.py:38
TSCBLBuilderWithPropagator
Definition: TSCBLBuilderWithPropagator.h:16
Trajectory.h
Trajectory::recHits
ConstRecHitContainer recHits() const
Definition: Trajectory.h:186
edmNew::DetSetVector
Definition: DetSetNew.h:13
SiPixelPI::two
Definition: SiPixelPayloadInspectorHelper.h:39
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
TrackExtenderWithMTDT::dumpLayer
string dumpLayer(const DetLayer *layer) const
Definition: TrackExtenderWithMTD.cc:1193
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
TrackExtenderWithMTDT::npixBarrelToken
edm::EDPutToken npixBarrelToken
Definition: TrackExtenderWithMTD.cc:374
TrackExtenderWithMTDT::transientTrackBuilder_
const std::string transientTrackBuilder_
Definition: TrackExtenderWithMTD.cc:393
GsfTrackFwd.h
Trajectory::firstMeasurement
TrajectoryMeasurement const & firstMeasurement() const
Definition: Trajectory.h:166
MTDDetLayerGeometry.h
reco::TransientTrack
Definition: TransientTrack.h:19
TrackExtenderWithMTDT::pathLengthOrigTrkToken
edm::EDPutToken pathLengthOrigTrkToken
Definition: TrackExtenderWithMTD.cc:380
FreeTrajectoryState
Definition: FreeTrajectoryState.h:27
TrackExtenderWithMTDT::produce
void produce(edm::Event &ev, const edm::EventSetup &es) final
Definition: TrackExtenderWithMTD.cc:535
reco::TrackExtraBase::Chi2sFive
std::vector< unsigned char > Chi2sFive
Definition: TrackExtraBase.h:25
c_inv
constexpr double c_inv
Definition: Phase2TrackerDigitizerAlgorithm.h:52
TrajectoryMeasurement::ConstRecHitPointer
TrackingRecHit::ConstRecHitPointer ConstRecHitPointer
Definition: TrajectoryMeasurement.h:28
Vertex.h
PVValHelper::dz
Definition: PVValidationHelpers.h:51
Trajectory
Definition: Trajectory.h:38
Frameworkfwd.h
TrackExtenderWithMTDT::checkRecHitsOrdering
RefitDirection::GeometricalDirection checkRecHitsOrdering(TransientTrackingRecHit::ConstRecHitContainer const &recHits) const
Definition: TrackExtenderWithMTD.cc:337
MTDDetTray.h
TrackingComponentsRecord.h
MTDDetId
Detector identifier base class for the MIP Timing Layer.
Definition: MTDDetId.h:21
ev
bool ev
Definition: Hydjet2Hadronizer.cc:97
TrajectoryStateOnSurface::curvilinearError
const CurvilinearTrajectoryError & curvilinearError() const
Definition: TrajectoryStateOnSurface.h:72
TrackExtenderWithMTDT::pOrigTrkToken
edm::EDPutToken pOrigTrkToken
Definition: TrackExtenderWithMTD.cc:376
RefitDirection::insideOut
Definition: RefitDirection.h:15
data-class-funcs.H
H
Definition: data-class-funcs.py:33
TrackExtenderWithMTDT::gtgToken_
edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > gtgToken_
Definition: TrackExtenderWithMTD.cc:401
EventSetup.h
BoundCylinder
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
Propagator::propagateWithPath
virtual std::pair< TrajectoryStateOnSurface, double > propagateWithPath(const FreeTrajectoryState &, const Surface &) const final
Definition: Propagator.cc:10
Trajectory::closestMeasurement
TrajectoryMeasurement const & closestMeasurement(GlobalPoint) const
Definition: Trajectory.cc:256
TrajectoryStateOnSurface::surface
const SurfaceType & surface() const
Definition: TrajectoryStateOnSurface.h:78
geant_units::operators::convertMmToCm
constexpr NumType convertMmToCm(NumType millimeters)
Definition: GeantUnits.h:63
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
TrackExtenderWithMTD
TrackExtenderWithMTDT< reco::TrackCollection > TrackExtenderWithMTD
Definition: TrackExtenderWithMTD.cc:1215
MTDDetLayerGeometry::allETLLayers
const std::vector< const DetLayer * > & allETLLayers() const
return the ETL DetLayers (endcap), -Z to +Z
Definition: MTDDetLayerGeometry.cc:91
mps_fire.result
result
Definition: mps_fire.py:311
TrackExtenderWithMTDT::etlMatchTimeChi2Token
edm::EDPutToken etlMatchTimeChi2Token
Definition: TrackExtenderWithMTD.cc:373
edm::helper::Filler
Definition: ValueMap.h:22
MTDChannelIdentifier.h
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
TrajectoryStateOnSurface::globalParameters
const GlobalTrajectoryParameters & globalParameters() const
Definition: TrajectoryStateOnSurface.h:64
TrackExtenderWithMTDT::btlChi2Cut_
const float btlChi2Cut_
Definition: TrackExtenderWithMTD.cc:410
operator<
bool operator<(DTCELinkId const &lhs, DTCELinkId const &rhs)
Definition: DTCELinkId.h:70
TrajectoryStateClosestToBeamLine::isValid
bool isValid() const
Definition: TrajectoryStateClosestToBeamLine.h:50
ParameterSet.h
TrackExtenderWithMTDT::dzCut_
const float dzCut_
Definition: TrackExtenderWithMTD.cc:417
TrajectoryStateClosestToBeamLine::trackStateAtPCA
FTS const & trackStateAtPCA() const
Definition: TrajectoryStateClosestToBeamLine.h:32
DetId::Forward
Definition: DetId.h:30
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
TrackExtenderWithMTDT
Definition: TrackExtenderWithMTD.cc:284
edm::Event
Definition: Event.h:73
TrackExtenderWithMTDT::btlTimeChi2Cut_
const float btlTimeChi2Cut_
Definition: TrackExtenderWithMTD.cc:411
MTDTransientTrackingRecHitBuilder.h
MagneticField
Definition: MagneticField.h:19
volumeBasedMagneticField_160812_cfi.magfield
magfield
Definition: volumeBasedMagneticField_160812_cfi.py:11
TrackExtenderWithMTDT::dlgeoToken_
edm::ESGetToken< MTDDetLayerGeometry, MTDRecoGeometryRecord > dlgeoToken_
Definition: TrackExtenderWithMTD.cc:403
RefitDirection::outsideIn
Definition: RefitDirection.h:15
Topology.h
reco::TrackExtraBase::TrajParams
std::vector< LocalTrajectoryParameters > TrajParams
Definition: TrackExtraBase.h:24
edm::InputTag
Definition: InputTag.h:15
alongMomentum
Definition: PropagationDirection.h:4
hgcalTopologyTester_cfi.layers
layers
Definition: hgcalTopologyTester_cfi.py:8
TrackExtenderWithMTDT::etlChi2Cut_
const float etlChi2Cut_
Definition: TrackExtenderWithMTD.cc:412
TrackExtenderWithMTDT::builderToken_
edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > builderToken_
Definition: TrackExtenderWithMTD.cc:397
reco::Vertex
Definition: Vertex.h:35
edm::ParameterSet::getParameterSet
ParameterSet const & getParameterSet(std::string const &) const
Definition: ParameterSet.cc:2128
TrajectoryStateOnSurface::isValid
bool isValid() const
Definition: TrajectoryStateOnSurface.h:54
hit
Definition: SiStripHitEffFromCalibTree.cc:88
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
edm::OwnVector< TrackingRecHit >
TrackExtenderWithMTDT::InputCollection
edm::View< TrackType > InputCollection
Definition: TrackExtenderWithMTD.cc:287
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:40
unpackBuffers-CaloStage2.token
token
Definition: unpackBuffers-CaloStage2.py:316
Generated for CMSSW Reference Manual by doxygen 1.8.16