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

#include <MuonPathAssociator.h>

Public Member Functions

void finish ()
 
void initialise (const edm::EventSetup &iEventSetup)
 
bool isNotAPrimo (cmsdt::metaPrimitive first, cmsdt::metaPrimitive second)
 
 MuonPathAssociator (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
 
void printmPC (cmsdt::metaPrimitive mP)
 
void removeSharingFits (std::vector< cmsdt::metaPrimitive > &chamberMPaths, std::vector< cmsdt::metaPrimitive > &allMPaths)
 
void removeSharingHits (std::vector< cmsdt::metaPrimitive > &firstMPaths, std::vector< cmsdt::metaPrimitive > &secondMPaths, std::vector< cmsdt::metaPrimitive > &allMPaths)
 
void run (edm::Event &iEvent, const edm::EventSetup &iEventSetup, edm::Handle< DTDigiCollection > digis, std::vector< cmsdt::metaPrimitive > &inMPaths, std::vector< cmsdt::metaPrimitive > &outMPaths)
 
bool shareFit (cmsdt::metaPrimitive first, cmsdt::metaPrimitive second)
 
 ~MuonPathAssociator ()
 

Public Attributes

const DTGeometry * dtGeo_
 
edm::ESGetToken< DTGeometry, MuonGeometryRecord > dtGeomH_
 

Private Member Functions

void correlateMPaths (edm::Handle< DTDigiCollection > digis, std::vector< cmsdt::metaPrimitive > &inMPaths, std::vector< cmsdt::metaPrimitive > &outMPaths)
 
bool hasPosRF (int wh, int sec)
 

Private Attributes

bool allow_confirmation_
 
double chi2corTh_
 
bool clean_chi2_correlation_
 
double dBX_correlate_TP_
 
bool debug_
 
double dT0_correlate_TP_
 
double dTanPsi_correlate_TP_
 
double minx_match_2digis_
 
edm::FileInPath shift_filename_
 
std::map< int, float > shiftinfo_
 
double tanPsi_precision_
 
bool use_LSB_
 
bool useBX_correlation_
 
double x_precision_
 

Detailed Description

Definition at line 34 of file MuonPathAssociator.h.

Constructor & Destructor Documentation

◆ MuonPathAssociator()

MuonPathAssociator::MuonPathAssociator ( const edm::ParameterSet &  pset,
edm::ConsumesCollector &  iC 
)

Definition at line 13 of file MuonPathAssociator.cc.

13  {
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 }

References edm::BeginRun, edm::ConsumesCollector::esConsumes(), Exception, LogDebug, muonDTDigis_cfi::pset, and edm::shift.

◆ ~MuonPathAssociator()

MuonPathAssociator::~MuonPathAssociator ( )

Definition at line 48 of file MuonPathAssociator.cc.

48  {
49  if (debug_)
50  LogDebug("MuonPathAssociator") << "MuonPathAssociator: destructor";
51 }

References LogDebug.

Member Function Documentation

◆ correlateMPaths()

void MuonPathAssociator::correlateMPaths ( edm::Handle< DTDigiCollection >  digis,
std::vector< cmsdt::metaPrimitive > &  inMPaths,
std::vector< cmsdt::metaPrimitive > &  outMPaths 
)
private

Definition at line 81 of file MuonPathAssociator.cc.

83  {
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 }

References funct::abs(), cmsdt::CELL_HEIGHT, hltPixelTracks_cff::chi2, IntegrityClient_cfi::ChId, mps_fire::i, createfilelist::int, DTLayerId::layer(), cmsdt::LHC_CLK_FREQ, dqm-mbProfile::log, LogDebug, convertSQLiteXML::ok, or, PV3DBase< T, PVType, FrameType >::phi(), funct::pow(), qcdUeDQM_cfi::quality, DetId::rawId(), edm::second(), DTChamberId::sector(), edm::shift, Validation_hcalonly_cfi::sign, DTChamberId::station(), DTChamberId::wheel(), cmsdt::X_POS_L3, and cmsdt::X_POS_L4.

◆ finish()

void MuonPathAssociator::finish ( )

Definition at line 76 of file MuonPathAssociator.cc.

76  {
77  if (debug_)
78  LogDebug("MuonPathAssociator") << "MuonPathAssociator: finish";
79 };

References LogDebug.

Referenced by progressbar.ProgressBar::__next__().

◆ hasPosRF()

bool MuonPathAssociator::hasPosRF ( int  wh,
int  sec 
)
inlineprivate

Definition at line 71 of file MuonPathAssociator.h.

71 { return wh > 0 || (wh == 0 && sec % 4 > 1); }

References fileinputsource_cfi::sec.

◆ initialise()

void MuonPathAssociator::initialise ( const edm::EventSetup &  iEventSetup)

Definition at line 56 of file MuonPathAssociator.cc.

56  {
57  if (debug_)
58  LogDebug("MuonPathAssociator") << "MuonPathAssociator::initialiase";
59 
60  const MuonGeometryRecord &geom = iEventSetup.get<MuonGeometryRecord>();
61  dtGeo_ = &geom.get(dtGeomH_);
62 }

References relativeConstraints::geom, edm::EventSetup::get(), and LogDebug.

◆ isNotAPrimo()

bool MuonPathAssociator::isNotAPrimo ( cmsdt::metaPrimitive  first,
cmsdt::metaPrimitive  second 
)

Definition at line 991 of file MuonPathAssociator.cc.

991  {
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 }

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

◆ printmPC()

void MuonPathAssociator::printmPC ( cmsdt::metaPrimitive  mP)

Definition at line 1007 of file MuonPathAssociator.cc.

1007  {
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 }

References cmsdt::metaPrimitive::chi2, IntegrityClient_cfi::ChId, cmsdt::metaPrimitive::lat1, cmsdt::metaPrimitive::lat2, cmsdt::metaPrimitive::lat3, cmsdt::metaPrimitive::lat4, cmsdt::metaPrimitive::lat5, cmsdt::metaPrimitive::lat6, cmsdt::metaPrimitive::lat7, cmsdt::metaPrimitive::lat8, LogDebug, cmsdt::metaPrimitive::rawId, cmsdt::metaPrimitive::t0, cmsdt::metaPrimitive::tanPhi, cmsdt::metaPrimitive::tdc1, cmsdt::metaPrimitive::tdc2, cmsdt::metaPrimitive::tdc3, cmsdt::metaPrimitive::tdc4, cmsdt::metaPrimitive::tdc5, cmsdt::metaPrimitive::tdc6, cmsdt::metaPrimitive::tdc7, cmsdt::metaPrimitive::tdc8, cmsdt::metaPrimitive::wi1, cmsdt::metaPrimitive::wi2, cmsdt::metaPrimitive::wi3, cmsdt::metaPrimitive::wi4, cmsdt::metaPrimitive::wi5, cmsdt::metaPrimitive::wi6, cmsdt::metaPrimitive::wi7, cmsdt::metaPrimitive::wi8, and cmsdt::metaPrimitive::x.

◆ removeSharingFits()

void MuonPathAssociator::removeSharingFits ( std::vector< cmsdt::metaPrimitive > &  chamberMPaths,
std::vector< cmsdt::metaPrimitive > &  allMPaths 
)

Definition at line 894 of file MuonPathAssociator.cc.

894  {
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 }

References edm::first(), mps_fire::i, dqmiolumiharvest::j, LogDebug, edm::second(), and TrackerOfflineValidationSummary_cfi::useFit.

◆ removeSharingHits()

void MuonPathAssociator::removeSharingHits ( std::vector< cmsdt::metaPrimitive > &  firstMPaths,
std::vector< cmsdt::metaPrimitive > &  secondMPaths,
std::vector< cmsdt::metaPrimitive > &  allMPaths 
)

Definition at line 936 of file MuonPathAssociator.cc.

938  {
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 }

References LogDebug, and convertSQLiteXML::ok.

◆ run()

void MuonPathAssociator::run ( edm::Event &  iEvent,
const edm::EventSetup &  iEventSetup,
edm::Handle< DTDigiCollection >  digis,
std::vector< cmsdt::metaPrimitive > &  inMPaths,
std::vector< cmsdt::metaPrimitive > &  outMPaths 
)

Definition at line 64 of file MuonPathAssociator.cc.

68  {
69  if (dT0_correlate_TP_)
70  correlateMPaths(digis, inMPaths, outMPaths);
71  else {
72  outMPaths.insert(outMPaths.end(), inMPaths.begin(), inMPaths.end());
73  }
74 }

◆ shareFit()

bool MuonPathAssociator::shareFit ( cmsdt::metaPrimitive  first,
cmsdt::metaPrimitive  second 
)

Definition at line 967 of file MuonPathAssociator.cc.

967  {
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 }

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

Member Data Documentation

◆ allow_confirmation_

bool MuonPathAssociator::allow_confirmation_
private

Definition at line 77 of file MuonPathAssociator.h.

◆ chi2corTh_

double MuonPathAssociator::chi2corTh_
private

Definition at line 82 of file MuonPathAssociator.h.

◆ clean_chi2_correlation_

bool MuonPathAssociator::clean_chi2_correlation_
private

Definition at line 75 of file MuonPathAssociator.h.

◆ dBX_correlate_TP_

double MuonPathAssociator::dBX_correlate_TP_
private

Definition at line 79 of file MuonPathAssociator.h.

◆ debug_

bool MuonPathAssociator::debug_
private

Definition at line 74 of file MuonPathAssociator.h.

◆ dT0_correlate_TP_

double MuonPathAssociator::dT0_correlate_TP_
private

Definition at line 78 of file MuonPathAssociator.h.

◆ dTanPsi_correlate_TP_

double MuonPathAssociator::dTanPsi_correlate_TP_
private

Definition at line 80 of file MuonPathAssociator.h.

◆ dtGeo_

const DTGeometry* MuonPathAssociator::dtGeo_

Definition at line 62 of file MuonPathAssociator.h.

◆ dtGeomH_

edm::ESGetToken<DTGeometry, MuonGeometryRecord> MuonPathAssociator::dtGeomH_

Definition at line 63 of file MuonPathAssociator.h.

◆ minx_match_2digis_

double MuonPathAssociator::minx_match_2digis_
private

Definition at line 81 of file MuonPathAssociator.h.

◆ shift_filename_

edm::FileInPath MuonPathAssociator::shift_filename_
private

Definition at line 88 of file MuonPathAssociator.h.

◆ shiftinfo_

std::map<int, float> MuonPathAssociator::shiftinfo_
private

Definition at line 89 of file MuonPathAssociator.h.

◆ tanPsi_precision_

double MuonPathAssociator::tanPsi_precision_
private

Definition at line 84 of file MuonPathAssociator.h.

◆ use_LSB_

bool MuonPathAssociator::use_LSB_
private

Definition at line 83 of file MuonPathAssociator.h.

◆ useBX_correlation_

bool MuonPathAssociator::useBX_correlation_
private

Definition at line 76 of file MuonPathAssociator.h.

◆ x_precision_

double MuonPathAssociator::x_precision_
private

Definition at line 85 of file MuonPathAssociator.h.

DTGeometry
Definition: DTGeometry.h:28
cmsdt::metaPrimitive
Definition: constants.h:48
MuonPathAssociator::chi2corTh_
double chi2corTh_
Definition: MuonPathAssociator.h:82
DTSuperLayerId
Definition: DTSuperLayerId.h:12
mps_fire.i
i
Definition: mps_fire.py:428
MuonPathAssociator::clean_chi2_correlation_
bool clean_chi2_correlation_
Definition: MuonPathAssociator.h:75
cmsdt::metaPrimitive::rawId
uint32_t rawId
Definition: constants.h:118
cmsdt::metaPrimitive::x
double x
Definition: constants.h:120
cmsdt::metaPrimitive::lat8
int lat8
Definition: constants.h:149
MuonPathAssociator::tanPsi_precision_
double tanPsi_precision_
Definition: MuonPathAssociator.h:84
cmsdt::metaPrimitive::wi1
int wi1
Definition: constants.h:126
cmsdt::metaPrimitive::wi8
int wi8
Definition: constants.h:147
MuonPathAssociator::dBX_correlate_TP_
double dBX_correlate_TP_
Definition: MuonPathAssociator.h:79
MuonPathAssociator::hasPosRF
bool hasPosRF(int wh, int sec)
Definition: MuonPathAssociator.h:71
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
MuonPathAssociator::shift_filename_
edm::FileInPath shift_filename_
Definition: MuonPathAssociator.h:88
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
edm::ConsumesCollector::esConsumes
auto esConsumes()
Definition: ConsumesCollector.h:97
cmsdt::metaPrimitive::tdc8
int tdc8
Definition: constants.h:148
dqmdumpme.first
first
Definition: dqmdumpme.py:55
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
DTGeometry::chamber
const DTChamber * chamber(const DTChamberId &id) const
Return a DTChamber given its id.
Definition: DTGeometry.cc:90
MuonPathAssociator::dtGeomH_
edm::ESGetToken< DTGeometry, MuonGeometryRecord > dtGeomH_
Definition: MuonPathAssociator.h:63
cmsdt::metaPrimitive::tdc1
int tdc1
Definition: constants.h:127
TrackerOfflineValidationSummary_cfi.useFit
useFit
Definition: TrackerOfflineValidationSummary_cfi.py:5
MuonPathAssociator::dT0_correlate_TP_
double dT0_correlate_TP_
Definition: MuonPathAssociator.h:78
edm::FileInPath
Definition: FileInPath.h:64
MuonPathAssociator::minx_match_2digis_
double minx_match_2digis_
Definition: MuonPathAssociator.h:81
edm::EventSetup::get
T get() const
Definition: EventSetup.h:80
MuonPathAssociator::use_LSB_
bool use_LSB_
Definition: MuonPathAssociator.h:83
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
DDAxes::z
cmsdt::metaPrimitive::lat1
int lat1
Definition: constants.h:128
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
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
GeomDet::toGlobal
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
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
MuonPathAssociator::dTanPsi_correlate_TP_
double dTanPsi_correlate_TP_
Definition: MuonPathAssociator.h:80
createfilelist.int
int
Definition: createfilelist.py:10
cmsdt::metaPrimitive::tdc6
int tdc6
Definition: constants.h:142
MuonPathAssociator::printmPC
void printmPC(cmsdt::metaPrimitive mP)
Definition: MuonPathAssociator.cc:1007
MuonPathAssociator::shiftinfo_
std::map< int, float > shiftinfo_
Definition: MuonPathAssociator.h:89
cmsdt::metaPrimitive::tanPhi
double tanPhi
Definition: constants.h:121
cmsdt::CELL_HEIGHT
constexpr int CELL_HEIGHT
Definition: constants.h:177
fileinputsource_cfi.sec
sec
Definition: fileinputsource_cfi.py:87
cmsdt::metaPrimitive::tdc4
int tdc4
Definition: constants.h:136
DDAxes::phi
cmsdt::metaPrimitive::chi2
double chi2
Definition: constants.h:124
psi
std::map< std::string, int, std::less< std::string > > psi
Definition: CountProcessesAction.h:15
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
MuonPathAssociator::debug_
bool debug_
Definition: MuonPathAssociator.h:74
edm::Transition::BeginRun
Exception
Definition: hltDiff.cc:246
cmsdt::metaPrimitive::tdc2
int tdc2
Definition: constants.h:130
MuonPathAssociator::x_precision_
double x_precision_
Definition: MuonPathAssociator.h:85
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
MuonPathAssociator::useBX_correlation_
bool useBX_correlation_
Definition: MuonPathAssociator.h:76
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
cmsdt::metaPrimitive::lat3
int lat3
Definition: constants.h:134
DTLayerId::layer
int layer() const
Return the layer number.
Definition: DTLayerId.h:42
MuonPathAssociator::dtGeo_
const DTGeometry * dtGeo_
Definition: MuonPathAssociator.h:62
MuonPathAssociator::allow_confirmation_
bool allow_confirmation_
Definition: MuonPathAssociator.h:77
MuonPathAssociator::isNotAPrimo
bool isNotAPrimo(cmsdt::metaPrimitive first, cmsdt::metaPrimitive second)
Definition: MuonPathAssociator.cc:991
MuonGeometryRecord
Definition: MuonGeometryRecord.h:34
cmsdt::X_POS_L4
constexpr double X_POS_L4
Definition: constants.h:246
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
cmsdt::metaPrimitive::wi3
int wi3
Definition: constants.h:132
edm::FileInPath::fullPath
std::string fullPath() const
Definition: FileInPath.cc:163
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