ForwardGeometry/src/ZdcTopology.cc

0001 #include "Geometry/ForwardGeometry/interface/ZdcTopology.h"
0002 #include "DataFormats/HcalDetId/interface/HcalZDCDetId.h"
0003 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0004 #include <cmath>
0005 #include <iostream>
0006 #include <algorithm>
0007
0008 ZdcTopology::ZdcTopology()
0009     : excludeEM_(false),
0010       excludeHAD_(false),
0011       excludeLUM_(false),
0012       excludeRPD_(false),
0013       excludeZP_(false),
0014       excludeZN_(false),
0015       firstEMModule_(1),
0016       lastEMModule_(HcalZDCDetId::kDepEM),
0017       firstHADModule_(1),
0018       lastHADModule_(HcalZDCDetId::kDepHAD),
0019       firstLUMModule_(1),
0020       lastLUMModule_(HcalZDCDetId::kDepLUM),
0021       firstRPDModule_(1),
0022       lastRPDModule_(HcalZDCDetId::kDepRPD) {}
0023
0024 bool ZdcTopology::valid(const HcalZDCDetId& id) const {
0025   // check the raw rules
0026   bool ok = validRaw(id);
0027   ok = ok && !isExcluded(id);
0028   return ok;
0029 }
0030
0031 bool ZdcTopology::isExcluded(const HcalZDCDetId& id) const {
0032   bool exed = false;
0033
0034   // check for section exclutions
0035   switch (id.section()) {
0036     case (HcalZDCDetId::EM):
0037       exed = excludeEM_;
0038       break;
0039     case (HcalZDCDetId::HAD):
0040       exed = excludeHAD_;
0041       break;
0042     case (HcalZDCDetId::LUM):
0043       exed = excludeLUM_;
0044       break;
0045     case (HcalZDCDetId::RPD):
0046       exed = excludeRPD_;
0047       break;
0048     default:
0049       exed = false;
0050   }
0051
0052   // check the entire list
0053   if (!exed && !exclusionList_.empty()) {
0054     std::vector<HcalZDCDetId>::const_iterator i = std::lower_bound(exclusionList_.begin(), exclusionList_.end(), id);
0055     if (i != exclusionList_.end() && *i == id)
0056       exed = true;
0057   }
0058   return exed;
0059 }
0060
0061 void ZdcTopology::exclude(const HcalZDCDetId& id) {
0062   std::vector<HcalZDCDetId>::iterator i = std::lower_bound(exclusionList_.begin(), exclusionList_.end(), id);
0063   if (i == exclusionList_.end() || *i != id) {
0064     exclusionList_.insert(i, id);
0065   }
0066 }
0067
0068 void ZdcTopology::exclude(int zside) {
0069   switch (zside) {
0070     case (1):
0071       excludeZP_ = true;
0072       break;
0073     case (-1):
0074       excludeZN_ = true;
0075       break;
0076     default:
0077       break;
0078   }
0079 }
0080
0081 void ZdcTopology::exclude(int zside, HcalZDCDetId::Section section) {
0082   switch (zside) {
0083     case (1):
0084       excludeZP_ = true;
0085       break;
0086     case (-1):
0087       excludeZN_ = true;
0088       break;
0089     default:
0090       break;
0091   }
0092   switch (section) {
0093     case (HcalZDCDetId::EM):
0094       excludeEM_ = true;
0095       break;
0096     case (HcalZDCDetId::HAD):
0097       excludeHAD_ = true;
0098       break;
0099     case (HcalZDCDetId::LUM):
0100       excludeLUM_ = true;
0101       break;
0102     case (HcalZDCDetId::RPD):
0103       excludeRPD_ = true;
0104       break;
0105     default:
0106       break;
0107   }
0108 }
0109
0110 int ZdcTopology::exclude(int zside, HcalZDCDetId::Section section, int ich1, int ich2) {
0111   bool exed = false;
0112   switch (zside) {
0113     case (1):
0114       exed = excludeZP_;
0115       break;
0116     case (-1):
0117       exed = excludeZN_;
0118       break;
0119     default:
0120       exed = false;
0121   }
0122   if (exed)
0123     return 0;
0124
0125   switch (section) {
0126     case (HcalZDCDetId::EM):
0127       exed = excludeEM_;
0128       break;
0129     case (HcalZDCDetId::HAD):
0130       exed = excludeHAD_;
0131       break;
0132     case (HcalZDCDetId::LUM):
0133       exed = excludeLUM_;
0134       break;
0135     case (HcalZDCDetId::RPD):
0136       exed = excludeRPD_;
0137       break;
0138     default:
0139       exed = false;
0140   }
0141   if (exed)
0142     return 0;
0143
0144   bool isPositive = false;
0145   if (zside == 1)
0146     isPositive = true;
0147
0148   int n = 0;
0149   for (int ich = ich1; ich < ich2; ich++) {
0150     HcalZDCDetId id(section, isPositive, ich);
0151     if (validRaw(id))
0152       exclude(id);
0153     n++;
0154   }
0155   return n;
0156 }
0157
0158 bool ZdcTopology::validRaw(const HcalZDCDetId& id) const {
0159   bool ok = true;
0160   if (abs(id.zside()) != 1)
0161     ok = false;
0162   else if (id.channel() <= 0)
0163     ok = false;
0164   else if (!(id.section() == HcalZDCDetId::EM || id.section() == HcalZDCDetId::HAD ||
0165              id.section() == HcalZDCDetId::LUM))
0166     //else if (!(id.section() == HcalZDCDetId::EM || id.section() == HcalZDCDetId::HAD || id.section()== HcalZDCDetId::LUM || id.section()== HcalZDCDetId::RPD))
0167     ok = false;
0168   else if (id.section() == HcalZDCDetId::EM && id.channel() > HcalZDCDetId::kDepEM)
0169     ok = false;
0170   else if (id.section() == HcalZDCDetId::HAD && id.channel() > HcalZDCDetId::kDepHAD)
0171     ok = false;
0172   else if (id.section() == HcalZDCDetId::LUM && id.channel() > HcalZDCDetId::kDepLUM)
0173     ok = false;
0174   else if (id.section() == HcalZDCDetId::RPD && id.channel() > HcalZDCDetId::kDepRPD)
0175     ok = false;
0176   return ok;
0177 }
0178
0179 std::vector<DetId> ZdcTopology::transverse(const DetId& id) const {
0180   std::vector<DetId> vNeighborsDetId;
0181   HcalZDCDetId zdcId = HcalZDCDetId(id);
0182   HcalZDCDetId zdcDetId;
0183   if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::EM) {
0184     bool isPositive = false;
0185     if (zdcId.zside() == 1)
0186       isPositive = true;
0187     if (zdcId.channel() == 1) {
0188       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0189       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0190       return vNeighborsDetId;
0191     }
0192     if (zdcId.channel() == HcalZDCDetId::kDepEM) {
0193       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0194       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0195       return vNeighborsDetId;
0196     }
0197     zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0198     vNeighborsDetId.emplace_back(zdcDetId.rawId());
0199     zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0200     vNeighborsDetId.emplace_back(zdcDetId.rawId());
0201   }
0202   return vNeighborsDetId;
0203 }
0204
0205 std::vector<DetId> ZdcTopology::longitudinal(const DetId& id) const {
0206   std::vector<DetId> vNeighborsDetId;
0207   HcalZDCDetId zdcId = HcalZDCDetId(id);
0208   HcalZDCDetId zdcDetId;
0209   if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::HAD) {
0210     bool isPositive = false;
0211     if (zdcId.zside() == 1)
0212       isPositive = true;
0213     if (zdcId.channel() == 1) {
0214       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0215       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0216       return vNeighborsDetId;
0217     }
0218     if (zdcId.channel() == HcalZDCDetId::kDepHAD) {
0219       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0220       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0221       return vNeighborsDetId;
0222     }
0223     zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0224     vNeighborsDetId.emplace_back(zdcDetId.rawId());
0225     zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0226     vNeighborsDetId.emplace_back(zdcDetId.rawId());
0227   }
0228   if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::LUM) {
0229     bool isPositive = false;
0230     if (zdcId.zside() == 1)
0231       isPositive = true;
0232     if (zdcId.channel() == 1) {
0233       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0234       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0235       return vNeighborsDetId;
0236     }
0237     if (zdcId.channel() == HcalZDCDetId::kDepLUM) {
0238       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0239       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0240       return vNeighborsDetId;
0241     }
0242   }
0243   if (validRaw(zdcId) && zdcId.section() == HcalZDCDetId::RPD) {
0244     bool isPositive = false;
0245     if (zdcId.zside() == 1)
0246       isPositive = true;
0247     if (zdcId.channel() == 1) {
0248       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() + 1);
0249       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0250       return vNeighborsDetId;
0251     }
0252     if (zdcId.channel() == HcalZDCDetId::kDepRPD) {
0253       zdcDetId = HcalZDCDetId(zdcId.section(), isPositive, zdcId.channel() - 1);
0254       vNeighborsDetId.emplace_back(zdcDetId.rawId());
0255       return vNeighborsDetId;
0256     }
0257   }
0258   return vNeighborsDetId;
0259 }
0260
0261 std::vector<DetId> ZdcTopology::east(const DetId& /*id*/) const {
0262   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::east() not yet implemented";
0263   std::vector<DetId> vNeighborsDetId;
0264   return vNeighborsDetId;
0265 }
0266
0267 std::vector<DetId> ZdcTopology::west(const DetId& /*id*/) const {
0268   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::west() not yet implemented";
0269   std::vector<DetId> vNeighborsDetId;
0270   return vNeighborsDetId;
0271 }
0272
0273 std::vector<DetId> ZdcTopology::north(const DetId& /*id*/) const {
0274   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::north() not yet implemented";
0275   std::vector<DetId> vNeighborsDetId;
0276   return vNeighborsDetId;
0277 }
0278 std::vector<DetId> ZdcTopology::south(const DetId& /*id*/) const {
0279   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::south() not yet implemented";
0280   std::vector<DetId> vNeighborsDetId;
0281   return vNeighborsDetId;
0282 }
0283 std::vector<DetId> ZdcTopology::up(const DetId& /*id*/) const {
0284   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::up() not yet implemented";
0285   std::vector<DetId> vNeighborsDetId;
0286   return vNeighborsDetId;
0287 }
0288 std::vector<DetId> ZdcTopology::down(const DetId& /*id*/) const {
0289   edm::LogVerbatim("ForwardGeom") << "ZdcTopology::down() not yet implemented";
0290   std::vector<DetId> vNeighborsDetId;
0291   return vNeighborsDetId;
0292 }
0293
0294 int ZdcTopology::ncells(HcalZDCDetId::Section section) const {
0295   int ncells = 0;
0296   switch (section) {
0297     case (HcalZDCDetId::EM):
0298       ncells = HcalZDCDetId::kDepEM;
0299       break;
0300     case (HcalZDCDetId::HAD):
0301       ncells = HcalZDCDetId::kDepHAD;
0302       break;
0303     case (HcalZDCDetId::LUM):
0304       ncells = HcalZDCDetId::kDepLUM;
0305       break;
0306     case (HcalZDCDetId::RPD):
0307       ncells = HcalZDCDetId::kDepRPD;
0308       break;
0309     case (HcalZDCDetId::Unknown):
0310       ncells = 0;
0311       break;
0312   }
0313   return ncells;
0314 }
0315
0316 int ZdcTopology::firstCell(HcalZDCDetId::Section section) const {
0317   int firstCell = 0;
0318   switch (section) {
0319     case (HcalZDCDetId::EM):
0320       firstCell = firstEMModule_;
0321       break;
0322     case (HcalZDCDetId::HAD):
0323       firstCell = firstHADModule_;
0324       break;
0325     case (HcalZDCDetId::LUM):
0326       firstCell = firstLUMModule_;
0327       break;
0328     case (HcalZDCDetId::RPD):
0329       firstCell = firstRPDModule_;
0330       break;
0331     case (HcalZDCDetId::Unknown):
0332       firstCell = 0;
0333       break;
0334   }
0335   return firstCell;
0336 }
0337
0338 int ZdcTopology::lastCell(HcalZDCDetId::Section section) const {
0339   int lastCell = 0;
0340   switch (section) {
0341     case (HcalZDCDetId::EM):
0342       lastCell = lastEMModule_;
0343       break;
0344     case (HcalZDCDetId::HAD):
0345       lastCell = lastHADModule_;
0346       break;
0347     case (HcalZDCDetId::LUM):
0348       lastCell = lastLUMModule_;
0349       break;
0350     case (HcalZDCDetId::RPD):
0351       lastCell = lastRPDModule_;
0352       break;
0353     case (HcalZDCDetId::Unknown):
0354       lastCell = 0;
0355       break;
0356   }
0357   return lastCell;
0358 }