CMS 3D CMS Logo
MuonPathAssociator.cc
Go to the documentation of this file.
1 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAssociator.h"
2 #include "L1Trigger/DTTriggerPhase2/interface/MuonPathAnalyzerPerSL.h"
3 #include "L1Trigger/DTTriggerPhase2/interface/constants.h"
4 #include "FWCore/MessageLogger/interface/MessageLogger.h"
5 
6 using namespace edm;
7 using namespace std;
8 using namespace cmsdt;
9 
10 // ============================================================================
11 // Constructors and destructor
12 // ============================================================================
13 MuonPathAssociator::MuonPathAssociator(const ParameterSet &pset, edm::ConsumesCollector &iC) {
14  // Obtention of parameters
15  debug_ = pset.getUntrackedParameter<bool>("debug");
16  clean_chi2_correlation_ = pset.getUntrackedParameter<bool>("clean_chi2_correlation");
17  use_LSB_ = pset.getUntrackedParameter<bool>("use_LSB");
18  tanPsi_precision_ = pset.getUntrackedParameter<double>("tanPsi_precision");
19  x_precision_ = pset.getUntrackedParameter<double>("x_precision");
20  useBX_correlation_ = pset.getUntrackedParameter<bool>("useBX_correlation");
21  allow_confirmation_ = pset.getUntrackedParameter<bool>("allow_confirmation");
22  dT0_correlate_TP_ = pset.getUntrackedParameter<double>("dT0_correlate_TP");
23  dBX_correlate_TP_ = pset.getUntrackedParameter<int>("dBX_correlate_TP");
24  dTanPsi_correlate_TP_ = pset.getUntrackedParameter<double>("dTanPsi_correlate_TP");
25  minx_match_2digis_ = pset.getUntrackedParameter<double>("minx_match_2digis");
26  chi2corTh_ = pset.getUntrackedParameter<double>("chi2corTh");
27 
28  if (debug_)
29  LogDebug("MuonPathAssociator") << "MuonPathAssociator: constructor";
30 
31  //shift
32  int rawId;
33  shift_filename_ = pset.getParameter<edm::FileInPath>("shift_filename");
34  std::ifstream ifin3(shift_filename_.fullPath());
35  double shift;
36  if (ifin3.fail()) {
37  throw cms::Exception("Missing Input File")
38  << "MuonPathAnalyzerPerSL::MuonPathAnalyzerPerSL() - Cannot find " << shift_filename_.fullPath();
39  }
40  while (ifin3.good()) {
41  ifin3 >> rawId >> shift;
42  shiftinfo_[rawId] = shift;
43  }
44 
45  dtGeomH_ = iC.esConsumes<DTGeometry, MuonGeometryRecord, edm::Transition::BeginRun>();
46 }
47 
48 MuonPathAssociator::~MuonPathAssociator() {
49  if (debug_)
50  LogDebug("MuonPathAssociator") << "MuonPathAssociator: destructor";
51 }
52 
53 // ============================================================================
54 // Main methods (initialise, run, finish)
55 // ============================================================================
56 void MuonPathAssociator::initialise(const edm::EventSetup &iEventSetup) {
57  if (debug_)
58  LogDebug("MuonPathAssociator") << "MuonPathAssociator::initialiase";
59 
60  const MuonGeometryRecord &geom = iEventSetup.get<MuonGeometryRecord>();
61  dtGeo_ = &geom.get(dtGeomH_);
62 }
63 
64 void MuonPathAssociator::run(edm::Event &iEvent,
65  const edm::EventSetup &iEventSetup,
66  edm::Handle<DTDigiCollection> digis,
67  std::vector<metaPrimitive> &inMPaths,
68  std::vector<metaPrimitive> &outMPaths) {
69  if (dT0_correlate_TP_)
70  correlateMPaths(digis, inMPaths, outMPaths);
71  else {
72  outMPaths.insert(outMPaths.end(), inMPaths.begin(), inMPaths.end());
73  }
74 }
75 
76 void MuonPathAssociator::finish() {
77  if (debug_)
78  LogDebug("MuonPathAssociator") << "MuonPathAssociator: finish";
79 };
80 
81 void MuonPathAssociator::correlateMPaths(edm::Handle<DTDigiCollection> dtdigis,
82  std::vector<metaPrimitive> &inMPaths,
83  std::vector<metaPrimitive> &outMPaths) {
84  int x_prec_inv = (int)(1. / (10. * x_precision_));
85  int numberOfBits = (int)(round(std::log(x_prec_inv) / std::log(2.)));
86 
87  //Silvia's code for correlationg filteredMetaPrimitives
88 
89  if (debug_)
90  LogDebug("MuonPathAssociator") << "starting correlation";
91 
92  for (int wh = -2; wh <= 2; wh++) { //wheel num: -2, -1, 0, +1, +2
93  for (int st = 1; st <= 4; st++) { //station num (MB): 1, 2, 3, 4
94  for (int se = 1; se <= 14; se++) { //sector number: 1-12, special sectors 13, 14 to account for bigger MB4s
95  if (se >= 13 && st != 4)
96  continue;
97 
98  DTChamberId ChId(wh, st, se);
99  DTSuperLayerId sl1Id(wh, st, se, 1);
100  DTSuperLayerId sl3Id(wh, st, se, 3);
101 
102  //filterSL1
103  std::vector<metaPrimitive> SL1metaPrimitives;
104  for (const auto &metaprimitiveIt : inMPaths) {
105  if (metaprimitiveIt.rawId == sl1Id.rawId())
106  SL1metaPrimitives.push_back(metaprimitiveIt);
107  }
108 
109  //filterSL3
110  std::vector<metaPrimitive> SL3metaPrimitives;
111  for (const auto &metaprimitiveIt : inMPaths) {
112  if (metaprimitiveIt.rawId == sl3Id.rawId())
113  SL3metaPrimitives.push_back(metaprimitiveIt);
114  }
115 
116  if (SL1metaPrimitives.empty() and SL3metaPrimitives.empty())
117  continue;
118 
119  if (debug_)
120  LogDebug("MuonPathAssociator") << "correlating " << SL1metaPrimitives.size() << " metaPrim in SL1 and "
121  << SL3metaPrimitives.size() << " in SL3 for " << sl3Id;
122 
123  bool at_least_one_correlation = false;
124  bool at_least_one_SL1_confirmation = false;
125  bool at_least_one_SL3_confirmation = false;
126 
127  bool useFitSL1[SL1metaPrimitives.size()];
128  for (unsigned int i = 0; i < SL1metaPrimitives.size(); i++)
129  useFitSL1[i] = false;
130  bool useFitSL3[SL3metaPrimitives.size()];
131  for (unsigned int i = 0; i < SL3metaPrimitives.size(); i++)
132  useFitSL3[i] = false;
133 
134  //SL1-SL3
135  vector<metaPrimitive> chamberMetaPrimitives;
136  vector<metaPrimitive> confirmedMetaPrimitives;
137  vector<metaPrimitive> normalMetaPrimitives;
138  int sl1 = 0;
139  int sl3 = 0;
140  for (auto SL1metaPrimitive = SL1metaPrimitives.begin(); SL1metaPrimitive != SL1metaPrimitives.end();
141  ++SL1metaPrimitive, sl1++, sl3 = -1) {
142  if (clean_chi2_correlation_)
143  at_least_one_correlation = false;
144  for (auto SL3metaPrimitive = SL3metaPrimitives.begin(); SL3metaPrimitive != SL3metaPrimitives.end();
145  ++SL3metaPrimitive, sl3++) {
146  if (std::abs(SL1metaPrimitive->tanPhi - SL3metaPrimitive->tanPhi) > dTanPsi_correlate_TP_)
147  continue; //TanPsi match, SliceTest only
148  if (useBX_correlation_) {
149  if (abs(round(SL1metaPrimitive->t0 / (float)LHC_CLK_FREQ) -
150  round(SL3metaPrimitive->t0 / (float)LHC_CLK_FREQ)) > dBX_correlate_TP_)
151  continue; //BX match
152  } else {
153  if (std::abs(SL1metaPrimitive->t0 - SL3metaPrimitive->t0) >= dT0_correlate_TP_)
154  continue; //time match
155  }
156  long int PosSL1 = (int)round(10 * SL1metaPrimitive->x / (10 * x_precision_));
157  long int PosSL3 = (int)round(10 * SL3metaPrimitive->x / (10 * x_precision_));
158  double NewSlope = -999.;
159  if (use_LSB_) {
160  long int newConstant = (int)(139.5 * 4);
161  long int difPos_mm_x4 = PosSL3 - PosSL1;
162  long int tanPsi_x4096_x128 = (difPos_mm_x4)*newConstant;
163  long int tanPsi_x4096 = tanPsi_x4096_x128 / ((long int)pow(2, 5 + numberOfBits));
164  if (tanPsi_x4096 < 0 && tanPsi_x4096_x128 % ((long int)pow(2, 5 + numberOfBits)) != 0)
165  tanPsi_x4096--;
166  NewSlope = -tanPsi_x4096 * tanPsi_precision_;
167  }
168  double MeanT0 = (SL1metaPrimitive->t0 + SL3metaPrimitive->t0) / 2;
169  double MeanPos = (PosSL3 + PosSL1) / (2. / (x_precision_));
170  if (use_LSB_) {
171  MeanPos = floor(round(10. * (MeanPos / x_precision_)) * 0.1) * x_precision_;
172  }
173 
174  DTSuperLayerId SLId1(SL1metaPrimitive->rawId);
175  DTSuperLayerId SLId3(SL3metaPrimitive->rawId);
176  DTWireId wireId1(SLId1, 2, 1);
177  DTWireId wireId3(SLId3, 2, 1);
178 
179  int wi[8], tdc[8], lat[8];
180  wi[0] = SL1metaPrimitive->wi1;
181  tdc[0] = SL1metaPrimitive->tdc1;
182  lat[0] = SL1metaPrimitive->lat1;
183  wi[1] = SL1metaPrimitive->wi2;
184  tdc[1] = SL1metaPrimitive->tdc2;
185  lat[1] = SL1metaPrimitive->lat2;
186  wi[2] = SL1metaPrimitive->wi3;
187  tdc[2] = SL1metaPrimitive->tdc3;
188  lat[2] = SL1metaPrimitive->lat3;
189  wi[3] = SL1metaPrimitive->wi4;
190  tdc[3] = SL1metaPrimitive->tdc4;
191  lat[3] = SL1metaPrimitive->lat4;
192  wi[4] = SL3metaPrimitive->wi1;
193  tdc[4] = SL3metaPrimitive->tdc1;
194  lat[4] = SL3metaPrimitive->lat1;
195  wi[5] = SL3metaPrimitive->wi2;
196  tdc[5] = SL3metaPrimitive->tdc2;
197  lat[5] = SL3metaPrimitive->lat2;
198  wi[6] = SL3metaPrimitive->wi3;
199  tdc[6] = SL3metaPrimitive->tdc3;
200  lat[6] = SL3metaPrimitive->lat3;
201  wi[7] = SL3metaPrimitive->wi4;
202  tdc[7] = SL3metaPrimitive->tdc4;
203  lat[7] = SL3metaPrimitive->lat4;
204 
205  long int chi2 = 0;
206 
207  long int CH_CENTER_TO_MID_SL_P = (long int)(117.5 * 4);
208  long int Z_FACTOR_CORR[8] = {-6, -2, 2, 6, -6, -2, 2, 6};
209 
210  for (int i = 0; i < 8; i++) {
211  int sign = 2 * (i / 4) - 1;
212  Z_FACTOR_CORR[i] = Z_FACTOR_CORR[i] * CELL_HEIGHT + CH_CENTER_TO_MID_SL_P * sign;
213  }
214  long int sum_A, sum_B;
215  for (int i = 0; i < 8; i++) {
216  long int shift, slTime;
217  if (i / 4 == 0) {
218  shift = round(shiftinfo_[wireId1.rawId()] / x_precision_);
219  slTime = SL1metaPrimitive->t0;
220  } else {
221  shift = round(shiftinfo_[wireId3.rawId()] / x_precision_);
222  slTime = SL3metaPrimitive->t0;
223  }
224  if (wi[i] != -1) {
225  long int drift_speed_new = 889;
226  long int drift_dist_um_x4 = drift_speed_new * (((long int)tdc[i]) - slTime);
227  long int wireHorizPos_x4 = (42 * wi[i] + ((i + 1) % 2) * 21) / (10 * x_precision_);
228  long int pos_mm_x4;
229 
230  if (lat[i] == 0) {
231  pos_mm_x4 = wireHorizPos_x4 - (drift_dist_um_x4 >> 10);
232  } else {
233  pos_mm_x4 = wireHorizPos_x4 + (drift_dist_um_x4 >> 10);
234  }
235  sum_A = shift + pos_mm_x4 - (long int)round(MeanPos / x_precision_);
236  sum_A = sum_A << (14 - numberOfBits);
237  sum_B = Z_FACTOR_CORR[i] * (long int)round(-NewSlope / tanPsi_precision_);
238  chi2 += ((sum_A - sum_B) * (sum_A - sum_B)) >> 2;
239  }
240  }
241 
242  double newChi2 = (double)(chi2 >> 16) / (1024. * 100.);
243 
244  if (newChi2 > chi2corTh_)
245  continue;
246 
247  // Fill the used vectors
248  useFitSL1[sl1] = true;
249  useFitSL3[sl3] = true;
250 
251  int quality = 0;
252  if (SL3metaPrimitive->quality <= 2 and SL1metaPrimitive->quality <= 2)
253  quality = 6;
254 
255  if ((SL3metaPrimitive->quality >= 3 && SL1metaPrimitive->quality <= 2) or
256  (SL1metaPrimitive->quality >= 3 && SL3metaPrimitive->quality <= 2))
257  quality = 8;
258 
259  if (SL3metaPrimitive->quality >= 3 && SL1metaPrimitive->quality >= 3)
260  quality = 9;
261 
262  double z = 0;
263  if (ChId.station() >= 3)
264  z = -1.8;
265  GlobalPoint jm_x_cmssw_global = dtGeo_->chamber(ChId)->toGlobal(
266  LocalPoint(MeanPos, 0., z)); //Jm_x is already extrapolated to the middle of the SL
267  int thisec = ChId.sector();
268  if (se == 13)
269  thisec = 4;
270  if (se == 14)
271  thisec = 10;
272  double phi = jm_x_cmssw_global.phi() - 0.5235988 * (thisec - 1);
273  double psi = atan(NewSlope);
274  double phiB = hasPosRF(ChId.wheel(), ChId.sector()) ? psi - phi : -psi - phi;
275 
276  if (!clean_chi2_correlation_)
277  outMPaths.emplace_back(ChId.rawId(),
278  MeanT0,
279  MeanPos,
280  NewSlope,
281  phi,
282  phiB,
283  newChi2,
284  quality,
285  SL1metaPrimitive->wi1,
286  SL1metaPrimitive->tdc1,
287  SL1metaPrimitive->lat1,
288  SL1metaPrimitive->wi2,
289  SL1metaPrimitive->tdc2,
290  SL1metaPrimitive->lat2,
291  SL1metaPrimitive->wi3,
292  SL1metaPrimitive->tdc3,
293  SL1metaPrimitive->lat3,
294  SL1metaPrimitive->wi4,
295  SL1metaPrimitive->tdc4,
296  SL1metaPrimitive->lat4,
297  SL3metaPrimitive->wi1,
298  SL3metaPrimitive->tdc1,
299  SL3metaPrimitive->lat1,
300  SL3metaPrimitive->wi2,
301  SL3metaPrimitive->tdc2,
302  SL3metaPrimitive->lat2,
303  SL3metaPrimitive->wi3,
304  SL3metaPrimitive->tdc3,
305  SL3metaPrimitive->lat3,
306  SL3metaPrimitive->wi4,
307  SL3metaPrimitive->tdc4,
308  SL3metaPrimitive->lat4);
309  else
310  chamberMetaPrimitives.emplace_back(ChId.rawId(),
311  MeanT0,
312  MeanPos,
313  NewSlope,
314  phi,
315  phiB,
316  newChi2,
317  quality,
318  SL1metaPrimitive->wi1,
319  SL1metaPrimitive->tdc1,
320  SL1metaPrimitive->lat1,
321  SL1metaPrimitive->wi2,
322  SL1metaPrimitive->tdc2,
323  SL1metaPrimitive->lat2,
324  SL1metaPrimitive->wi3,
325  SL1metaPrimitive->tdc3,
326  SL1metaPrimitive->lat3,
327  SL1metaPrimitive->wi4,
328  SL1metaPrimitive->tdc4,
329  SL1metaPrimitive->lat4,
330  SL3metaPrimitive->wi1,
331  SL3metaPrimitive->tdc1,
332  SL3metaPrimitive->lat1,
333  SL3metaPrimitive->wi2,
334  SL3metaPrimitive->tdc2,
335  SL3metaPrimitive->lat2,
336  SL3metaPrimitive->wi3,
337  SL3metaPrimitive->tdc3,
338  SL3metaPrimitive->lat3,
339  SL3metaPrimitive->wi4,
340  SL3metaPrimitive->tdc4,
341  SL3metaPrimitive->lat4);
342 
343  at_least_one_correlation = true;
344  }
345 
346  if (at_least_one_correlation == false &&
347  allow_confirmation_ == true) { //no correlation was found, trying with pairs of two digis in the other SL
348  int matched_digis = 0;
349  double minx = minx_match_2digis_;
350  double min2x = minx_match_2digis_;
351  int best_tdc = -1;
352  int next_tdc = -1;
353  int best_wire = -1;
354  int next_wire = -1;
355  int best_layer = -1;
356  int next_layer = -1;
357  int best_lat = -1;
358  int next_lat = -1;
359  int lat = -1;
360 
361  for (const auto &dtLayerId_It : *dtdigis) {
362  const DTLayerId dtLId = dtLayerId_It.first;
363  const DTSuperLayerId &dtSLId(dtLId);
364  if (dtSLId.rawId() != sl3Id.rawId())
365  continue;
366  double l_shift = 0;
367  if (dtLId.layer() == 4)
368  l_shift = X_POS_L4;
369  else if (dtLId.layer() == 3)
370  l_shift = X_POS_L3;
371  else if (dtLId.layer() == 2)
372  l_shift = -1 * X_POS_L3;
373  else if (dtLId.layer() == 1)
374  l_shift = -1 * X_POS_L4;
375  double x_inSL3 = SL1metaPrimitive->x - SL1metaPrimitive->tanPhi * (23.5 + l_shift);
376  for (auto digiIt = (dtLayerId_It.second).first; digiIt != (dtLayerId_It.second).second; ++digiIt) {
377  DTWireId wireId(dtLId, (*digiIt).wire());
378  int x_wire = shiftinfo_[wireId.rawId()] + ((*digiIt).time() - SL1metaPrimitive->t0) * 0.00543;
379  int x_wire_left = shiftinfo_[wireId.rawId()] - ((*digiIt).time() - SL1metaPrimitive->t0) * 0.00543;
380  lat = 1;
381  if (std::abs(x_inSL3 - x_wire) > std::abs(x_inSL3 - x_wire_left)) {
382  x_wire = x_wire_left; //choose the closest laterality
383  lat = 0;
384  }
385  if (std::abs(x_inSL3 - x_wire) < minx) {
386  minx = std::abs(x_inSL3 - x_wire);
387  next_wire = best_wire;
388  next_tdc = best_tdc;
389  next_layer = best_layer;
390  next_lat = best_lat;
391 
392  best_wire = (*digiIt).wire();
393  best_tdc = (*digiIt).time();
394  best_layer = dtLId.layer();
395  best_lat = lat;
396  matched_digis++;
397  } else if ((std::abs(x_inSL3 - x_wire) >= minx) && (std::abs(x_inSL3 - x_wire) < min2x)) {
398  min2x = std::abs(x_inSL3 - x_wire);
399  next_wire = (*digiIt).wire();
400  next_tdc = (*digiIt).time();
401  next_layer = dtLId.layer();
402  next_lat = lat;
403  matched_digis++;
404  }
405  }
406  }
407  if (matched_digis >= 2 and best_layer != -1 and next_layer != -1) {
408  int new_quality = 7;
409  if (SL1metaPrimitive->quality <= 2)
410  new_quality = 5;
411 
412  int wi1 = -1;
413  int tdc1 = -1;
414  int lat1 = -1;
415  int wi2 = -1;
416  int tdc2 = -1;
417  int lat2 = -1;
418  int wi3 = -1;
419  int tdc3 = -1;
420  int lat3 = -1;
421  int wi4 = -1;
422  int tdc4 = -1;
423  int lat4 = -1;
424 
425  if (next_layer == 1) {
426  wi1 = next_wire;
427  tdc1 = next_tdc;
428  lat1 = next_lat;
429  }
430  if (next_layer == 2) {
431  wi2 = next_wire;
432  tdc2 = next_tdc;
433  lat2 = next_lat;
434  }
435  if (next_layer == 3) {
436  wi3 = next_wire;
437  tdc3 = next_tdc;
438  lat3 = next_lat;
439  }
440  if (next_layer == 4) {
441  wi4 = next_wire;
442  tdc4 = next_tdc;
443  lat4 = next_lat;
444  }
445 
446  if (best_layer == 1) {
447  wi1 = best_wire;
448  tdc1 = best_tdc;
449  lat1 = best_lat;
450  }
451  if (best_layer == 2) {
452  wi2 = best_wire;
453  tdc2 = best_tdc;
454  lat2 = best_lat;
455  }
456  if (best_layer == 3) {
457  wi3 = best_wire;
458  tdc3 = best_tdc;
459  lat3 = best_lat;
460  }
461  if (best_layer == 4) {
462  wi4 = best_wire;
463  tdc4 = best_tdc;
464  lat4 = best_lat;
465  }
466 
467  if (!clean_chi2_correlation_)
468  outMPaths.emplace_back(metaPrimitive({ChId.rawId(),
469  SL1metaPrimitive->t0,
470  SL1metaPrimitive->x,
471  SL1metaPrimitive->tanPhi,
472  SL1metaPrimitive->phi,
473  SL1metaPrimitive->phiB,
474  SL1metaPrimitive->chi2,
475  new_quality,
476  SL1metaPrimitive->wi1,
477  SL1metaPrimitive->tdc1,
478  SL1metaPrimitive->lat1,
479  SL1metaPrimitive->wi2,
480  SL1metaPrimitive->tdc2,
481  SL1metaPrimitive->lat2,
482  SL1metaPrimitive->wi3,
483  SL1metaPrimitive->tdc3,
484  SL1metaPrimitive->lat3,
485  SL1metaPrimitive->wi4,
486  SL1metaPrimitive->tdc4,
487  SL1metaPrimitive->lat4,
488  wi1,
489  tdc1,
490  lat1,
491  wi2,
492  tdc2,
493  lat2,
494  wi3,
495  tdc3,
496  lat3,
497  wi4,
498  tdc4,
499  lat4,
500  -1}));
501  else
502  confirmedMetaPrimitives.emplace_back(metaPrimitive({ChId.rawId(),
503  SL1metaPrimitive->t0,
504  SL1metaPrimitive->x,
505  SL1metaPrimitive->tanPhi,
506  SL1metaPrimitive->phi,
507  SL1metaPrimitive->phiB,
508  SL1metaPrimitive->chi2,
509  new_quality,
510  SL1metaPrimitive->wi1,
511  SL1metaPrimitive->tdc1,
512  SL1metaPrimitive->lat1,
513  SL1metaPrimitive->wi2,
514  SL1metaPrimitive->tdc2,
515  SL1metaPrimitive->lat2,
516  SL1metaPrimitive->wi3,
517  SL1metaPrimitive->tdc3,
518  SL1metaPrimitive->lat3,
519  SL1metaPrimitive->wi4,
520  SL1metaPrimitive->tdc4,
521  SL1metaPrimitive->lat4,
522  wi1,
523  tdc1,
524  lat1,
525  wi2,
526  tdc2,
527  lat2,
528  wi3,
529  tdc3,
530  lat3,
531  wi4,
532  tdc4,
533  lat4,
534  -1}));
535  useFitSL1[sl1] = true;
536  at_least_one_SL1_confirmation = true;
537  }
538  }
539  }
540 
541  //finish SL1-SL3
542 
543  //SL3-SL1
544  sl3 = 0;
545  for (auto SL3metaPrimitive = SL3metaPrimitives.begin(); SL3metaPrimitive != SL3metaPrimitives.end();
546  ++SL3metaPrimitive, sl3++) {
547  if (useFitSL3[sl3])
548  continue;
549  if ((at_least_one_correlation == false || clean_chi2_correlation_) &&
550  allow_confirmation_) { //no correlation was found, trying with pairs of two digis in the other SL
551 
552  int matched_digis = 0;
553  double minx = minx_match_2digis_;
554  double min2x = minx_match_2digis_;
555  int best_tdc = -1;
556  int next_tdc = -1;
557  int best_wire = -1;
558  int next_wire = -1;
559  int best_layer = -1;
560  int next_layer = -1;
561  int best_lat = -1;
562  int next_lat = -1;
563  int lat = -1;
564 
565  for (const auto &dtLayerId_It : *dtdigis) {
566  const DTLayerId dtLId = dtLayerId_It.first;
567  const DTSuperLayerId &dtSLId(dtLId);
568  if (dtSLId.rawId() != sl1Id.rawId())
569  continue;
570  double l_shift = 0;
571  if (dtLId.layer() == 4)
572  l_shift = 1.95;
573  if (dtLId.layer() == 3)
574  l_shift = 0.65;
575  if (dtLId.layer() == 2)
576  l_shift = -0.65;
577  if (dtLId.layer() == 1)
578  l_shift = -1.95;
579  double x_inSL1 = SL3metaPrimitive->x + SL3metaPrimitive->tanPhi * (23.5 - l_shift);
580  for (auto digiIt = (dtLayerId_It.second).first; digiIt != (dtLayerId_It.second).second; ++digiIt) {
581  DTWireId wireId(dtLId, (*digiIt).wire());
582  int x_wire = shiftinfo_[wireId.rawId()] + ((*digiIt).time() - SL3metaPrimitive->t0) * 0.00543;
583  int x_wire_left = shiftinfo_[wireId.rawId()] - ((*digiIt).time() - SL3metaPrimitive->t0) * 0.00543;
584  lat = 1;
585  if (std::abs(x_inSL1 - x_wire) > std::abs(x_inSL1 - x_wire_left)) {
586  x_wire = x_wire_left; //choose the closest laterality
587  lat = 0;
588  }
589  if (std::abs(x_inSL1 - x_wire) < minx) {
590  minx = std::abs(x_inSL1 - x_wire);
591  next_wire = best_wire;
592  next_tdc = best_tdc;
593  next_layer = best_layer;
594  next_lat = best_lat;
595 
596  best_wire = (*digiIt).wire();
597  best_tdc = (*digiIt).time();
598  best_layer = dtLId.layer();
599  best_lat = lat;
600  matched_digis++;
601  } else if ((std::abs(x_inSL1 - x_wire) >= minx) && (std::abs(x_inSL1 - x_wire) < min2x)) {
602  minx = std::abs(x_inSL1 - x_wire);
603  next_wire = (*digiIt).wire();
604  next_tdc = (*digiIt).time();
605  next_layer = dtLId.layer();
606  next_lat = lat;
607  matched_digis++;
608  }
609  }
610  }
611  if (matched_digis >= 2 and best_layer != -1 and next_layer != -1) {
612  int new_quality = 7;
613  if (SL3metaPrimitive->quality <= 2)
614  new_quality = 5;
615 
616  int wi1 = -1;
617  int tdc1 = -1;
618  int lat1 = -1;
619  int wi2 = -1;
620  int tdc2 = -1;
621  int lat2 = -1;
622  int wi3 = -1;
623  int tdc3 = -1;
624  int lat3 = -1;
625  int wi4 = -1;
626  int tdc4 = -1;
627  int lat4 = -1;
628 
629  if (next_layer == 1) {
630  wi1 = next_wire;
631  tdc1 = next_tdc;
632  lat1 = next_lat;
633  }
634  if (next_layer == 2) {
635  wi2 = next_wire;
636  tdc2 = next_tdc;
637  lat2 = next_lat;
638  }
639  if (next_layer == 3) {
640  wi3 = next_wire;
641  tdc3 = next_tdc;
642  lat3 = next_lat;
643  }
644  if (next_layer == 4) {
645  wi4 = next_wire;
646  tdc4 = next_tdc;
647  lat4 = next_lat;
648  }
649 
650  if (best_layer == 1) {
651  wi1 = best_wire;
652  tdc1 = best_tdc;
653  lat1 = best_lat;
654  }
655  if (best_layer == 2) {
656  wi2 = best_wire;
657  tdc2 = best_tdc;
658  lat2 = best_lat;
659  }
660  if (best_layer == 3) {
661  wi3 = best_wire;
662  tdc3 = best_tdc;
663  lat3 = best_lat;
664  }
665  if (best_layer == 4) {
666  wi4 = best_wire;
667  tdc4 = best_tdc;
668  lat4 = best_lat;
669  }
670 
671  if (!clean_chi2_correlation_)
672  outMPaths.push_back(metaPrimitive({ChId.rawId(),
673  SL3metaPrimitive->t0,
674  SL3metaPrimitive->x,
675  SL3metaPrimitive->tanPhi,
676  SL3metaPrimitive->phi,
677  SL3metaPrimitive->phiB,
678  SL3metaPrimitive->chi2,
679  new_quality,
680  wi1,
681  tdc1,
682  lat1,
683  wi2,
684  tdc2,
685  lat2,
686  wi3,
687  tdc3,
688  lat3,
689  wi4,
690  tdc4,
691  lat4,
692  SL3metaPrimitive->wi1,
693  SL3metaPrimitive->tdc1,
694  SL3metaPrimitive->lat1,
695  SL3metaPrimitive->wi2,
696  SL3metaPrimitive->tdc2,
697  SL3metaPrimitive->lat2,
698  SL3metaPrimitive->wi3,
699  SL3metaPrimitive->tdc3,
700  SL3metaPrimitive->lat3,
701  SL3metaPrimitive->wi4,
702  SL3metaPrimitive->tdc4,
703  SL3metaPrimitive->lat4,
704  -1}));
705  else
706  confirmedMetaPrimitives.push_back(metaPrimitive({ChId.rawId(),
707  SL3metaPrimitive->t0,
708  SL3metaPrimitive->x,
709  SL3metaPrimitive->tanPhi,
710  SL3metaPrimitive->phi,
711  SL3metaPrimitive->phiB,
712  SL3metaPrimitive->chi2,
713  new_quality,
714  wi1,
715  tdc1,
716  lat1,
717  wi2,
718  tdc2,
719  lat2,
720  wi3,
721  tdc3,
722  lat3,
723  wi4,
724  tdc4,
725  lat4,
726  SL3metaPrimitive->wi1,
727  SL3metaPrimitive->tdc1,
728  SL3metaPrimitive->lat1,
729  SL3metaPrimitive->wi2,
730  SL3metaPrimitive->tdc2,
731  SL3metaPrimitive->lat2,
732  SL3metaPrimitive->wi3,
733  SL3metaPrimitive->tdc3,
734  SL3metaPrimitive->lat3,
735  SL3metaPrimitive->wi4,
736  SL3metaPrimitive->tdc4,
737  SL3metaPrimitive->lat4,
738  -1}));
739  useFitSL3[sl3] = true;
740  at_least_one_SL3_confirmation = true;
741  }
742  }
743  }
744  // Start correlation cleaning
745  if (clean_chi2_correlation_) {
746  if (debug_)
747  LogDebug("MuonPathAssociator") << "Pushing back correlated MPs to the MPs collection";
748  removeSharingFits(chamberMetaPrimitives, outMPaths);
749  }
750  if (clean_chi2_correlation_) {
751  if (debug_)
752  LogDebug("MuonPathAssociator") << "Pushing back confirmed MPs to the complete vector";
753  removeSharingHits(confirmedMetaPrimitives, chamberMetaPrimitives, outMPaths);
754  }
755 
756  //finish SL3-SL1
757  if (at_least_one_correlation == false || clean_chi2_correlation_) {
758  if (debug_ && !at_least_one_correlation)
759  LogDebug("MuonPathAssociator")
760  << "correlation we found zero correlations, adding both collections as they are to the outMPaths";
761  if (debug_)
762  LogDebug("MuonPathAssociator")
763  << "correlation sizes:" << SL1metaPrimitives.size() << " " << SL3metaPrimitives.size();
764  if (at_least_one_SL1_confirmation == false || clean_chi2_correlation_) {
765  sl1 = 0;
766  for (auto SL1metaPrimitive = SL1metaPrimitives.begin(); SL1metaPrimitive != SL1metaPrimitives.end();
767  ++SL1metaPrimitive, sl1++) {
768  if (useFitSL1[sl1])
769  continue;
770 
771  DTSuperLayerId SLId(SL1metaPrimitive->rawId);
772  DTChamberId(SLId.wheel(), SLId.station(), SLId.sector());
773  metaPrimitive newSL1metaPrimitive = {ChId.rawId(),
774  SL1metaPrimitive->t0,
775  SL1metaPrimitive->x,
776  SL1metaPrimitive->tanPhi,
777  SL1metaPrimitive->phi,
778  SL1metaPrimitive->phiB,
779  SL1metaPrimitive->chi2,
780  SL1metaPrimitive->quality,
781  SL1metaPrimitive->wi1,
782  SL1metaPrimitive->tdc1,
783  SL1metaPrimitive->lat1,
784  SL1metaPrimitive->wi2,
785  SL1metaPrimitive->tdc2,
786  SL1metaPrimitive->lat2,
787  SL1metaPrimitive->wi3,
788  SL1metaPrimitive->tdc3,
789  SL1metaPrimitive->lat3,
790  SL1metaPrimitive->wi4,
791  SL1metaPrimitive->tdc4,
792  SL1metaPrimitive->lat4,
793  -1,
794  -1,
795  -1,
796  -1,
797  -1,
798  -1,
799  -1,
800  -1,
801  -1,
802  -1,
803  -1,
804  -1,
805  -1};
806 
807  bool ok = true;
808  for (auto &metaPrimitive : chamberMetaPrimitives) {
809  if (!isNotAPrimo(newSL1metaPrimitive, metaPrimitive)) {
810  ok = false;
811  break;
812  }
813  }
814  if (!ok)
815  continue;
816 
817  if (!clean_chi2_correlation_)
818  outMPaths.push_back(newSL1metaPrimitive);
819  else
820  normalMetaPrimitives.push_back(newSL1metaPrimitive);
821  }
822  }
823  if (at_least_one_SL3_confirmation == false || clean_chi2_correlation_) {
824  sl3 = 0;
825  for (auto SL3metaPrimitive = SL3metaPrimitives.begin(); SL3metaPrimitive != SL3metaPrimitives.end();
826  ++SL3metaPrimitive, sl3++) {
827  if (useFitSL3[sl3])
828  continue;
829  DTSuperLayerId SLId(SL3metaPrimitive->rawId);
830  DTChamberId(SLId.wheel(), SLId.station(), SLId.sector());
831  metaPrimitive newSL3metaPrimitive = {ChId.rawId(),
832  SL3metaPrimitive->t0,
833  SL3metaPrimitive->x,
834  SL3metaPrimitive->tanPhi,
835  SL3metaPrimitive->phi,
836  SL3metaPrimitive->phiB,
837  SL3metaPrimitive->chi2,
838  SL3metaPrimitive->quality,
839  -1,
840  -1,
841  -1,
842  -1,
843  -1,
844  -1,
845  -1,
846  -1,
847  -1,
848  -1,
849  -1,
850  -1,
851  SL3metaPrimitive->wi1,
852  SL3metaPrimitive->tdc1,
853  SL3metaPrimitive->lat1,
854  SL3metaPrimitive->wi2,
855  SL3metaPrimitive->tdc2,
856  SL3metaPrimitive->lat2,
857  SL3metaPrimitive->wi3,
858  SL3metaPrimitive->tdc3,
859  SL3metaPrimitive->lat3,
860  SL3metaPrimitive->wi4,
861  SL3metaPrimitive->tdc4,
862  SL3metaPrimitive->lat4,
863  -1};
864 
865  if (!clean_chi2_correlation_)
866  outMPaths.push_back(newSL3metaPrimitive);
867  else
868  normalMetaPrimitives.push_back(newSL3metaPrimitive);
869  }
870  }
871  }
872 
873  SL1metaPrimitives.clear();
874  SL1metaPrimitives.erase(SL1metaPrimitives.begin(), SL1metaPrimitives.end());
875  SL3metaPrimitives.clear();
876  SL3metaPrimitives.erase(SL3metaPrimitives.begin(), SL3metaPrimitives.end());
877 
878  vector<metaPrimitive> auxMetaPrimitives;
879  if (clean_chi2_correlation_) {
880  if (debug_)
881  LogDebug("MuonPathAssociator") << "Pushing back normal MPs to the auxiliar vector";
882  removeSharingHits(normalMetaPrimitives, confirmedMetaPrimitives, auxMetaPrimitives);
883  }
884  if (clean_chi2_correlation_) {
885  if (debug_)
886  LogDebug("MuonPathAssociator") << "Pushing back normal MPs to the MPs collection";
887  removeSharingHits(auxMetaPrimitives, chamberMetaPrimitives, outMPaths);
888  }
889  }
890  }
891  }
892 }
893 
894 void MuonPathAssociator::removeSharingFits(vector<metaPrimitive> &chamberMPaths, vector<metaPrimitive> &allMPaths) {
895  bool useFit[chamberMPaths.size()];
896  for (unsigned int i = 0; i < chamberMPaths.size(); i++) {
897  useFit[i] = true;
898  }
899  for (unsigned int i = 0; i < chamberMPaths.size(); i++) {
900  if (debug_)
901  LogDebug("MuonPathAssociator") << "Looking at prim" << i;
902  if (!useFit[i])
903  continue;
904  for (unsigned int j = i + 1; j < chamberMPaths.size(); j++) {
905  if (debug_)
906  LogDebug("MuonPathAssociator") << "Comparing with prim " << j;
907  if (!useFit[j])
908  continue;
909  metaPrimitive first = chamberMPaths[i];
910  metaPrimitive second = chamberMPaths[j];
911  if (shareFit(first, second)) {
912  if (first.quality > second.quality)
913  useFit[j] = false;
914  else if (first.quality < second.quality)
915  useFit[i] = false;
916  else {
917  if (first.chi2 < second.chi2)
918  useFit[j] = false;
919  else {
920  useFit[i] = false;
921  break;
922  }
923  }
924  }
925  }
926  if (useFit[i]) {
927  if (debug_)
928  printmPC(chamberMPaths[i]);
929  allMPaths.push_back(chamberMPaths[i]);
930  }
931  }
932  if (debug_)
933  LogDebug("MuonPathAssociator") << "---Swapping chamber---";
934 }
935 
936 void MuonPathAssociator::removeSharingHits(std::vector<metaPrimitive> &firstMPaths,
937  std::vector<metaPrimitive> &secondMPaths,
938  std::vector<metaPrimitive> &allMPaths) {
939  for (auto &firstMP : firstMPaths) {
940  if (debug_)
941  LogDebug("MuonPathAssociator") << "----------------------------------";
942  if (debug_)
943  LogDebug("MuonPathAssociator") << "Turn for ";
944  if (debug_)
945  printmPC(firstMP);
946  bool ok = true;
947  for (auto &secondMP : secondMPaths) {
948  if (debug_)
949  LogDebug("MuonPathAssociator") << "Comparing with ";
950  if (debug_)
951  printmPC(secondMP);
952  if (!isNotAPrimo(firstMP, secondMP)) {
953  ok = false;
954  break;
955  }
956  }
957  if (ok) {
958  allMPaths.push_back(firstMP);
959  if (debug_)
960  printmPC(firstMP);
961  }
962  if (debug_)
963  LogDebug("MuonPathAssociator") << "----------------------------------";
964  }
965 }
966 
967 bool MuonPathAssociator::shareFit(metaPrimitive first, metaPrimitive second) {
968  bool lay1 = (first.wi1 == second.wi1) && (first.tdc1 = second.tdc1);
969  bool lay2 = (first.wi2 == second.wi2) && (first.tdc2 = second.tdc2);
970  bool lay3 = (first.wi3 == second.wi3) && (first.tdc3 = second.tdc3);
971  bool lay4 = (first.wi4 == second.wi4) && (first.tdc4 = second.tdc4);
972  bool lay5 = (first.wi5 == second.wi5) && (first.tdc5 = second.tdc5);
973  bool lay6 = (first.wi6 == second.wi6) && (first.tdc6 = second.tdc6);
974  bool lay7 = (first.wi7 == second.wi7) && (first.tdc7 = second.tdc7);
975  bool lay8 = (first.wi8 == second.wi8) && (first.tdc8 = second.tdc8);
976 
977  if (lay1 && lay2 && lay3 && lay4) {
978  if (lay5 || lay6 || lay7 || lay8)
979  return true;
980  else
981  return false;
982  } else if (lay5 && lay6 && lay7 && lay8) {
983  if (lay1 || lay2 || lay3 || lay4)
984  return true;
985  else
986  return false;
987  } else
988  return false;
989 }
990 
991 bool MuonPathAssociator::isNotAPrimo(metaPrimitive first, metaPrimitive second) {
992  int hitsSL1 = (first.wi1 != -1) + (first.wi2 != -1) + (first.wi3 != -1) + (first.wi4 != -1);
993  int hitsSL3 = (first.wi5 != -1) + (first.wi6 != -1) + (first.wi7 != -1) + (first.wi8 != -1);
994 
995  bool lay1 = (first.wi1 == second.wi1) && (first.tdc1 = second.tdc1) && (first.wi1 != -1);
996  bool lay2 = (first.wi2 == second.wi2) && (first.tdc2 = second.tdc2) && (first.wi2 != -1);
997  bool lay3 = (first.wi3 == second.wi3) && (first.tdc3 = second.tdc3) && (first.wi3 != -1);
998  bool lay4 = (first.wi4 == second.wi4) && (first.tdc4 = second.tdc4) && (first.wi4 != -1);
999  bool lay5 = (first.wi5 == second.wi5) && (first.tdc5 = second.tdc5) && (first.wi5 != -1);
1000  bool lay6 = (first.wi6 == second.wi6) && (first.tdc6 = second.tdc6) && (first.wi6 != -1);
1001  bool lay7 = (first.wi7 == second.wi7) && (first.tdc7 = second.tdc7) && (first.wi7 != -1);
1002  bool lay8 = (first.wi8 == second.wi8) && (first.tdc8 = second.tdc8) && (first.wi8 != -1);
1003 
1004  return (((!lay1 && !lay2 && !lay3 && !lay4) || hitsSL1 < 3) && ((!lay5 && !lay6 && !lay7 && !lay8) || hitsSL3 < 3));
1005 }
1006 
1007 void MuonPathAssociator::printmPC(metaPrimitive mP) {
1008  DTChamberId ChId(mP.rawId);
1009  LogDebug("MuonPathAssociator") << ChId << "\t"
1010  << " " << setw(2) << left << mP.wi1 << " " << setw(2) << left << mP.wi2 << " "
1011  << setw(2) << left << mP.wi3 << " " << setw(2) << left << mP.wi4 << " " << setw(2)
1012  << left << mP.wi5 << " " << setw(2) << left << mP.wi6 << " " << setw(2) << left
1013  << mP.wi7 << " " << setw(2) << left << mP.wi8 << " " << setw(5) << left << mP.tdc1
1014  << " " << setw(5) << left << mP.tdc2 << " " << setw(5) << left << mP.tdc3 << " "
1015  << setw(5) << left << mP.tdc4 << " " << setw(5) << left << mP.tdc5 << " " << setw(5)
1016  << left << mP.tdc6 << " " << setw(5) << left << mP.tdc7 << " " << setw(5) << left
1017  << mP.tdc8 << " " << setw(2) << left << mP.lat1 << " " << setw(2) << left << mP.lat2
1018  << " " << setw(2) << left << mP.lat3 << " " << setw(2) << left << mP.lat4 << " "
1019  << setw(2) << left << mP.lat5 << " " << setw(2) << left << mP.lat6 << " " << setw(2)
1020  << left << mP.lat7 << " " << setw(2) << left << mP.lat8 << " " << setw(10) << right
1021  << mP.x << " " << setw(9) << left << mP.tanPhi << " " << setw(5) << left << mP.t0
1022  << " " << setw(13) << left << mP.chi2 << " \n";
1023 }
DTGeometry
Definition: DTGeometry.h:28
cmsdt::metaPrimitive
Definition: constants.h:48
DTSuperLayerId
Definition: DTSuperLayerId.h:12
mps_fire.i
i
Definition: mps_fire.py:428
MessageLogger.h
cmsdt::metaPrimitive::rawId
uint32_t rawId
Definition: constants.h:118
cmsdt::metaPrimitive::x
double x
Definition: constants.h:120
MuonPathAssociator::run
void run(edm::Event &iEvent, const edm::EventSetup &iEventSetup, edm::Handle< DTDigiCollection > digis, std::vector< cmsdt::metaPrimitive > &inMPaths, std::vector< cmsdt::metaPrimitive > &outMPaths)
Definition: MuonPathAssociator.cc:64
edm
HLT enums.
Definition: AlignableModifier.h:19
cmsdt::metaPrimitive::lat8
int lat8
Definition: constants.h:149
cmsdt::metaPrimitive::wi1
int wi1
Definition: constants.h:126
cmsdt::metaPrimitive::wi8
int wi8
Definition: constants.h:147
MuonPathAssociator::finish
void finish()
Definition: MuonPathAssociator.cc:76
Validation_hcalonly_cfi.sign
sign
Definition: Validation_hcalonly_cfi.py:32
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
cmsdt::metaPrimitive::lat4
int lat4
Definition: constants.h:137
align::LocalPoint
Point3DBase< Scalar, LocalTag > LocalPoint
Definition: Definitions.h:30
MuonPathAssociator::shareFit
bool shareFit(cmsdt::metaPrimitive first, cmsdt::metaPrimitive second)
Definition: MuonPathAssociator.cc:967
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
edm::ConsumesCollector::esConsumes
auto esConsumes()
Definition: ConsumesCollector.h:97
edm::Handle< DTDigiCollection >
cmsdt::metaPrimitive::tdc8
int tdc8
Definition: constants.h:148
MuonPathAssociator::removeSharingFits
void removeSharingFits(std::vector< cmsdt::metaPrimitive > &chamberMPaths, std::vector< cmsdt::metaPrimitive > &allMPaths)
Definition: MuonPathAssociator.cc:894
MuonPathAssociator::removeSharingHits
void removeSharingHits(std::vector< cmsdt::metaPrimitive > &firstMPaths, std::vector< cmsdt::metaPrimitive > &secondMPaths, std::vector< cmsdt::metaPrimitive > &allMPaths)
Definition: MuonPathAssociator.cc:936
cmsdt::metaPrimitive::tdc1
int tdc1
Definition: constants.h:127
edm::first
T first(std::pair< T, U > const &p)
Definition: ParameterSet.cc:217
MuonPathAssociator::initialise
void initialise(const edm::EventSetup &iEventSetup)
Definition: MuonPathAssociator.cc:56
TrackerOfflineValidationSummary_cfi.useFit
useFit
Definition: TrackerOfflineValidationSummary_cfi.py:5
edm::FileInPath
Definition: FileInPath.h:64
cmsdt
Definition: constants.h:39
constants.h
edm::EventSetup::get
T get() const
Definition: EventSetup.h:80
cmsdt::metaPrimitive::lat5
int lat5
Definition: constants.h:140
DTWireId
Definition: DTWireId.h:12
cmsdt::metaPrimitive::lat6
int lat6
Definition: constants.h:143
cmsdt::metaPrimitive::wi2
int wi2
Definition: constants.h:129
cmsdt::metaPrimitive::tdc7
int tdc7
Definition: constants.h:145
cmsdt::metaPrimitive::lat1
int lat1
Definition: constants.h:128
MuonPathAnalyzerPerSL.h
cmsdt::metaPrimitive::wi7
int wi7
Definition: constants.h:144
cmsdt::metaPrimitive::wi6
int wi6
Definition: constants.h:141
relativeConstraints.geom
geom
Definition: relativeConstraints.py:72
cmsdt::metaPrimitive::tdc3
int tdc3
Definition: constants.h:133
MuonPathAssociator::~MuonPathAssociator
~MuonPathAssociator()
Definition: MuonPathAssociator.cc:48
cmsdt::metaPrimitive::lat7
int lat7
Definition: constants.h:146
Point3DBase< float, GlobalTag >
DTLayerId
Definition: DTLayerId.h:12
cmsdt::metaPrimitive::wi5
int wi5
Definition: constants.h:138
cmsdt::LHC_CLK_FREQ
constexpr int LHC_CLK_FREQ
Definition: constants.h:169
MuonPathAssociator::MuonPathAssociator
MuonPathAssociator(const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
Definition: MuonPathAssociator.cc:13
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
edm::ParameterSet
Definition: ParameterSet.h:47
cmsdt::metaPrimitive::lat2
int lat2
Definition: constants.h:131
IntegrityClient_cfi.ChId
ChId
Definition: IntegrityClient_cfi.py:18
cmsdt::metaPrimitive::wi4
int wi4
Definition: constants.h:135
MuonPathAssociator::correlateMPaths
void correlateMPaths(edm::Handle< DTDigiCollection > digis, std::vector< cmsdt::metaPrimitive > &inMPaths, std::vector< cmsdt::metaPrimitive > &outMPaths)
Definition: MuonPathAssociator.cc:81
cmsdt::metaPrimitive::tdc5
int tdc5
Definition: constants.h:139
createfilelist.int
int
Definition: createfilelist.py:10
iEvent
int iEvent
Definition: GenABIO.cc:224
cmsdt::metaPrimitive::tdc6
int tdc6
Definition: constants.h:142
MuonPathAssociator::printmPC
void printmPC(cmsdt::metaPrimitive mP)
Definition: MuonPathAssociator.cc:1007
edm::EventSetup
Definition: EventSetup.h:57
cmsdt::metaPrimitive::tanPhi
double tanPhi
Definition: constants.h:121
cmsdt::CELL_HEIGHT
constexpr int CELL_HEIGHT
Definition: constants.h:177
cmsdt::metaPrimitive::tdc4
int tdc4
Definition: constants.h:136
cmsdt::metaPrimitive::chi2
double chi2
Definition: constants.h:124
psi
std::map< std::string, int, std::less< std::string > > psi
Definition: CountProcessesAction.h:15
DTChamberId::sector
int sector() const
Definition: DTChamberId.h:49
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
edm::shift
static unsigned const int shift
Definition: LuminosityBlockID.cc:7
cmsdt::X_POS_L3
constexpr double X_POS_L3
Definition: constants.h:245
edm::Transition::BeginRun
Exception
Definition: hltDiff.cc:246
cmsdt::metaPrimitive::tdc2
int tdc2
Definition: constants.h:130
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
DTChamberId
Definition: DTChamberId.h:14
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
edm::Event
Definition: Event.h:73
cmsdt::metaPrimitive::lat3
int lat3
Definition: constants.h:134
DTLayerId::layer
int layer() const
Return the layer number.
Definition: DTLayerId.h:42
MuonPathAssociator::isNotAPrimo
bool isNotAPrimo(cmsdt::metaPrimitive first, cmsdt::metaPrimitive second)
Definition: MuonPathAssociator.cc:991
MuonGeometryRecord
Definition: MuonGeometryRecord.h:34
DTChamberId::wheel
int wheel() const
Return the wheel number.
Definition: DTChamberId.h:39
cmsdt::X_POS_L4
constexpr double X_POS_L4
Definition: constants.h:246
MuonPathAssociator.h
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
cmsdt::metaPrimitive::wi3
int wi3
Definition: constants.h:132
DTChamberId::station
int station() const
Return the station number.
Definition: DTChamberId.h:42
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
cmsdt::metaPrimitive::t0
double t0
Definition: constants.h:119
Generated for CMSSW Reference Manual by doxygen 1.8.16