CMS 3D CMS Logo
Stage2Layer2ClusterAlgorithmFirmwareImp1.cc
Go to the documentation of this file.
1 
8 #include "FWCore/MessageLogger/interface/MessageLogger.h"
9 #include "L1Trigger/L1TCalorimeter/interface/Stage2Layer2ClusterAlgorithmFirmware.h"
10 //#include "DataFormats/Math/interface/LorentzVector.h "
11 
12 #include "L1Trigger/L1TCalorimeter/interface/CaloTools.h"
13 #include "L1Trigger/L1TCalorimeter/interface/CaloStage2Nav.h"
14 
15 #include "L1Trigger/L1TCalorimeter/interface/CaloParamsHelper.h"
16 
17 /*****************************************************************/
18 l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::Stage2Layer2ClusterAlgorithmFirmwareImp1(CaloParamsHelper const* params, ClusterInput clusterInput) :
19  clusterInput_(clusterInput),
20  seedThreshold_(1),
21  clusterThreshold_(1),
22  hcalThreshold_(1),
23  params_(params)
24 /*****************************************************************/
25 {
26 
27 }
28 
29 
30 /*****************************************************************/
31 l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::~Stage2Layer2ClusterAlgorithmFirmwareImp1()
32 /*****************************************************************/
33 {
34 }
35 
36 
37 /*****************************************************************/
38 void l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::processEvent(const std::vector<l1t::CaloTower>& towers, std::vector<l1t::CaloCluster>& clusters)
39 /*****************************************************************/
40 {
41  if (clusterInput_==E)
42  {
43  seedThreshold_ = floor(params_->egSeedThreshold()/params_->towerLsbE());
44  clusterThreshold_ = floor(params_->egNeighbourThreshold()/params_->towerLsbE());
45  }
46  else if (clusterInput_==EH)
47  {
48  seedThreshold_ = floor(params_->egSeedThreshold()/params_->towerLsbSum());
49  clusterThreshold_ = floor(params_->egNeighbourThreshold()/params_->towerLsbSum());
50  }
51  if (clusterInput_==H)
52  {
53  seedThreshold_ = floor(params_->egSeedThreshold()/params_->towerLsbH());
54  clusterThreshold_ = floor(params_->egNeighbourThreshold()/params_->towerLsbH());
55  }
56 
57  hcalThreshold_ = floor(params_->egHcalThreshold()/params_->towerLsbH());
58 
59  clustering(towers, clusters);
60  filtering (towers, clusters);
61  //No sharing in new implementation
62  //sharing (towers, clusters);
63  refining (towers, clusters);
64 }
65 
66 /*****************************************************************/
67 void l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::clustering(const std::vector<l1t::CaloTower>& towers, std::vector<l1t::CaloCluster>& clusters)
68 /*****************************************************************/
69 {
70  // navigator
71  l1t::CaloStage2Nav caloNav;
72 
73  // Build clusters passing seed threshold
74  for(const auto& tower : towers)
75  {
76  int iEta = tower.hwEta();
77  int iPhi = tower.hwPhi();
78  int hwEt = 0;
79  if(clusterInput_==E) hwEt = tower.hwEtEm();
80  else if(clusterInput_==EH) hwEt = tower.hwPt();
81  else if(clusterInput_==H) hwEt = tower.hwEtHad();
82  int hwEtEm = tower.hwEtEm();
83  int hwEtHad = tower.hwEtHad();
84  // Check if the seed tower pass the seed threshold
85  if(hwEt>=seedThreshold_)
86  {
87  math::XYZTLorentzVector emptyP4;
88  clusters.push_back( l1t::CaloCluster(emptyP4, hwEt, iEta, iPhi) );
89  l1t::CaloCluster& cluster = clusters.back();
90  cluster.setHwPtEm(hwEtEm);
91  cluster.setHwPtHad(hwEtHad);
92  cluster.setHwSeedPt(hwEt);
93 
94  bool hOverE = idHoverE(tower);
95  cluster.setHOverE(hOverE);
96  // FG of the cluster is FG of the seed
97  bool fg = (tower.hwQual() & (0x1<<3));
98  cluster.setFgECAL((int)fg);
99  }
100  }
101 
102 
103  // check if neighbour towers are below clustering threshold
104  for(auto& cluster : clusters)
105  {
106  if( cluster.isValid() )
107  {
108  // look at the energies in neighbour towers
109  int iEta = cluster.hwEta();
110  int iPhi = cluster.hwPhi();
111  int iEtaP = caloNav.offsetIEta(iEta, 1);
112  int iEtaM = caloNav.offsetIEta(iEta, -1);
113  int iPhiP = caloNav.offsetIPhi(iPhi, 1);
114  int iPhiP2 = caloNav.offsetIPhi(iPhi, 2);
115  int iPhiM = caloNav.offsetIPhi(iPhi, -1);
116  int iPhiM2 = caloNav.offsetIPhi(iPhi, -2);
117  const l1t::CaloTower& towerNW = l1t::CaloTools::getTower(towers, iEtaM, iPhiM);
118  const l1t::CaloTower& towerN = l1t::CaloTools::getTower(towers, iEta , iPhiM);
119  const l1t::CaloTower& towerNE = l1t::CaloTools::getTower(towers, iEtaP, iPhiM);
120  const l1t::CaloTower& towerE = l1t::CaloTools::getTower(towers, iEtaP, iPhi );
121  const l1t::CaloTower& towerSE = l1t::CaloTools::getTower(towers, iEtaP, iPhiP);
122  const l1t::CaloTower& towerS = l1t::CaloTools::getTower(towers, iEta , iPhiP);
123  const l1t::CaloTower& towerSW = l1t::CaloTools::getTower(towers, iEtaM, iPhiP);
124  const l1t::CaloTower& towerW = l1t::CaloTools::getTower(towers, iEtaM, iPhi );
125  const l1t::CaloTower& towerNN = l1t::CaloTools::getTower(towers, iEta , iPhiM2);
126  const l1t::CaloTower& towerSS = l1t::CaloTools::getTower(towers, iEta , iPhiP2);
127  int towerEtNW = 0;
128  int towerEtN = 0;
129  int towerEtNE = 0;
130  int towerEtE = 0;
131  int towerEtSE = 0;
132  int towerEtS = 0;
133  int towerEtSW = 0;
134  int towerEtW = 0;
135  int towerEtNN = 0;
136  int towerEtSS = 0;
137  if(clusterInput_==E)
138  {
139  towerEtNW = towerNW.hwEtEm();
140  towerEtN = towerN .hwEtEm();
141  towerEtNE = towerNE.hwEtEm();
142  towerEtE = towerE .hwEtEm();
143  towerEtSE = towerSE.hwEtEm();
144  towerEtS = towerS .hwEtEm();
145  towerEtSW = towerSW.hwEtEm();
146  towerEtW = towerW .hwEtEm();
147  towerEtNN = towerNN.hwEtEm();
148  towerEtSS = towerSS.hwEtEm();
149  }
150  else if(clusterInput_==EH)
151  {
152  towerEtNW = towerNW.hwPt();
153  towerEtN = towerN .hwPt();
154  towerEtNE = towerNE.hwPt();
155  towerEtE = towerE .hwPt();
156  towerEtSE = towerSE.hwPt();
157  towerEtS = towerS .hwPt();
158  towerEtSW = towerSW.hwPt();
159  towerEtW = towerW .hwPt();
160  towerEtNN = towerNN.hwPt();
161  towerEtSS = towerSS.hwPt();
162  }
163  else if(clusterInput_==H)
164  {
165  towerEtNW = towerNW.hwEtHad();
166  towerEtN = towerN .hwEtHad();
167  towerEtNE = towerNE.hwEtHad();
168  towerEtE = towerE .hwEtHad();
169  towerEtSE = towerSE.hwEtHad();
170  towerEtS = towerS .hwEtHad();
171  towerEtSW = towerSW.hwEtHad();
172  towerEtW = towerW .hwEtHad();
173  towerEtNN = towerNN.hwEtHad();
174  towerEtSS = towerSS.hwEtHad();
175  }
176 
177  // check which towers can be clustered to the seed
178  if(towerEtNW < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_NW, false);
179  if(towerEtN < clusterThreshold_)
180  {
181  cluster.setClusterFlag(CaloCluster::INCLUDE_N , false);
182  cluster.setClusterFlag(CaloCluster::INCLUDE_NN, false);
183  }
184  if(towerEtNE < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_NE, false);
185  if(towerEtE < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_E , false);
186  if(towerEtSE < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_SE, false);
187  if(towerEtS < clusterThreshold_)
188  {
189  cluster.setClusterFlag(CaloCluster::INCLUDE_S , false);
190  cluster.setClusterFlag(CaloCluster::INCLUDE_SS, false);
191  }
192  if(towerEtSW < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_SW, false);
193  if(towerEtW < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_W , false);
194  if(towerEtNN < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_NN, false);
195  if(towerEtSS < clusterThreshold_) cluster.setClusterFlag(CaloCluster::INCLUDE_SS, false);
196 
197  }
198  }
199 
200 }
201 
202 
203 
204 /*****************************************************************/
205 void l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::filtering(const std::vector<l1t::CaloTower>& towers, std::vector<l1t::CaloCluster>& clusters)
206 /*****************************************************************/
207 {
208 
209 
210  // adapted from jet overlap filtering
211 
212  constexpr int mask[9][3] = {
213  { 2,2,2 },
214  { 2,2,2 },
215  { 2,2,2 },
216  { 1,2,2 },
217  { 1,0,2 },
218  { 1,1,2 },
219  { 1,1,1 },
220  { 1,1,1 },
221  { 1,1,1 },
222  };
223 
224  // navigator
225  l1t::CaloStage2Nav caloNav;
226 
227  // Filter: keep only local maxima in a 9x3 region
228  // If two neighbor seeds have the same energy, favor the most central one
229  for(auto& cluster : clusters)
230  {
231  // retrieve neighbour cluster candidates. At this stage they only contain the seed tower.
232  int iEta = cluster.hwEta();
233  int iPhi = cluster.hwPhi();
234  bool filter = false;
235  for( int deta = -1; deta < 2; ++deta )
236  {
237  for( int dphi = -4; dphi < 5; ++dphi )
238  {
239  int iEtaNeigh = caloNav.offsetIEta(iEta, deta);
240  int iPhiNeigh = caloNav.offsetIPhi(iPhi, dphi);
241  const l1t::CaloCluster& clusterNeigh = l1t::CaloTools::getCluster(clusters, iEtaNeigh, iPhiNeigh);
242 
243  if (mask[8-(dphi+4)][deta+1] == 0) continue;
244  else if (mask[8-(dphi+4)][deta+1] == 1) filter = (clusterNeigh.hwPt() > cluster.hwPt());
245  else if (mask[8-(dphi+4)][deta+1] == 2) filter = (clusterNeigh.hwPt() >= cluster.hwPt());
246  if(filter)
247  {
248  cluster.setClusterFlag(CaloCluster::INCLUDE_SEED, false);
249  break;
250  }
251  }
252  if(filter) break;
253  }
254  }
255 
256 }
257 
258 
259 
260 /*****************************************************************/
261 void l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::refining(const std::vector<l1t::CaloTower>& towers, std::vector<l1t::CaloCluster>& clusters)
262 /*****************************************************************/
263 {
264  // navigator
265  l1t::CaloStage2Nav caloNav;
266 
267  // trim cluster
268  for(auto& cluster : clusters)
269  {
270  if( cluster.isValid() )
271  {
272  int iEta = cluster.hwEta();
273  int iPhi = cluster.hwPhi();
274  int iEtaP = caloNav.offsetIEta(iEta, 1);
275  int iEtaM = caloNav.offsetIEta(iEta, -1);
276  int iPhiP = caloNav.offsetIPhi(iPhi, 1);
277  int iPhiP2 = caloNav.offsetIPhi(iPhi, 2);
278  int iPhiM = caloNav.offsetIPhi(iPhi, -1);
279  int iPhiM2 = caloNav.offsetIPhi(iPhi, -2);
280  const l1t::CaloTower& towerNW = l1t::CaloTools::getTower(towers, iEtaM, iPhiM);
281  const l1t::CaloTower& towerN = l1t::CaloTools::getTower(towers, iEta , iPhiM);
282  const l1t::CaloTower& towerNE = l1t::CaloTools::getTower(towers, iEtaP, iPhiM);
283  const l1t::CaloTower& towerE = l1t::CaloTools::getTower(towers, iEtaP, iPhi );
284  const l1t::CaloTower& towerSE = l1t::CaloTools::getTower(towers, iEtaP, iPhiP);
285  const l1t::CaloTower& towerS = l1t::CaloTools::getTower(towers, iEta , iPhiP);
286  const l1t::CaloTower& towerSW = l1t::CaloTools::getTower(towers, iEtaM, iPhiP);
287  const l1t::CaloTower& towerW = l1t::CaloTools::getTower(towers, iEtaM, iPhi );
288  const l1t::CaloTower& towerNN = l1t::CaloTools::getTower(towers, iEta , iPhiM2);
289  const l1t::CaloTower& towerSS = l1t::CaloTools::getTower(towers, iEta , iPhiP2);
290 
291  int towerEtNW = 0;
292  int towerEtN = 0;
293  int towerEtNE = 0;
294  int towerEtE = 0;
295  int towerEtSE = 0;
296  int towerEtS = 0;
297  int towerEtSW = 0;
298  int towerEtW = 0;
299  int towerEtNN = 0;
300  int towerEtSS = 0;
301  if(clusterInput_==E)
302  {
303  towerEtNW = towerNW.hwEtEm();
304  towerEtN = towerN .hwEtEm();
305  towerEtNE = towerNE.hwEtEm();
306  towerEtE = towerE .hwEtEm();
307  towerEtSE = towerSE.hwEtEm();
308  towerEtS = towerS .hwEtEm();
309  towerEtSW = towerSW.hwEtEm();
310  towerEtW = towerW .hwEtEm();
311  towerEtNN = towerNN.hwEtEm();
312  towerEtSS = towerSS.hwEtEm();
313  }
314  else if(clusterInput_==EH)
315  {
316  towerEtNW = towerNW.hwPt();
317  towerEtN = towerN .hwPt();
318  towerEtNE = towerNE.hwPt();
319  towerEtE = towerE .hwPt();
320  towerEtSE = towerSE.hwPt();
321  towerEtS = towerS .hwPt();
322  towerEtSW = towerSW.hwPt();
323  towerEtW = towerW .hwPt();
324  towerEtNN = towerNN.hwPt();
325  towerEtSS = towerSS.hwPt();
326 
327  }
328  else if(clusterInput_==H)
329  {
330  towerEtNW = towerNW.hwEtHad();
331  towerEtN = towerN .hwEtHad();
332  towerEtNE = towerNE.hwEtHad();
333  towerEtE = towerE .hwEtHad();
334  towerEtSE = towerSE.hwEtHad();
335  towerEtS = towerS .hwEtHad();
336  towerEtSW = towerSW.hwEtHad();
337  towerEtW = towerW .hwEtHad();
338  towerEtNN = towerNN.hwEtHad();
339  towerEtSS = towerSS.hwEtHad();
340  }
341 
342  int towerEtEmNW = towerNW.hwEtEm();
343  int towerEtEmN = towerN .hwEtEm();
344  int towerEtEmNE = towerNE.hwEtEm();
345  int towerEtEmE = towerE .hwEtEm();
346  int towerEtEmSE = towerSE.hwEtEm();
347  int towerEtEmS = towerS .hwEtEm();
348  int towerEtEmSW = towerSW.hwEtEm();
349  int towerEtEmW = towerW .hwEtEm();
350  int towerEtEmNN = towerNN.hwEtEm();
351  int towerEtEmSS = towerSS.hwEtEm();
352  //
353  int towerEtHadNW = towerNW.hwEtHad();
354  int towerEtHadN = towerN .hwEtHad();
355  int towerEtHadNE = towerNE.hwEtHad();
356  int towerEtHadE = towerE .hwEtHad();
357  int towerEtHadSE = towerSE.hwEtHad();
358  int towerEtHadS = towerS .hwEtHad();
359  int towerEtHadSW = towerSW.hwEtHad();
360  int towerEtHadW = towerW .hwEtHad();
361  int towerEtHadNN = towerNN.hwEtHad();
362  int towerEtHadSS = towerSS.hwEtHad();
363 
364  // trim one eta-side
365  // The side with largest energy will be kept
366  int EtEtaRight = 0;
367  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NE)) EtEtaRight += towerEtNE;
368  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_E)) EtEtaRight += towerEtE;
369  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SE)) EtEtaRight += towerEtSE;
370  int EtEtaLeft = 0;
371  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NW)) EtEtaLeft += towerEtNW;
372  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_W)) EtEtaLeft += towerEtW;
373  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SW)) EtEtaLeft += towerEtSW;
374 
375  cluster.setClusterFlag(CaloCluster::TRIM_LEFT, (EtEtaRight>= EtEtaLeft) );
376 
377 
378  if(cluster.checkClusterFlag(CaloCluster::TRIM_LEFT))
379  {
380  cluster.setClusterFlag(CaloCluster::INCLUDE_NW, false);
381  cluster.setClusterFlag(CaloCluster::INCLUDE_W , false);
382  cluster.setClusterFlag(CaloCluster::INCLUDE_SW, false);
383  }
384  else
385  {
386  cluster.setClusterFlag(CaloCluster::INCLUDE_NE, false);
387  cluster.setClusterFlag(CaloCluster::INCLUDE_E , false);
388  cluster.setClusterFlag(CaloCluster::INCLUDE_SE, false);
389  }
390 
391 
392  // compute cluster energy according to cluster flags
393  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NW)) cluster.setHwPt(cluster.hwPt() + towerEtNW);
394  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_N)) cluster.setHwPt(cluster.hwPt() + towerEtN);
395  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NE)) cluster.setHwPt(cluster.hwPt() + towerEtNE);
396  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_E)) cluster.setHwPt(cluster.hwPt() + towerEtE);
397  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SE)) cluster.setHwPt(cluster.hwPt() + towerEtSE);
398  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_S)) cluster.setHwPt(cluster.hwPt() + towerEtS);
399  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SW)) cluster.setHwPt(cluster.hwPt() + towerEtSW);
400  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_W)) cluster.setHwPt(cluster.hwPt() + towerEtW);
401  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NN)) cluster.setHwPt(cluster.hwPt() + towerEtNN);
402  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SS)) cluster.setHwPt(cluster.hwPt() + towerEtSS);
403  //
404  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NW)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmNW);
405  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_N)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmN);
406  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NE)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmNE);
407  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_E)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmE);
408  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SE)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmSE);
409  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_S)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmS);
410  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SW)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmSW);
411  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_W)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmW);
412  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NN)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmNN);
413  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SS)) cluster.setHwPtEm(cluster.hwPtEm() + towerEtEmSS);
414  //
415  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NW)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadNW);
416  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_N)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadN);
417  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NE)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadNE);
418  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_E)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadE);
419  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SE)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadSE);
420  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_S)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadS);
421  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SW)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadSW);
422  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_W)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadW);
423  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NN)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadNN);
424  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SS)) cluster.setHwPtHad(cluster.hwPtHad() + towerEtHadSS);
425 
426 
427  // Compute fine-grain position within the seed tower,
428  // according to the distribution of energy in the cluster
429  int fgEta = 0;
430  int fgPhi = 0;
431 
432  if(EtEtaRight>EtEtaLeft) fgEta = 2;
433  else if(EtEtaLeft>EtEtaRight) fgEta = 1;
434 
435  int EtUp = 0;
436  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NE)) EtUp += towerEtNE;
437  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_N)) EtUp += towerEtN;
438  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NW)) EtUp += towerEtNW;
439  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_NN)) EtUp += towerEtNN;
440  int EtDown = 0;
441  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SE)) EtDown += towerEtSE;
442  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_S)) EtDown += towerEtS;
443  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SW)) EtDown += towerEtSW;
444  if(cluster.checkClusterFlag(CaloCluster::INCLUDE_SS)) EtDown += towerEtSS;
445  //
446  if(EtDown>EtUp) fgPhi = 2;
447  else if(EtUp>EtDown) fgPhi = 1;
448  //
449  cluster.setFgEta(fgEta);
450  cluster.setFgPhi(fgPhi);
451  }
452  }
453 }
454 
455 
456 
457 
458 
459 
460 
461 bool l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::idHoverE(const l1t::CaloTower tow){
462 
463  bool hOverEBit = true;
464 
465  int ratio = tow.hwEtRatio();
466  int qual = tow.hwQual();
467  bool denomZeroFlag = ((qual&0x1) > 0);
468  bool eOverHFlag = ((qual&0x2) > 0);
469 
470  if (denomZeroFlag && !eOverHFlag)
471  hOverEBit = false;
472  if (denomZeroFlag && eOverHFlag)
473  hOverEBit = true;
474  if (!denomZeroFlag && !eOverHFlag) // H > E, ratio = log(H/E)
475  hOverEBit = false;
476  if (!denomZeroFlag && eOverHFlag){ // E >= H , so ratio==log(E/H)
477  if(abs(tow.hwEta())< 16 )
478  hOverEBit = ratio > params_->egHOverEcutBarrel(); // equivalent to H/E<=pow(2,-egHOverEcut)
479  else
480  hOverEBit = ratio > params_->egHOverEcutEndcap();
481  }
482 
483  return hOverEBit;
484 
485 }
particleFlowDisplacedVertex_cfi.ratio
ratio
Definition: particleFlowDisplacedVertex_cfi.py:93
l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::filtering
void filtering(const std::vector< l1t::CaloTower > &towers, std::vector< l1t::CaloCluster > &clusters)
Definition: Stage2Layer2ClusterAlgorithmFirmwareImp1.cc:205
l1t::CaloStage2Nav::offsetIEta
static int offsetIEta(int iEta, int offset)
Definition: CaloStage2Nav.h:44
l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::Stage2Layer2ClusterAlgorithmFirmwareImp1
Stage2Layer2ClusterAlgorithmFirmwareImp1(CaloParamsHelper const *params, ClusterInput clusterInput)
Definition: Stage2Layer2ClusterAlgorithmFirmwareImp1.cc:18
l1t::CaloTower::hwEtRatio
int hwEtRatio() const
Definition: CaloTower.cc:74
l1t::CaloParamsHelper::egHOverEcutBarrel
int egHOverEcutBarrel() const
Definition: CaloParamsHelper.h:171
l1t::CaloTower::hwEtEm
int hwEtEm() const
Definition: CaloTower.cc:64
electronIdCutBased_cfi.hOverE
hOverE
Definition: electronIdCutBased_cfi.py:124
l1t::CaloCluster::setHwSeedPt
void setHwSeedPt(int pt)
Definition: CaloCluster.cc:41
l1t::CaloParamsHelper::egSeedThreshold
double egSeedThreshold() const
Definition: CaloParamsHelper.h:139
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
l1t::CaloCluster::setFgECAL
void setFgECAL(int fgECAL)
Definition: CaloCluster.cc:61
l1t::CaloCluster::setHwPtHad
void setHwPtHad(int pt)
Definition: CaloCluster.cc:36
l1t::CaloStage2Nav::offsetIPhi
static int offsetIPhi(int iPhi, int offset)
Definition: CaloStage2Nav.h:33
l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::refining
void refining(const std::vector< l1t::CaloTower > &towers, std::vector< l1t::CaloCluster > &clusters)
Definition: Stage2Layer2ClusterAlgorithmFirmwareImp1.cc:261
l1t::CaloTools::getCluster
static const l1t::CaloCluster & getCluster(const std::vector< l1t::CaloCluster > &clusters, int iEta, int iPhi)
Definition: CaloTools.cc:60
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
l1t::L1Candidate::hwEta
int hwEta() const
Definition: L1Candidate.h:49
l1t::L1Candidate::hwQual
int hwQual() const
Definition: L1Candidate.h:51
l1t::CaloParamsHelper::egHcalThreshold
double egHcalThreshold() const
Definition: CaloParamsHelper.h:141
l1t::CaloParamsHelper::egNeighbourThreshold
double egNeighbourThreshold() const
Definition: CaloParamsHelper.h:140
l1t::CaloCluster::setHOverE
void setHOverE(int hOverE)
Definition: CaloCluster.cc:56
l1t::CaloCluster::setHwPtEm
void setHwPtEm(int pt)
Definition: CaloCluster.cc:31
l1t::L1Candidate::hwPt
int hwPt() const
Definition: L1Candidate.h:48
fastPrimaryVertexProducer_cfi.clusters
clusters
Definition: fastPrimaryVertexProducer_cfi.py:5
ALCARECOTkAlBeamHalo_cff.filter
filter
Definition: ALCARECOTkAlBeamHalo_cff.py:27
l1t::CaloParamsHelper::egHOverEcutEndcap
int egHOverEcutEndcap() const
Definition: CaloParamsHelper.h:172
l1t::CaloTools::getTower
static const l1t::CaloTower & getTower(const std::vector< l1t::CaloTower > &towers, int iEta, int iPhi)
Definition: CaloTools.cc:37
l1t::CaloParamsHelper::towerLsbSum
double towerLsbSum() const
Definition: CaloParamsHelper.h:86
l1t::CaloParamsHelper::towerLsbE
double towerLsbE() const
Definition: CaloParamsHelper.h:85
l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::clustering
void clustering(const std::vector< l1t::CaloTower > &towers, std::vector< l1t::CaloCluster > &clusters)
Definition: Stage2Layer2ClusterAlgorithmFirmwareImp1.cc:67
l1t::CaloTower::hwEtHad
int hwEtHad() const
Definition: CaloTower.cc:69
constexpr
#define constexpr
Definition: GCC11Compatibility.h:35
l1t::Stage2Layer2ClusterAlgorithmFirmwareImp1::processEvent
void processEvent(const std::vector< l1t::CaloTower > &towers, std::vector< l1t::CaloCluster > &clusters) override
Definition: Stage2Layer2ClusterAlgorithmFirmwareImp1.cc:38
l1t::CaloParamsHelper::towerLsbH
double towerLsbH() const
Definition: CaloParamsHelper.h:84
Generated for CMSSW Reference Manual by doxygen 1.8.11