CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
CSCMotherboardME11.cc
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 //
3 // Class: CSCMotherboardME11
4 //
5 // Description:
6 // Extended CSCMotherboard for ME11 to handle ME1a and ME1b separately
7 //
8 // Author List: Vadim Khotilovich 12 May 2009
9 //
10 //
11 //-----------------------------------------------------------------------------
12 
13 #include <L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11.h>
14 //#include <Utilities/Timing/interface/TimingReport.h>
15 #include <FWCore/MessageLogger/interface/MessageLogger.h>
16 #include <DataFormats/MuonDetId/interface/CSCTriggerNumbering.h>
17 
18 
19 
20 // LUT for which ME1/1 wire group can cross which ME1/a halfstrip
21 // 1st index: WG number
22 // 2nd index: inclusive HS range
23 const int CSCMotherboardME11::lut_wg_vs_hs_me1a[48][2] = {
24 {0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
25 {0, 95},{0, 95},{0, 95},{0, 95},{0, 95},
26 {0, 95},{0, 95},{0, 77},{0, 61},{0, 39},
27 {0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
28 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
29 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
30 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
31 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
32 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
33 {-1,-1},{-1,-1},{-1,-1} };
34 // a modified LUT for ganged ME1a
35 const int CSCMotherboardME11::lut_wg_vs_hs_me1ag[48][2] = {
36 {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
37 {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
38 {0, 31},{0, 31},{0, 31},{0, 31},{0, 31},
39 {0, 22},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
40 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
41 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
42 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
43 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
44 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
45 {-1,-1},{-1,-1},{-1,-1} };
46 
47 // LUT for which ME1/1 wire group can cross which ME1/b halfstrip
48 // 1st index: WG number
49 // 2nd index: inclusive HS range
50 const int CSCMotherboardME11::lut_wg_vs_hs_me1b[48][2] = {
51 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
52 {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
53 {100, 127},{73, 127},{47, 127},{22, 127},{0, 127},
54 {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
55 {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
56 {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
57 {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
58 {0, 127},{0, 127},{0, 127},{0, 127},{0, 127},
59 {0, 127},{0, 127},{0, 127},{0, 127},{0, 105},
60 {0, 93},{0, 78},{0, 63} };
61 
62 
63 CSCMotherboardME11::CSCMotherboardME11(unsigned endcap, unsigned station,
64  unsigned sector, unsigned subsector,
65  unsigned chamber,
66  const edm::ParameterSet& conf) :
67  CSCMotherboard(endcap, station, sector, subsector, chamber, conf)
68 {
69  edm::ParameterSet commonParams = conf.getParameter<edm::ParameterSet>("commonParam");
70 
71  // special configuration parameters for ME11 treatment
72  smartME1aME1b = commonParams.getUntrackedParameter<bool>("smartME1aME1b", true);
73  disableME1a = commonParams.getUntrackedParameter<bool>("disableME1a", false);
74  gangedME1a = commonParams.getUntrackedParameter<bool>("gangedME1a", false);
75 
76  if (!isSLHC) edm::LogError("L1CSCTPEmulatorConfigError")
77  << "+++ Upgrade CSCMotherboardME11 constructed while isSLHC is not set! +++\n";
78  if (!smartME1aME1b) edm::LogError("L1CSCTPEmulatorConfigError")
79  << "+++ Upgrade CSCMotherboardME11 constructed while smartME1aME1b is not set! +++\n";
80 
81  edm::ParameterSet alctParams = conf.getParameter<edm::ParameterSet>("alctSLHC");
82  edm::ParameterSet clctParams = conf.getParameter<edm::ParameterSet>("clctSLHC");
83  edm::ParameterSet tmbParams = conf.getParameter<edm::ParameterSet>("tmbSLHC");
84 
85  clct1a = new CSCCathodeLCTProcessor(endcap, station, sector, subsector, chamber, clctParams, commonParams, tmbParams);
86  clct1a->setRing(4);
87 
88  match_earliest_alct_me11_only = tmbParams.getUntrackedParameter<bool>("matchEarliestAlctME11Only",true);
89  match_earliest_clct_me11_only = tmbParams.getUntrackedParameter<bool>("matchEarliestClctME11Only",true);
90 
91  // if true: use regular CLCT-to-ALCT matching in TMB
92  // if false: do ALCT-to-CLCT matching
93  clct_to_alct = tmbParams.getUntrackedParameter<bool>("clctToAlct",true);
94 
95  // whether to not reuse CLCTs that were used by previous matching ALCTs
96  // in ALCT-to-CLCT algorithm
97  drop_used_clcts = tmbParams.getUntrackedParameter<bool>("tmbDropUsedClcts",true);
98 
99  tmb_cross_bx_algo = tmbParams.getUntrackedParameter<unsigned int>("tmbCrossBxAlgorithm");
100 
101  // maximum lcts per BX in ME11: 2, 3, 4 or 999
102  max_me11_lcts = tmbParams.getUntrackedParameter<unsigned int>("maxME11LCTs",4);
103 
104  pref[0] = match_trig_window_size/2;
105  for (unsigned int m=2; m<match_trig_window_size; m+=2)
106  {
107  pref[m-1] = pref[0] - m/2;
108  pref[m] = pref[0] + m/2;
109  }
110 }
111 
112 
113 CSCMotherboardME11::CSCMotherboardME11() : CSCMotherboard()
114 {
115  // Constructor used only for testing.
116 
117  clct1a = new CSCCathodeLCTProcessor();
118  clct1a->setRing(4);
119 
120  pref[0] = match_trig_window_size/2;
121  for (unsigned int m=2; m<match_trig_window_size; m+=2)
122  {
123  pref[m-1] = pref[0] - m/2;
124  pref[m] = pref[0] + m/2;
125  }
126 }
127 
128 
129 CSCMotherboardME11::~CSCMotherboardME11()
130 {
131  if (clct1a) delete clct1a;
132 }
133 
134 
135 void CSCMotherboardME11::clear()
136 {
137  CSCMotherboard::clear();
138  if (clct1a) clct1a->clear();
139  for (int bx = 0; bx < MAX_LCT_BINS; bx++)
140  {
141  //firstLCT1a[bx].clear();
142  //secondLCT1a[bx].clear();
143  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
144  for (int i=0;i<2;i++)
145  {
146  allLCTs1b[bx][mbx][i].clear();
147  allLCTs1a[bx][mbx][i].clear();
148  }
149  }
150 }
151 
152 // Set configuration parameters obtained via EventSetup mechanism.
153 void CSCMotherboardME11::setConfigParameters(const CSCDBL1TPParameters* conf)
154 {
155  alct->setConfigParameters(conf);
156  clct->setConfigParameters(conf);
157  clct1a->setConfigParameters(conf);
158  // No config. parameters in DB for the TMB itself yet.
159 }
160 
161 
162 void CSCMotherboardME11::run(const CSCWireDigiCollection* wiredc,
163  const CSCComparatorDigiCollection* compdc)
164 {
165  clear();
166 
167  if (!( alct && clct && clct1a && smartME1aME1b))
168  {
169  if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError")
170  << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
171  return;
172  }
173 
174  alctV = alct->run(wiredc); // run anodeLCT
175  clctV1b = clct->run(compdc); // run cathodeLCT in ME1/b
176  clctV1a = clct1a->run(compdc); // run cathodeLCT in ME1/a
177 
178  //int n_clct_a=0, n_clct_b=0;
179  //if (clct1a->bestCLCT[6].isValid() && clct1a->bestCLCT[6].getBX()==6) n_clct_a++;
180  //if (clct1a->secondCLCT[6].isValid() && clct1a->secondCLCT[6].getBX()==6) n_clct_a++;
181 
182  int used_alct_mask[20], used_alct_mask_1a[20];
183  int used_clct_mask[20], used_clct_mask_1a[20];
184  for (int b=0;b<20;b++)
185  used_alct_mask[b] = used_alct_mask_1a[b] = used_clct_mask[b] = used_clct_mask_1a[b] = 0;
186 
187  // CLCT-centric CLCT-to-ALCT matching
188  if (clct_to_alct) for (int bx_clct = 0; bx_clct < CSCCathodeLCTProcessor::MAX_CLCT_BINS; bx_clct++)
189  {
190  // matching in ME1b
191  if (clct->bestCLCT[bx_clct].isValid())
192  {
193  int bx_alct_start = bx_clct - match_trig_window_size/2;
194  int bx_alct_stop = bx_clct + match_trig_window_size/2;
195  for (int bx_alct = bx_alct_start; bx_alct <= bx_alct_stop; bx_alct++)
196  {
197  if (bx_alct < 0 || bx_alct >= CSCAnodeLCTProcessor::MAX_ALCT_BINS) continue;
198  if (drop_used_alcts && used_alct_mask[bx_alct]) continue;
199  if (alct->bestALCT[bx_alct].isValid())
200  {
201  if (infoV > 1) LogTrace("CSCMotherboard")
202  << "Successful CLCT-ALCT match in ME1b: bx_clct = " << bx_clct
203  << "; match window: [" << bx_alct_start << "; " << bx_alct_stop
204  << "]; bx_alct = " << bx_alct;
205  int mbx = bx_alct_stop - bx_alct;
206  correlateLCTs(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
207  clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
208  allLCTs1b[bx_alct][mbx][0], allLCTs1b[bx_alct][mbx][1], ME1B);
209  if (allLCTs1b[bx_alct][mbx][0].isValid())
210  {
211  used_alct_mask[bx_alct] += 1;
212  if (match_earliest_alct_me11_only) break;
213  }
214  }
215  }
216  // Do not report CLCT-only LCT for ME1b
217  }
218  // matching in ME1a
219  if (clct1a->bestCLCT[bx_clct].isValid())
220  {
221  int bx_alct_start = bx_clct - match_trig_window_size/2;
222  int bx_alct_stop = bx_clct + match_trig_window_size/2;
223  for (int bx_alct = bx_alct_start; bx_alct <= bx_alct_stop; bx_alct++)
224  {
225  if (bx_alct < 0 || bx_alct >= CSCAnodeLCTProcessor::MAX_ALCT_BINS) continue;
226  if (drop_used_alcts && used_alct_mask_1a[bx_alct]) continue;
227  if (alct->bestALCT[bx_alct].isValid())
228  {
229  if (infoV > 1) LogTrace("CSCMotherboard")
230  << "Successful CLCT-ALCT match in ME1a: bx_clct = " << bx_clct
231  << "; match window: [" << bx_alct_start << "; " << bx_alct_stop
232  << "]; bx_alct = " << bx_alct;
233  int mbx = bx_alct_stop - bx_alct;
234  correlateLCTs(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
235  clct1a->bestCLCT[bx_clct], clct1a->secondCLCT[bx_clct],
236  allLCTs1a[bx_alct][mbx][0], allLCTs1a[bx_alct][mbx][1], ME1A);
237  if (allLCTs1a[bx_alct][mbx][0].isValid())
238  {
239  used_alct_mask_1a[bx_alct] += 1;
240  if (match_earliest_alct_me11_only) break;
241  }
242  }
243  }
244  // Do not report CLCT-only LCT for ME1b
245  }
246  // Do not attempt to make ALCT-only LCT for ME1b
247  } // end of CLCT-centric matching
248 
249  // ALCT-centric ALCT-to-CLCT matching
250  else for (int bx_alct = 0; bx_alct < CSCAnodeLCTProcessor::MAX_ALCT_BINS; bx_alct++)
251  {
252  if (alct->bestALCT[bx_alct].isValid())
253  {
254  int bx_clct_start = bx_alct - match_trig_window_size/2;
255  int bx_clct_stop = bx_alct + match_trig_window_size/2;
256 
257  // matching in ME1b
258  for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
259  {
260  if (bx_clct < 0 || bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
261  if (drop_used_clcts && used_clct_mask[bx_clct]) continue;
262  if (clct->bestCLCT[bx_clct].isValid())
263  {
264  if (infoV > 1) LogTrace("CSCMotherboard")
265  << "Successful ALCT-CLCT match in ME1b: bx_alct = " << bx_alct
266  << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
267  << "]; bx_clct = " << bx_clct;
268  int mbx = bx_clct-bx_clct_start;
269  correlateLCTs(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
270  clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct],
271  allLCTs1b[bx_alct][mbx][0], allLCTs1b[bx_alct][mbx][1], ME1B);
272  if (allLCTs1b[bx_alct][mbx][0].isValid())
273  {
274  used_clct_mask[bx_clct] += 1;
275  if (match_earliest_clct_me11_only) break;
276  }
277  }
278  }
279 
280  // matching in ME1a
281  for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++)
282  {
283  if (bx_clct < 0 || bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue;
284  if (drop_used_clcts && used_clct_mask_1a[bx_clct]) continue;
285  if (clct1a->bestCLCT[bx_clct].isValid())
286  {
287  if (infoV > 1) LogTrace("CSCMotherboard")
288  << "Successful ALCT-CLCT match in ME1a: bx_alct = " << bx_alct
289  << "; match window: [" << bx_clct_start << "; " << bx_clct_stop
290  << "]; bx_clct = " << bx_clct;
291  int mbx = bx_clct-bx_clct_start;
292  correlateLCTs(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct],
293  clct1a->bestCLCT[bx_clct], clct1a->secondCLCT[bx_clct],
294  allLCTs1a[bx_alct][mbx][0], allLCTs1a[bx_alct][mbx][1], ME1A);
295  if (allLCTs1a[bx_alct][mbx][0].isValid())
296  {
297  used_clct_mask_1a[bx_clct] += 1;
298  if (match_earliest_clct_me11_only) break;
299  }
300  }
301  }
302  }
303  } // end of ALCT-centric matching
304 
305  // reduction of nLCTs per each BX
306  for (int bx = 0; bx < MAX_LCT_BINS; bx++)
307  {
308  // counting
309  unsigned int n1a=0, n1b=0;
310  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
311  for (int i=0;i<2;i++)
312  {
313  int cbx = bx + mbx - match_trig_window_size/2;
314  if (allLCTs1b[bx][mbx][i].isValid())
315  {
316  n1b++;
317  if (infoV > 0) LogDebug("CSCMotherboard") << "1b LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1b[bx][mbx][i];
318  }
319  if (allLCTs1a[bx][mbx][i].isValid())
320  {
321  n1a++;
322  if (infoV > 0) LogDebug("CSCMotherboard") << "1a LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1a[bx][mbx][i];
323  }
324  }
325  if (infoV > 0 && n1a+n1b>0) LogDebug("CSCMotherboard") <<"bx "<<bx<<" nLCT:"<<n1a<<" "<<n1b<<" "<<n1a+n1b;
326 
327  // some simple cross-bx sorting algorithms
328  if (tmb_cross_bx_algo == 1 && (n1a>2 || n1b>2) )
329  {
330  n1a=0, n1b=0;
331  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
332  for (int i=0;i<2;i++)
333  {
334  if (allLCTs1b[bx][pref[mbx]][i].isValid())
335  {
336  n1b++;
337  if (n1b>2) allLCTs1b[bx][pref[mbx]][i].clear();
338  }
339  if (allLCTs1a[bx][pref[mbx]][i].isValid())
340  {
341  n1a++;
342  if (n1a>2) allLCTs1a[bx][pref[mbx]][i].clear();
343  }
344  }
345 
346  if (infoV > 0) LogDebug("CSCMotherboard") <<"After x-bx sorting:";
347  n1a=0, n1b=0;
348  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
349  for (int i=0;i<2;i++)
350  {
351  int cbx = bx + mbx - match_trig_window_size/2;
352  if (allLCTs1b[bx][mbx][i].isValid())
353  {
354  n1b++;
355  if (infoV > 0) LogDebug("CSCMotherboard") << "1b LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1b[bx][mbx][i];
356  }
357  if (allLCTs1a[bx][mbx][i].isValid())
358  {
359  n1a++;
360  if (infoV > 0) LogDebug("CSCMotherboard") << "1a LCT"<<i+1<<" "<<bx<<"/"<<cbx<<": "<<allLCTs1a[bx][mbx][i];
361  }
362  }
363  if (infoV > 0 && n1a+n1b>0) LogDebug("CSCMotherboard") <<"bx "<<bx<<" nnLCT:"<<n1a<<" "<<n1b<<" "<<n1a+n1b;
364  } // x-bx sorting
365 
366  // Maximum 2 or 3 per whole ME11 per BX case:
367  // (supposedly, now we should have max 2 per bx in each 1a and 1b)
368  if ( n1a+n1b > max_me11_lcts )
369  {
370  // do it simple so far: take all low eta 1/b stubs
371  unsigned int nLCT=n1b;
372  n1a=0;
373  // right now nLCT<=2; cut 1a if necessary
374  for (unsigned int mbx=0; mbx<match_trig_window_size; mbx++)
375  for (int i=0;i<2;i++)
376  if (allLCTs1a[bx][mbx][i].isValid()) {
377  nLCT++;
378  if (nLCT>max_me11_lcts) allLCTs1a[bx][mbx][i].clear();
379  else n1a++;
380  }
381  if (infoV > 0 && nLCT>0) LogDebug("CSCMotherboard") <<"bx "<<bx<<" nnnLCT:"<<n1a<<" "<<n1b<<" "<<n1a+n1b;
382  }
383  }// reduction per bx
384 
385  //if (infoV > 1) LogTrace("CSCMotherboardME11")<<"clct_count E:"<<theEndcap<<"S:"<<theStation<<"R:"<<1<<"C:"
386  // <<CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber)
387  // <<" a "<<n_clct_a<<" b "<<n_clct_b<<" ab "<<n_clct_a+n_clct_b;
388 }
389 
390 
391 std::vector<CSCCorrelatedLCTDigi> CSCMotherboardME11::readoutLCTs1a()
392 {
393  return readoutLCTs(ME1A);
394 }
395 
396 
397 std::vector<CSCCorrelatedLCTDigi> CSCMotherboardME11::readoutLCTs1b()
398 {
399  return readoutLCTs(ME1B);
400 }
401 
402 
403 // Returns vector of read-out correlated LCTs, if any. Starts with
404 // the vector of all found LCTs and selects the ones in the read-out
405 // time window.
406 std::vector<CSCCorrelatedLCTDigi> CSCMotherboardME11::readoutLCTs(int me1ab)
407 {
408  std::vector<CSCCorrelatedLCTDigi> tmpV;
409 
410  // The start time of the L1A*LCT coincidence window should be related
411  // to the fifo_pretrig parameter, but I am not completely sure how.
412  // Just choose it such that the window is centered at bx=7. This may
413  // need further tweaking if the value of tmb_l1a_window_size changes.
414  //static int early_tbins = 4;
415  // The number of LCT bins in the read-out is given by the
416  // tmb_l1a_window_size parameter, forced to be odd
417  static int lct_bins =
418  (tmb_l1a_window_size % 2 == 0) ? tmb_l1a_window_size + 1 : tmb_l1a_window_size;
419  static int late_tbins = early_tbins + lct_bins;
420 
421 
422  // Start from the vector of all found correlated LCTs and select
423  // those within the LCT*L1A coincidence window.
424  int bx_readout = -1;
425  std::vector<CSCCorrelatedLCTDigi> all_lcts;
426  if (me1ab == ME1A) all_lcts = getLCTs1a();
427  if (me1ab == ME1B) all_lcts = getLCTs1b();
428  std::vector <CSCCorrelatedLCTDigi>::const_iterator plct = all_lcts.begin();
429  for (; plct != all_lcts.end(); plct++)
430  {
431  if (!plct->isValid()) continue;
432 
433  int bx = (*plct).getBX();
434  // Skip LCTs found too early relative to L1Accept.
435  if (bx <= early_tbins) continue;
436 
437  // Skip LCTs found too late relative to L1Accept.
438  if (bx > late_tbins) continue;
439 
440  // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
441  // in digi->raw step, LCTs have to be packed into the TMB header, and
442  // currently there is room just for two.
443  if (readout_earliest_2 && (bx_readout == -1 || bx == bx_readout) )
444  {
445  tmpV.push_back(*plct);
446  if (bx_readout == -1) bx_readout = bx;
447  }
448  else tmpV.push_back(*plct);
449  }
450  return tmpV;
451 }
452 
453 
454 // Returns vector of found correlated LCTs, if any.
455 std::vector<CSCCorrelatedLCTDigi> CSCMotherboardME11::getLCTs1b()
456 {
457  std::vector<CSCCorrelatedLCTDigi> tmpV;
458 
459  for (int bx = 0; bx < MAX_LCT_BINS; bx++)
460  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
461  for (int i=0;i<2;i++)
462  if (allLCTs1b[bx][mbx][i].isValid()) tmpV.push_back(allLCTs1b[bx][mbx][i]);
463  return tmpV;
464 }
465 
466 // Returns vector of found correlated LCTs, if any.
467 std::vector<CSCCorrelatedLCTDigi> CSCMotherboardME11::getLCTs1a()
468 {
469  std::vector<CSCCorrelatedLCTDigi> tmpV;
470 
471  // disabled ME1a
472  if (mpc_block_me1a || disableME1a) return tmpV;
473 
474  // Report all LCTs found.
475  for (int bx = 0; bx < MAX_LCT_BINS; bx++)
476  for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++)
477  for (int i=0;i<2;i++)
478  if (allLCTs1a[bx][mbx][i].isValid()) tmpV.push_back(allLCTs1a[bx][mbx][i]);
479  return tmpV;
480 }
481 
482 
483 bool CSCMotherboardME11::doesALCTCrossCLCT(CSCALCTDigi &a, CSCCLCTDigi &c, int me)
484 {
485  if ( !c.isValid() || !a.isValid() ) return false;
486  int key_hs = c.getKeyStrip();
487  int key_wg = a.getKeyWG();
488  if ( me == ME1A )
489  {
490  if ( !gangedME1a )
491  {
492  // wrap around ME11 HS number for -z endcap
493  if (theEndcap==2) key_hs = 95 - key_hs;
494  if ( key_hs >= lut_wg_vs_hs_me1a[key_wg][0] &&
495  key_hs <= lut_wg_vs_hs_me1a[key_wg][1] ) return true;
496  return false;
497  }
498  else
499  {
500  if (theEndcap==2) key_hs = 31 - key_hs;
501  if ( key_hs >= lut_wg_vs_hs_me1ag[key_wg][0] &&
502  key_hs <= lut_wg_vs_hs_me1ag[key_wg][1] ) return true;
503  return false;
504  }
505  }
506  if ( me == ME1B)
507  {
508  if (theEndcap==2) key_hs = 127 - key_hs;
509  if ( key_hs >= lut_wg_vs_hs_me1b[key_wg][0] &&
510  key_hs <= lut_wg_vs_hs_me1b[key_wg][1] ) return true;
511  }
512  return false;
513 }
514 
515 
516 void CSCMotherboardME11::correlateLCTs(CSCALCTDigi bestALCT,
517  CSCALCTDigi secondALCT,
518  CSCCLCTDigi bestCLCT,
519  CSCCLCTDigi secondCLCT,
520  CSCCorrelatedLCTDigi& lct1,
521  CSCCorrelatedLCTDigi& lct2)
522 {
523  bool anodeBestValid = bestALCT.isValid();
524  bool anodeSecondValid = secondALCT.isValid();
525  bool cathodeBestValid = bestCLCT.isValid();
526  bool cathodeSecondValid = secondCLCT.isValid();
527 
528  if (anodeBestValid && !anodeSecondValid) secondALCT = bestALCT;
529  if (!anodeBestValid && anodeSecondValid) bestALCT = secondALCT;
530  if (cathodeBestValid && !cathodeSecondValid) secondCLCT = bestCLCT;
531  if (!cathodeBestValid && cathodeSecondValid) bestCLCT = secondCLCT;
532 
533  // ALCT-CLCT matching conditions are defined by "trig_enable" configuration
534  // parameters.
535  if ((alct_trig_enable && bestALCT.isValid()) ||
536  (clct_trig_enable && bestCLCT.isValid()) ||
537  (match_trig_enable && bestALCT.isValid() && bestCLCT.isValid()))
538  {
539  lct1 = constructLCTs(bestALCT, bestCLCT);
540  lct1.setTrknmb(1);
541  }
542 
543  if (((secondALCT != bestALCT) || (secondCLCT != bestCLCT)) &&
544  ((alct_trig_enable && secondALCT.isValid()) ||
545  (clct_trig_enable && secondCLCT.isValid()) ||
546  (match_trig_enable && secondALCT.isValid() && secondCLCT.isValid())))
547  {
548  lct2 = constructLCTs(secondALCT, secondCLCT);
549  lct2.setTrknmb(2);
550  }
551 }
552 
553 
554 void CSCMotherboardME11::correlateLCTs(CSCALCTDigi bestALCT,
555  CSCALCTDigi secondALCT,
556  CSCCLCTDigi bestCLCT,
557  CSCCLCTDigi secondCLCT,
558  CSCCorrelatedLCTDigi& lct1,
559  CSCCorrelatedLCTDigi& lct2,
560  int me)
561 {
562  // assume that always anodeBestValid && cathodeBestValid
563 
564  if (secondALCT == bestALCT) secondALCT.clear();
565  if (secondCLCT == bestCLCT) secondCLCT.clear();
566 
567  int ok11 = doesALCTCrossCLCT( bestALCT, bestCLCT, me);
568  int ok12 = doesALCTCrossCLCT( bestALCT, secondCLCT, me);
569  int ok21 = doesALCTCrossCLCT( secondALCT, bestCLCT, me);
570  int ok22 = doesALCTCrossCLCT( secondALCT, secondCLCT, me);
571  int code = (ok11<<3) | (ok12<<2) | (ok21<<1) | (ok22);
572 
573  int dbg=0;
574  int ring = me;
575  int chamb= CSCTriggerNumbering::chamberFromTriggerLabels(theSector,theSubsector, theStation, theTrigChamber);
576  CSCDetId did(theEndcap, theStation, ring, chamb, 0);
577  if (dbg) LogTrace("CSCMotherboardME11")<<"debug correlateLCTs in "<<did<<std::endl
578  <<"ALCT1: "<<bestALCT<<std::endl
579  <<"ALCT2: "<<secondALCT<<std::endl
580  <<"CLCT1: "<<bestCLCT<<std::endl
581  <<"CLCT2: "<<secondCLCT<<std::endl
582  <<"ok 11 12 21 22 code = "<<ok11<<" "<<ok12<<" "<<ok21<<" "<<ok22<<" "<<code<<std::endl;
583 
584  if ( code==0 ) return;
585 
586  // LUT defines correspondence between possible ok## combinations
587  // and resulting lct1 and lct2
588  int lut[16][2] = {
589  //ok: 11 12 21 22
590  {0 ,0 }, // 0 0 0 0
591  {22,0 }, // 0 0 0 1
592  {21,0 }, // 0 0 1 0
593  {21,22}, // 0 0 1 1
594  {12,0 }, // 0 1 0 0
595  {12,22}, // 0 1 0 1
596  {12,21}, // 0 1 1 0
597  {12,21}, // 0 1 1 1
598  {11,0 }, // 1 0 0 0
599  {11,22}, // 1 0 0 1
600  {11,21}, // 1 0 1 0
601  {11,22}, // 1 0 1 1
602  {11,12}, // 1 1 0 0
603  {11,22}, // 1 1 0 1
604  {11,12}, // 1 1 1 0
605  {11,22}, // 1 1 1 1
606  };
607 
608  if (dbg) LogTrace("CSCMotherboardME11")<<"lut 0 1 = "<<lut[code][0]<<" "<<lut[code][1]<<std::endl;
609 
610  switch (lut[code][0]) {
611  case 11:
612  lct1 = constructLCTs(bestALCT, bestCLCT);
613  break;
614  case 12:
615  lct1 = constructLCTs(bestALCT, secondCLCT);
616  break;
617  case 21:
618  lct1 = constructLCTs(secondALCT, bestCLCT);
619  break;
620  case 22:
621  lct1 = constructLCTs(secondALCT, secondCLCT);
622  break;
623  default: return;
624  }
625  lct1.setTrknmb(1);
626 
627  if (dbg) LogTrace("CSCMotherboardME11")<<"lct1: "<<lct1<<std::endl;
628 
629  switch (lut[code][1])
630  {
631  case 12:
632  lct2 = constructLCTs(bestALCT, secondCLCT);
633  lct2.setTrknmb(2);
634  if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
635  return;
636  case 21:
637  lct2 = constructLCTs(secondALCT, bestCLCT);
638  lct2.setTrknmb(2);
639  if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
640  return;
641  case 22:
642  lct2 = constructLCTs(secondALCT, secondCLCT);
643  lct2.setTrknmb(2);
644  if (dbg) LogTrace("CSCMotherboardME11")<<"lct2: "<<lct2<<std::endl;
645  return;
646  default: return;
647  }
648  if (dbg) LogTrace("CSCMotherboardME11")<<"out of correlateLCTs"<<std::endl;
649 
650  return;
651 }
652 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
CSCCathodeLCTProcessor::secondCLCT
CSCCLCTDigi secondCLCT[MAX_CLCT_BINS]
Definition: CSCCathodeLCTProcessor.h:75
CSCMotherboard::theSector
const unsigned theSector
Definition: CSCMotherboard.h:93
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
CSCMotherboardME11::clctV1a
std::vector< CSCCLCTDigi > clctV1a
Definition: CSCMotherboardME11.h:98
i
int i
Definition: DBlmapReader.cc:9
CSCMotherboard::constructLCTs
CSCCorrelatedLCTDigi constructLCTs(const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT)
Definition: CSCMotherboard.cc:571
CSCMotherboardME11::allLCTs1b
CSCCorrelatedLCTDigi allLCTs1b[MAX_LCT_BINS][15][2]
Definition: CSCMotherboardME11.h:85
CSCMotherboardME11::run
void run(const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc)
Definition: CSCMotherboardME11.cc:162
CSCMotherboard::clct_trig_enable
unsigned int clct_trig_enable
Definition: CSCMotherboard.h:108
CSCMotherboardME11::setConfigParameters
void setConfigParameters(const CSCDBL1TPParameters *conf)
Definition: CSCMotherboardME11.cc:153
CSCMotherboard::readoutLCTs
std::vector< CSCCorrelatedLCTDigi > readoutLCTs()
Definition: CSCMotherboard.cc:421
CSCAnodeLCTProcessor::bestALCT
CSCALCTDigi bestALCT[MAX_ALCT_BINS]
Definition: CSCAnodeLCTProcessor.h:64
CSCMotherboard::match_trig_window_size
unsigned int match_trig_window_size
Definition: CSCMotherboard.h:109
Reference_intrackfit_cff.endcap
endcap
Definition: Reference_intrackfit_cff.py:82
CSCAnodeLCTProcessor::secondALCT
CSCALCTDigi secondALCT[MAX_ALCT_BINS]
Definition: CSCAnodeLCTProcessor.h:67
CSCMotherboard::theTrigChamber
const unsigned theTrigChamber
Definition: CSCMotherboard.h:95
CSCALCTDigi::isValid
bool isValid() const
check ALCT validity (1 - valid ALCT)
Definition: CSCALCTDigi.h:30
CSCMotherboardME11::pref
int pref[MAX_LCT_BINS]
Definition: CSCMotherboardME11.h:101
CSCMotherboardME11::max_me11_lcts
unsigned int max_me11_lcts
Definition: CSCMotherboardME11.h:117
CSCMotherboard::theEndcap
const unsigned theEndcap
Definition: CSCMotherboard.h:91
CSCALCTDigi::clear
void clear()
clear this ALCT
Definition: CSCALCTDigi.cc:35
CSCMotherboardME11::lut_wg_vs_hs_me1a
static const int lut_wg_vs_hs_me1a[48][2]
Definition: CSCMotherboardME11.h:69
CSCMotherboardME11::getLCTs1b
std::vector< CSCCorrelatedLCTDigi > getLCTs1b()
Definition: CSCMotherboardME11.cc:455
CSCCathodeLCTProcessor::bestCLCT
CSCCLCTDigi bestCLCT[MAX_CLCT_BINS]
Definition: CSCCathodeLCTProcessor.h:72
CSCAnodeLCTProcessor::setConfigParameters
void setConfigParameters(const CSCDBL1TPParameters *conf)
Definition: CSCAnodeLCTProcessor.cc:345
CSCMotherboardME11::correlateLCTs
void correlateLCTs(CSCALCTDigi bestALCT, CSCALCTDigi secondALCT, CSCCLCTDigi bestCLCT, CSCCLCTDigi secondCLCT, CSCCorrelatedLCTDigi &lct1, CSCCorrelatedLCTDigi &lct2)
Definition: CSCMotherboardME11.cc:516
CSCMotherboard::mpc_block_me1a
unsigned int mpc_block_me1a
Definition: CSCMotherboard.h:107
CSCMotherboardME11::tmb_cross_bx_algo
unsigned int tmb_cross_bx_algo
Definition: CSCMotherboardME11.h:114
CSCMotherboardME11::allLCTs1a
CSCCorrelatedLCTDigi allLCTs1a[MAX_LCT_BINS][15][2]
Definition: CSCMotherboardME11.h:86
CSCMotherboard::theStation
const unsigned theStation
Definition: CSCMotherboard.h:92
CSCMotherboardME11::alctV
std::vector< CSCALCTDigi > alctV
Definition: CSCMotherboardME11.h:96
CSCMotherboard::theSubsector
const unsigned theSubsector
Definition: CSCMotherboard.h:94
CSCMotherboard::tmb_l1a_window_size
unsigned int tmb_l1a_window_size
Definition: CSCMotherboard.h:109
CSCCLCTDigi::isValid
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:30
CSCMotherboard::match_trig_enable
unsigned int match_trig_enable
Definition: CSCMotherboard.h:108
lumiPlot.lut
tuple lut
Definition: lumiPlot.py:244
CSCMotherboardME11::lut_wg_vs_hs_me1b
static const int lut_wg_vs_hs_me1b[48][2]
Definition: CSCMotherboardME11.h:68
CSCMotherboardME11::lut_wg_vs_hs_me1ag
static const int lut_wg_vs_hs_me1ag[48][2]
Definition: CSCMotherboardME11.h:70
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
CSCMotherboard::alct
CSCAnodeLCTProcessor * alct
Definition: CSCMotherboard.h:78
dbtoconf.conf
tuple conf
Definition: dbtoconf.py:185
b
double b
Definition: hdecay.h:120
CSCMotherboard::alct_trig_enable
unsigned int alct_trig_enable
Definition: CSCMotherboard.h:108
CSCMotherboardME11::getLCTs1a
std::vector< CSCCorrelatedLCTDigi > getLCTs1a()
Definition: CSCMotherboardME11.cc:467
CSCMotherboard::clct
CSCCathodeLCTProcessor * clct
Definition: CSCMotherboard.h:81
CSCCathodeLCTProcessor::run
std::vector< CSCCLCTDigi > run(const CSCComparatorDigiCollection *compdc)
Definition: CSCCathodeLCTProcessor.cc:548
CSCMotherboardME11::clctV1b
std::vector< CSCCLCTDigi > clctV1b
Definition: CSCMotherboardME11.h:97
a
double a
Definition: hdecay.h:121
CSCMotherboardME11::doesALCTCrossCLCT
bool doesALCTCrossCLCT(CSCALCTDigi &a, CSCCLCTDigi &c, int me)
Definition: CSCMotherboardME11.cc:483
CSCMotherboardME11::readoutLCTs1b
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1b()
Definition: CSCMotherboardME11.cc:397
CSCCLCTDigi::clear
void clear()
clear this CLCT
Definition: CSCCLCTDigi.cc:58
CSCMotherboardME11::clct1a
CSCCathodeLCTProcessor * clct1a
Definition: CSCMotherboardME11.h:57
CSCCLCTDigi::getKeyStrip
int getKeyStrip() const
Definition: CSCCLCTDigi.h:65
CSCAnodeLCTProcessor::run
std::vector< CSCALCTDigi > run(const CSCWireDigiCollection *wiredc)
Definition: CSCAnodeLCTProcessor.cc:485
CSCCorrelatedLCTDigi::setTrknmb
void setTrknmb(const uint16_t number)
Set track number (1,2) after sorting LCTs.
Definition: CSCCorrelatedLCTDigi.h:68
CSCALCTDigi::getKeyWG
int getKeyWG() const
return key wire group
Definition: CSCALCTDigi.h:45
CSCTriggerNumbering::chamberFromTriggerLabels
static int chamberFromTriggerLabels(int TriggerSector, int TriggerSubSector, int station, int TriggerCSCID)
Definition: CSCTriggerNumbering.cc:33
CSCCathodeLCTProcessor::setConfigParameters
void setConfigParameters(const CSCDBL1TPParameters *conf)
Definition: CSCCathodeLCTProcessor.cc:421
CSCMotherboardME11::readoutLCTs1a
std::vector< CSCCorrelatedLCTDigi > readoutLCTs1a()
Definition: CSCMotherboardME11.cc:391
Generated for CMSSW Reference Manual by doxygen 1.8.5