CMS 3D CMS Logo
ZdcTopology.cc
Go to the documentation of this file.
1 #include "Geometry/ForwardGeometry/interface/ZdcTopology.h"
2 #include "DataFormats/HcalDetId/interface/HcalZDCDetId.h"
3 #include "FWCore/MessageLogger/interface/MessageLogger.h"
4 #include <cmath>
5 #include <iostream>
6 #include <algorithm>
7 
8 ZdcTopology::ZdcTopology(const HcalDDDRecConstants* hcons)
9  : hcons_(hcons),
10  excludeEM_(false),
11  excludeHAD_(false),
12  excludeLUM_(false),
13  excludeRPD_(false),
14  excludeZP_(false),
15  excludeZN_(false),
16  firstEMModule_(1),
17  lastEMModule_(HcalZDCDetId::kDepEM),
18  firstHADModule_(1),
19  lastHADModule_(HcalZDCDetId::kDepHAD),
20  firstLUMModule_(1),
21  lastLUMModule_(HcalZDCDetId::kDepLUM),
22  firstRPDModule_(1),
23  lastRPDModule_(HcalZDCDetId::kDepRPD) {
24  mode_ = (HcalTopologyMode::Mode)(hcons_->getTopoMode());
25  excludeRPD_ = (mode_ < HcalTopologyMode::Mode::Run3);
26  edm::LogVerbatim("ForwardGeom") << "ZdcTopology : Mode " << mode_ << ":" << HcalTopologyMode::Mode::Run3
27  << " ExcludeRPD " << excludeRPD_;
28 }
29 
30 bool ZdcTopology::valid(const HcalZDCDetId& id) const {
31  // check the raw rules
32  bool ok = validRaw(id);
33  ok = ok && !isExcluded(id);
34  return ok;
35 }
36 
37 bool ZdcTopology::isExcluded(const HcalZDCDetId& id) const {
38  bool exed = false;
39 
40  // check for section exclutions
41  switch (id.section()) {
42  case (HcalZDCDetId::EM):
43  exed = excludeEM_;
44  break;
45  case (HcalZDCDetId::HAD):
46  exed = excludeHAD_;
47  break;
48  case (HcalZDCDetId::LUM):
49  exed = excludeLUM_;
50  break;
51  case (HcalZDCDetId::RPD):
52  exed = excludeRPD_;
53  break;
54  default:
55  exed = true;
56  }
57 
58  // check the entire list
59  if (!exed && !exclusionList_.empty()) {
60  std::vector<HcalZDCDetId>::const_iterator i = std::lower_bound(exclusionList_.begin(), exclusionList_.end(), id);
61  if (i != exclusionList_.end() && *i == id)
62  exed = true;
63  }
64  return exed;
65 }
66 
67 void ZdcTopology::exclude(const HcalZDCDetId& id) {
68  std::vector<HcalZDCDetId>::iterator i = std::lower_bound(exclusionList_.begin(), exclusionList_.end(), id);
69  if (i == exclusionList_.end() || *i != id) {
70  exclusionList_.insert(i, id);
71  }
72 }
73 
74 void ZdcTopology::exclude(int zside) {
75  switch (zside) {
76  case (1):
77  excludeZP_ = true;
78  break;
79  case (-1):
80  excludeZN_ = true;
81  break;
82  default:
83  break;
84  }
85 }
86 
87 void ZdcTopology::exclude(int zside, HcalZDCDetId::Section section) {
88  switch (zside) {
89  case (1):
90  excludeZP_ = true;
91  break;
92  case (-1):
93  excludeZN_ = true;
94  break;
95  default:
96  break;
97  }
98  switch (section) {
99  case (HcalZDCDetId::EM):
100  excludeEM_ = true;
101  break;
102  case (HcalZDCDetId::HAD):
103  excludeHAD_ = true;
104  break;
105  case (HcalZDCDetId::LUM):
106  excludeLUM_ = true;
107  break;
108  case (HcalZDCDetId::RPD):
109  excludeRPD_ = true;
110  break;
111  default:
112  break;
113  }
114 }
115 
116 int ZdcTopology::exclude(int zside, HcalZDCDetId::Section section, int ich1, int ich2) {
117  bool exed = false;
118  switch (zside) {
119  case (1):
120  exed = excludeZP_;
121  break;
122  case (-1):
123  exed = excludeZN_;
124  break;
125  default:
126  exed = false;
127  }
128  if (exed)
129  return 0;
130 
131  switch (section) {
132  case (HcalZDCDetId::EM):
133  exed = excludeEM_;
134  break;
135  case (HcalZDCDetId::HAD):
136  exed = excludeHAD_;
137  break;
138  case (HcalZDCDetId::LUM):
139  exed = excludeLUM_;
140  break;
141  case (HcalZDCDetId::RPD):
142  exed = excludeRPD_;
143  break;
144  default:
145  exed = false;
146  }
147  if (exed)
148  return 0;
149 
150  bool isPositive = false;
151  if (zside == 1)
152  isPositive = true;
153 
154  int n = 0;
155  for (int ich = ich1; ich < ich2; ich++) {
156  HcalZDCDetId id(section, isPositive, ich);
157  if (validRaw(id))
158  exclude(id);
159  n++;
160  }
161  return n;
162 }
163 
164 bool ZdcTopology::validRaw(const HcalZDCDetId& id) const {
165  bool ok = true;
166  if (abs(id.zside()) != 1)
167  ok = false;
168  else if (id.channel() <= 0)
169  ok = false;
170  else if (!(id.section() == HcalZDCDetId::EM || id.section() == HcalZDCDetId::HAD ||
171  id.section() == HcalZDCDetId::LUM || id.section() == HcalZDCDetId::RPD))
172  ok = false;
173  else if (id.section() == HcalZDCDetId::EM && id.channel() > HcalZDCDetId::kDepEM)
174  ok = false;
175  else if (id.section() == HcalZDCDetId::HAD && id.channel() > HcalZDCDetId::kDepHAD)
176  ok = false;
177  else if (id.section() == HcalZDCDetId::LUM && id.channel() > HcalZDCDetId::kDepLUM)
178  ok = false;
179  else if (id.section() == HcalZDCDetId::RPD && id.channel() > HcalZDCDetId::kDepRPD)
180  ok = false;
181  else if (id.section() == HcalZDCDetId::Unknown)
182  ok = false;
183  return ok;
184 }
185 
186 std::vector<DetId> ZdcTopology::transverse(const DetId& id) const {
187  std::vector<DetId> vNeighborsDetId;
188  HcalZDCDetId zdcId = HcalZDCDetId(id);
189  HcalZDCDetId zdcDetId;
190  if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::EM) {
191  bool isPositive = false;
192  if (zdcId.zside() == 1)
193  isPositive = true;
194  if (zdcId.channel() == 1) {
195  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
196  vNeighborsDetId.emplace_back(zdcDetId.rawId());
197  return vNeighborsDetId;
198  }
199  if (zdcId.channel() == HcalZDCDetId::kDepEM) {
200  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
201  vNeighborsDetId.emplace_back(zdcDetId.rawId());
202  return vNeighborsDetId;
203  }
204  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
205  vNeighborsDetId.emplace_back(zdcDetId.rawId());
206  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
207  vNeighborsDetId.emplace_back(zdcDetId.rawId());
208  }
209  return vNeighborsDetId;
210 }
211 
212 std::vector<DetId> ZdcTopology::longitudinal(const DetId& id) const {
213  std::vector<DetId> vNeighborsDetId;
214  HcalZDCDetId zdcId = HcalZDCDetId(id);
215  HcalZDCDetId zdcDetId;
216  if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::HAD) {
217  bool isPositive = false;
218  if (zdcId.zside() == 1)
219  isPositive = true;
220  if (zdcId.channel() == 1) {
221  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
222  vNeighborsDetId.emplace_back(zdcDetId.rawId());
223  return vNeighborsDetId;
224  }
225  if (zdcId.channel() == HcalZDCDetId::kDepHAD) {
226  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
227  vNeighborsDetId.emplace_back(zdcDetId.rawId());
228  return vNeighborsDetId;
229  }
230  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
231  vNeighborsDetId.emplace_back(zdcDetId.rawId());
232  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
233  vNeighborsDetId.emplace_back(zdcDetId.rawId());
234  }
235  if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::LUM) {
236  bool isPositive = false;
237  if (zdcId.zside() == 1)
238  isPositive = true;
239  if (zdcId.channel() == 1) {
240  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
241  vNeighborsDetId.emplace_back(zdcDetId.rawId());
242  return vNeighborsDetId;
243  }
244  if (zdcId.channel() == HcalZDCDetId::kDepLUM) {
245  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
246  vNeighborsDetId.emplace_back(zdcDetId.rawId());
247  return vNeighborsDetId;
248  }
249  }
250  if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::RPD) {
251  bool isPositive = false;
252  if (zdcId.zside() == 1)
253  isPositive = true;
254  if (zdcId.channel() == 1) {
255  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
256  vNeighborsDetId.emplace_back(zdcDetId.rawId());
257  return vNeighborsDetId;
258  }
259  if (zdcId.channel() == HcalZDCDetId::kDepRPD) {
260  zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
261  vNeighborsDetId.emplace_back(zdcDetId.rawId());
262  return vNeighborsDetId;
263  }
264  }
265  return vNeighborsDetId;
266 }
267 
268 std::vector<DetId> ZdcTopology::east(const DetId& /*id*/) const {
269  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::east() not yet implemented";
270  std::vector<DetId> vNeighborsDetId;
271  return vNeighborsDetId;
272 }
273 
274 std::vector<DetId> ZdcTopology::west(const DetId& /*id*/) const {
275  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::west() not yet implemented";
276  std::vector<DetId> vNeighborsDetId;
277  return vNeighborsDetId;
278 }
279 
280 std::vector<DetId> ZdcTopology::north(const DetId& /*id*/) const {
281  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::north() not yet implemented";
282  std::vector<DetId> vNeighborsDetId;
283  return vNeighborsDetId;
284 }
285 std::vector<DetId> ZdcTopology::south(const DetId& /*id*/) const {
286  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::south() not yet implemented";
287  std::vector<DetId> vNeighborsDetId;
288  return vNeighborsDetId;
289 }
290 std::vector<DetId> ZdcTopology::up(const DetId& /*id*/) const {
291  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::up() not yet implemented";
292  std::vector<DetId> vNeighborsDetId;
293  return vNeighborsDetId;
294 }
295 std::vector<DetId> ZdcTopology::down(const DetId& /*id*/) const {
296  edm::LogVerbatim("ForwardGeom") << "ZdcTopology::down() not yet implemented";
297  std::vector<DetId> vNeighborsDetId;
298  return vNeighborsDetId;
299 }
300 
301 int ZdcTopology::ncells(HcalZDCDetId::Section section) const {
302  int ncells = 0;
303  switch (section) {
304  case (HcalZDCDetId::EM):
305  ncells = HcalZDCDetId::kDepEM;
306  break;
307  case (HcalZDCDetId::HAD):
308  ncells = HcalZDCDetId::kDepHAD;
309  break;
310  case (HcalZDCDetId::LUM):
311  ncells = HcalZDCDetId::kDepLUM;
312  break;
313  case (HcalZDCDetId::RPD):
314  ncells = HcalZDCDetId::kDepRPD;
315  break;
316  case (HcalZDCDetId::Unknown):
317  ncells = 0;
318  break;
319  }
320  return ncells;
321 }
322 
323 int ZdcTopology::firstCell(HcalZDCDetId::Section section) const {
324  int firstCell = 0;
325  switch (section) {
326  case (HcalZDCDetId::EM):
327  firstCell = firstEMModule_;
328  break;
329  case (HcalZDCDetId::HAD):
330  firstCell = firstHADModule_;
331  break;
332  case (HcalZDCDetId::LUM):
333  firstCell = firstLUMModule_;
334  break;
335  case (HcalZDCDetId::RPD):
336  firstCell = firstRPDModule_;
337  break;
338  case (HcalZDCDetId::Unknown):
339  firstCell = 0;
340  break;
341  }
342  return firstCell;
343 }
344 
345 int ZdcTopology::lastCell(HcalZDCDetId::Section section) const {
346  int lastCell = 0;
347  switch (section) {
348  case (HcalZDCDetId::EM):
349  lastCell = lastEMModule_;
350  break;
351  case (HcalZDCDetId::HAD):
352  lastCell = lastHADModule_;
353  break;
354  case (HcalZDCDetId::LUM):
355  lastCell = lastLUMModule_;
356  break;
357  case (HcalZDCDetId::RPD):
358  lastCell = lastRPDModule_;
359  break;
360  case (HcalZDCDetId::Unknown):
361  lastCell = 0;
362  break;
363  }
364  return lastCell;
365 }
366 
367 uint32_t ZdcTopology::kSizeForDenseIndexing() const {
368  return (mode_ >= HcalTopologyMode::Mode::Run3 ? HcalZDCDetId::kSizeForDenseIndexingRun3
369  : HcalZDCDetId::kSizeForDenseIndexingRun1);
370 }
371 
372 DetId ZdcTopology::denseId2detId(uint32_t di) const {
373  if (validDenseIndex(di)) {
374  bool lz(false);
375  uint32_t dp(0);
376  HcalZDCDetId::Section se(HcalZDCDetId::Unknown);
377  if (di >= 2 * HcalZDCDetId::kDepRun1) {
378  lz = (di >= (HcalZDCDetId::kDepRun1 + HcalZDCDetId::kDepTot));
379  se = HcalZDCDetId::RPD;
380  dp = 1 + ((di - 2 * HcalZDCDetId::kDepRun1) % HcalZDCDetId::kDepRPD);
381  } else {
382  lz = (di >= HcalZDCDetId::kDepRun1);
383  uint32_t in = (di % HcalZDCDetId::kDepRun1);
384  se = (in < HcalZDCDetId::kDepEM
385  ? HcalZDCDetId::EM
386  : (in < HcalZDCDetId::kDepEM + HcalZDCDetId::kDepHAD ? HcalZDCDetId::HAD : HcalZDCDetId::LUM));
387  dp = (se == HcalZDCDetId::EM ? in + 1
388  : (se == HcalZDCDetId::HAD ? in - HcalZDCDetId::kDepEM + 1
389  : in - HcalZDCDetId::kDepEM - HcalZDCDetId::kDepHAD + 1));
390  }
391  return static_cast<DetId>(HcalZDCDetId(se, lz, dp));
392  }
393  return DetId();
394 }
395 
396 uint32_t ZdcTopology::detId2DenseIndex(const DetId& id) const {
397  HcalZDCDetId detId(id);
398  const int32_t se(detId.section());
399  uint32_t di = (detId.channel() - 1 +
400  (se == HcalZDCDetId::RPD
401  ? 2 * HcalZDCDetId::kDepRun1 + (detId.zside() < 0 ? 0 : HcalZDCDetId::kDepRPD)
402  : ((detId.zside() < 0 ? 0 : HcalZDCDetId::kDepRun1) +
403  (se == HcalZDCDetId::HAD
404  ? HcalZDCDetId::kDepEM
405  : (se == HcalZDCDetId::LUM ? HcalZDCDetId::kDepEM + HcalZDCDetId::kDepHAD : 0)))));
406  return di;
407 }
ZdcTopology::firstEMModule_
int firstEMModule_
Definition: ZdcTopology.h:83
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:134
ZdcTopology::down
std::vector< DetId > down(const DetId &id) const override
Definition: ZdcTopology.cc:295
ZdcTopology::excludeEM_
bool excludeEM_
Definition: ZdcTopology.h:81
ZdcTopology::exclude
void exclude(const HcalZDCDetId &id)
Definition: ZdcTopology.cc:67
mps_fire.i
i
Definition: mps_fire.py:429
ZdcTopology::lastLUMModule_
int lastLUMModule_
Definition: ZdcTopology.h:83
ZdcTopology::kSizeForDenseIndexing
uint32_t kSizeForDenseIndexing() const
Definition: ZdcTopology.cc:367
HcalZDCDetId::kDepTot
static constexpr int32_t kDepTot
Definition: HcalZDCDetId.h:42
Calorimetry_cff.dp
dp
Definition: Calorimetry_cff.py:158
ZdcTopology::excludeRPD_
bool excludeRPD_
Definition: ZdcTopology.h:81
ZdcTopology::excludeHAD_
bool excludeHAD_
Definition: ZdcTopology.h:81
ecaldqm::zside
int zside(DetId const &)
Definition: EcalDQMCommonUtils.cc:189
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:86
ZdcTopology::ZdcTopology
ZdcTopology(const HcalDDDRecConstants *hcons)
Definition: ZdcTopology.cc:8
HcalZDCDetId::kSizeForDenseIndexingRun1
static constexpr int32_t kSizeForDenseIndexingRun1
Definition: HcalZDCDetId.h:201
ZdcTopology::up
std::vector< DetId > up(const DetId &id) const override
Definition: ZdcTopology.cc:290
ZdcTopology::hcons_
const HcalDDDRecConstants * hcons_
Definition: ZdcTopology.h:76
ZdcTopology::mode_
HcalTopologyMode::Mode mode_
Definition: ZdcTopology.h:77
pfDeepBoostedJetPreprocessParams_cfi.lower_bound
lower_bound
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:15
ZdcTopology::north
std::vector< DetId > north(const DetId &id) const override
Definition: ZdcTopology.cc:280
ZdcTopology::firstRPDModule_
int firstRPDModule_
Definition: ZdcTopology.h:83
HcalZDCDetId::kDepHAD
static constexpr int32_t kDepHAD
Definition: HcalZDCDetId.h:38
ZdcTopology::excludeZN_
bool excludeZN_
Definition: ZdcTopology.h:81
HcalZDCDetId::kDepEM
static constexpr int32_t kDepEM
Definition: HcalZDCDetId.h:37
ZdcTopology::detId2DenseIndex
uint32_t detId2DenseIndex(const DetId &id) const
Definition: ZdcTopology.cc:396
ZdcTopology::south
std::vector< DetId > south(const DetId &id) const override
Definition: ZdcTopology.cc:285
ZdcTopology::firstHADModule_
int firstHADModule_
Definition: ZdcTopology.h:83
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ZdcTopology::denseId2detId
DetId denseId2detId(uint32_t di) const override
Definition: ZdcTopology.cc:372
ZdcTopology::transverse
virtual std::vector< DetId > transverse(const DetId &id) const
Definition: ZdcTopology.cc:186
ZdcTopology::exclusionList_
std::vector< HcalZDCDetId > exclusionList_
Definition: ZdcTopology.h:79
ZdcTopology::excludeLUM_
bool excludeLUM_
Definition: ZdcTopology.h:81
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
ZdcTopology::lastRPDModule_
int lastRPDModule_
Definition: ZdcTopology.h:83
ZdcTopology::valid
virtual bool valid(const HcalZDCDetId &id) const
Definition: ZdcTopology.cc:30
ZdcTopology::firstCell
int firstCell(HcalZDCDetId::Section section) const
Definition: ZdcTopology.cc:323
ZdcTopology::east
std::vector< DetId > east(const DetId &id) const override
Definition: ZdcTopology.cc:268
DetId
Definition: DetId.h:17
ZdcTopology::west
std::vector< DetId > west(const DetId &id) const override
Definition: ZdcTopology.cc:274
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
CaloSubdetectorTopology::ncells
virtual unsigned int ncells() const
return a count of valid cells (for dense indexing use)
Definition: CaloSubdetectorTopology.h:30
ZdcTopology::lastCell
int lastCell(HcalZDCDetId::Section section) const
Definition: ZdcTopology.cc:345
HcalZDCDetId::kDepLUM
static constexpr int32_t kDepLUM
Definition: HcalZDCDetId.h:39
HcalZDCDetId::section
constexpr Section section() const
get the section
Definition: HcalZDCDetId.h:92
ZdcTopology::validRaw
bool validRaw(const HcalZDCDetId &id) const
Definition: ZdcTopology.cc:164
HcalZDCDetId::kDepRun1
static constexpr int32_t kDepRun1
Definition: HcalZDCDetId.h:41
ZdcTopology::validDenseIndex
bool validDenseIndex(uint32_t din) const
Definition: ZdcTopology.h:57
ZdcTopology::excludeZP_
bool excludeZP_
Definition: ZdcTopology.h:81
HcalZDCDetId::kDepRPD
static constexpr int32_t kDepRPD
Definition: HcalZDCDetId.h:40
ZdcTopology::lastEMModule_
int lastEMModule_
Definition: ZdcTopology.h:83
ZdcTopology::isExcluded
bool isExcluded(const HcalZDCDetId &id) const
Definition: ZdcTopology.cc:37
HcalZDCDetId::channel
constexpr int32_t channel() const
get the channel
Definition: HcalZDCDetId.h:112
ZdcTopology::firstLUMModule_
int firstLUMModule_
Definition: ZdcTopology.h:83
HcalZDCDetId::zside
constexpr int32_t zside() const
get the z-side of the cell (1/-1)
Definition: HcalZDCDetId.h:90
HcalZDCDetId::kSizeForDenseIndexingRun3
static constexpr int32_t kSizeForDenseIndexingRun3
Definition: HcalZDCDetId.h:202
ZdcTopology::longitudinal
virtual std::vector< DetId > longitudinal(const DetId &id) const
Definition: ZdcTopology.cc:212
ZdcTopology::lastHADModule_
int lastHADModule_
Definition: ZdcTopology.h:83
Generated for CMSSW Reference Manual by doxygen 1.8.14