HGCalTBCommonData/src/HGCalTBParametersFromDD.cc

0001 #include "Geometry/HGCalTBCommonData/interface/HGCalTBParametersFromDD.h"
0002
0003 #include "DataFormats/Math/interface/GeantUnits.h"
0004 #include "DetectorDescription/Core/interface/DDFilteredView.h"
0005 #include "DetectorDescription/Core/interface/DDutils.h"
0006 #include "DetectorDescription/DDCMS/interface/DDFilteredView.h"
0007 #include "Geometry/HGCalCommonData/interface/HGCalGeometryMode.h"
0008 #include "Geometry/HGCalTBCommonData/interface/HGCalTBGeomParameters.h"
0009 #include "Geometry/HGCalTBCommonData/interface/HGCalTBParameters.h"
0010
0011 //#define EDM_ML_DEBUG
0012 using namespace geant_units::operators;
0013
0014 bool HGCalTBParametersFromDD::build(const DDCompactView* cpv,
0015                                     HGCalTBParameters& php,
0016                                     const std::string& name,
0017                                     const std::string& namew,
0018                                     const std::string& namec,
0019                                     const std::string& namet) {
0020 #ifdef EDM_ML_DEBUG
0021   edm::LogVerbatim("HGCalGeom") << "HGCalTBParametersFromDD (DDD)::build called with "
0022                                 << "names " << name << ":" << namew << ":" << namec << ":" << namet;
0023 #endif
0024
0025   // Special parameters at simulation level
0026   std::string attribute = "Volume";
0027   std::string value = name;
0028   DDValue val(attribute, value, 0.0);
0029   DDSpecificsMatchesValueFilter filter{val};
0030   DDFilteredView fv(*cpv, filter);
0031   bool ok = fv.firstChild();
0032   HGCalGeometryMode::WaferMode mode(HGCalGeometryMode::Polyhedra);
0033 #ifdef EDM_ML_DEBUG
0034   edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode ";
0035 #endif
0036   if (ok) {
0037     DDsvalues_type sv(fv.mergedSpecifics());
0038     php.mode_ = HGCalGeometryMode::getGeometryMode("GeometryMode", sv);
0039 #ifdef EDM_ML_DEBUG
0040     edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode " << php.mode_ << ":"
0041                                   << HGCalGeometryMode::Hexagon << ":" << HGCalGeometryMode::HexagonFull;
0042 #endif
0043     php.levelZSide_ = 3;    // Default level for ZSide
0044     php.detectorType_ = 0;  // These two parameters are
0045     php.useSimWt_ = 1;      // energy weighting for SimHits
0046     std::unique_ptr<HGCalTBGeomParameters> geom = std::make_unique<HGCalTBGeomParameters>();
0047     if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
0048       attribute = "OnlyForHGCalNumbering";
0049       value = namet;
0050       DDValue val2(attribute, value, 0.0);
0051       DDSpecificsMatchesValueFilter filter2{val2};
0052       DDFilteredView fv2(*cpv, filter2);
0053       bool ok2 = fv2.firstChild();
0054       if (ok2) {
0055         DDsvalues_type sv2(fv2.mergedSpecifics());
0056         mode = HGCalGeometryMode::getGeometryWaferMode("WaferMode", sv2);
0057 #ifdef EDM_ML_DEBUG
0058         edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0059                                       << HGCalGeometryMode::ExtrudedPolygon;
0060 #endif
0061       }
0062     }
0063     php.firstLayer_ = 1;
0064     if (php.mode_ == HGCalGeometryMode::Hexagon) {
0065       // Load the SpecPars
0066       geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0067       // Load the Geometry parameters
0068       geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0069       // Load cell parameters
0070       geom->loadCellParsHexagon(cpv, php);
0071       // Set complete fill mode
0072       php.defineFull_ = false;
0073     } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0074       // Load the SpecPars
0075       geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0076       // Load the Geometry parameters
0077       geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0078       // Modify some constants
0079       geom->loadWaferHexagon(php);
0080       // Load cell parameters
0081       geom->loadCellParsHexagon(cpv, php);
0082       // Set complete fill mode
0083       php.defineFull_ = true;
0084     } else {
0085       edm::LogError("HGCalGeom") << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew
0086                                  << ":" << namec;
0087       throw cms::Exception("DDException")
0088           << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew << ":" << namec;
0089     }
0090   } else {
0091     edm::LogError("HGCalGeom") << " Attribute " << val << " not found but needed.";
0092     throw cms::Exception("DDException") << "Attribute " << val << " not found but needed.";
0093   }
0094 #ifdef EDM_ML_DEBUG
0095   edm::LogVerbatim("HGCalGeom") << "Return from HGCalTBParametersFromDD::build"
0096                                 << " with flag " << ok;
0097 #endif
0098   return ok;
0099 }
0100
0101 bool HGCalTBParametersFromDD::build(const cms::DDCompactView* cpv,
0102                                     HGCalTBParameters& php,
0103                                     const std::string& name,
0104                                     const std::string& namew,
0105                                     const std::string& namec,
0106                                     const std::string& namet,
0107                                     const std::string& name2) {
0108 #ifdef EDM_ML_DEBUG
0109   edm::LogVerbatim("HGCalGeom") << "HGCalTBParametersFromDD (DD4hep)::build called with "
0110                                 << "names " << name << ":" << namew << ":" << namec << ":" << namet << ":" << name2;
0111 #endif
0112   cms::DDVectorsMap vmap = cpv->detector()->vectors();
0113   const cms::DDFilter filter("Volume", name);
0114   cms::DDFilteredView fv((*cpv), filter);
0115   std::vector<std::string> tempS;
0116   std::vector<double> tempD;
0117   bool ok = fv.firstChild();
0118   tempS = fv.get<std::vector<std::string> >(name2, "GeometryMode");
0119   if (tempS.empty()) {
0120     tempS = fv.get<std::vector<std::string> >(name, "GeometryMode");
0121   }
0122   std::string sv = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Hexagon8Full";
0123   HGCalGeometryMode::WaferMode mode(HGCalGeometryMode::Polyhedra);
0124 #ifdef EDM_ML_DEBUG
0125   edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode ";
0126 #endif
0127
0128   if (ok) {
0129     php.mode_ = HGCalGeometryMode::getGeometryMode(sv);
0130 #ifdef EDM_ML_DEBUG
0131     edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode " << php.mode_ << ":"
0132                                   << HGCalGeometryMode::Hexagon << ":" << HGCalGeometryMode::HexagonFull;
0133 #endif
0134     php.levelZSide_ = 3;    // Default level for ZSide
0135     php.detectorType_ = 0;  // These two parameters are
0136     php.useSimWt_ = 1;      // energy weighting for SimHits
0137     std::unique_ptr<HGCalTBGeomParameters> geom = std::make_unique<HGCalTBGeomParameters>();
0138     if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
0139       tempS = fv.get<std::vector<std::string> >(namet, "WaferMode");
0140       std::string sv2 = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Polyhedra";
0141       mode = HGCalGeometryMode::getGeometryWaferMode(sv2);
0142 #ifdef EDM_ML_DEBUG
0143       edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0144                                     << HGCalGeometryMode::ExtrudedPolygon;
0145 #endif
0146     }
0147     if (php.mode_ == HGCalGeometryMode::Hexagon) {
0148       // Load the SpecPars
0149       php.firstLayer_ = 1;
0150       geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0151       // Load the Geometry parameters
0152       geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0153       // Load cell parameters
0154       geom->loadCellParsHexagon(vmap, php);
0155       // Set complete fill mode
0156       php.defineFull_ = false;
0157     } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0158       // Load the SpecPars
0159       php.firstLayer_ = 1;
0160       geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0161       // Load the Geometry parameters
0162       geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0163       // Modify some constants
0164       geom->loadWaferHexagon(php);
0165       // Load cell parameters
0166       geom->loadCellParsHexagon(vmap, php);
0167       // Set complete fill mode
0168       php.defineFull_ = true;
0169     }
0170   } else {
0171     edm::LogError("HGCalGeom") << " Attribute Volume:" << name << " not found but needed.";
0172     throw cms::Exception("DDException") << "Attribute Volume:" << name << " not found but needed.";
0173   }
0174 #ifdef EDM_ML_DEBUG
0175   edm::LogVerbatim("HGCalGeom") << "Return from HGCalTBParametersFromDD::build"
0176                                 << " with flag " << ok;
0177 #endif
0178   return ok;
0179 }
0180
0181 double HGCalTBParametersFromDD::getDDDValue(const char* s, const DDsvalues_type& sv) {
0182   DDValue val(s);
0183   if (DDfetch(&sv, val)) {
0184     const std::vector<double>& fvec = val.doubles();
0185     if (fvec.empty()) {
0186       throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to get " << s << " tag.";
0187     }
0188     return fvec[0];
0189   } else {
0190     throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to fetch " << s << " tag";
0191   }
0192 }
0193
0194 std::vector<double> HGCalTBParametersFromDD::getDDDArray(const char* s, const DDsvalues_type& sv) {
0195   DDValue val(s);
0196   if (DDfetch(&sv, val)) {
0197     const std::vector<double>& fvec = val.doubles();
0198     if (fvec.empty()) {
0199       throw cms::Exception("HGCalGeom") << "getDDDArray::Failed to get " << s << " tag.";
0200     }
0201     return fvec;
0202   } else {
0203     throw cms::Exception("HGCalGeom") << "getDDDArray:Failed to fetch " << s << " tag";
0204   }
0205 }