File indexing completed on 2025-06-04 02:16:34
0001 #include "Geometry/HGCalCommonData/interface/HGCalParametersFromDD.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/HGCalGeomParameters.h"
0008 #include "Geometry/HGCalCommonData/interface/HGCalGeometryMode.h"
0009 #include "Geometry/HGCalCommonData/interface/HGCalParameters.h"
0010
0011
0012 using namespace geant_units::operators;
0013
0014 bool HGCalParametersFromDD::build(const DDCompactView* cpv,
0015 HGCalParameters& 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") << "HGCalParametersFromDD (DDD)::build called with "
0022 << "names " << name << ":" << namew << ":" << namec << ":" << namet;
0023 #endif
0024
0025
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 << HGCalGeometryMode::Hexagon8 << ":" << HGCalGeometryMode::Hexagon8Full << ":"
0043 << HGCalGeometryMode::Hexagon8File << ":" << HGCalGeometryMode::Hexagon8Module << ":"
0044 << HGCalGeometryMode::Trapezoid << ":" << HGCalGeometryMode::TrapezoidFile << ":"
0045 << HGCalGeometryMode::TrapezoidModule << ":" << HGCalGeometryMode::Hexagon8Cassette
0046 << ":" << HGCalGeometryMode::TrapezoidCassette << ":"
0047 << HGCalGeometryMode::Hexagon8CalibCell << ":" << HGCalGeometryMode::TrapezoidFineCell
0048 << ":" << HGCalGeometryMode::Hexagon8FineCell;
0049 #endif
0050 php.levelZSide_ = 3;
0051 php.detectorType_ = 0;
0052 php.firstMixedLayer_ = -1;
0053 php.useSimWt_ = 1;
0054 php.layerRotation_ = 0;
0055 php.cassettes_ = 0;
0056 php.nphiCassette_ = 0;
0057 php.phiOffset_ = 0;
0058 php.calibCellRHD_ = 0;
0059 php.calibCellRLD_ = 0;
0060 std::unique_ptr<HGCalGeomParameters> geom = std::make_unique<HGCalGeomParameters>();
0061 if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
0062 attribute = "OnlyForHGCalNumbering";
0063 value = namet;
0064 DDValue val2(attribute, value, 0.0);
0065 DDSpecificsMatchesValueFilter filter2{val2};
0066 DDFilteredView fv2(*cpv, filter2);
0067 bool ok2 = fv2.firstChild();
0068 if (ok2) {
0069 DDsvalues_type sv2(fv2.mergedSpecifics());
0070 mode = HGCalGeometryMode::getGeometryWaferMode("WaferMode", sv2);
0071 #ifdef EDM_ML_DEBUG
0072 edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0073 << HGCalGeometryMode::ExtrudedPolygon;
0074 #endif
0075 }
0076 php.minTileSize_ = 0;
0077 php.waferMaskMode_ = 0;
0078 php.waferZSide_ = 0;
0079 php.waferNoGap_ = 0;
0080 }
0081 if ((php.mode_ == HGCalGeometryMode::Hexagon8) || (php.mode_ == HGCalGeometryMode::Hexagon8Full) ||
0082 (php.mode_ == HGCalGeometryMode::Hexagon8File) || (php.mode_ == HGCalGeometryMode::Hexagon8Module) ||
0083 (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) || (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
0084 (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0085 php.levelT_ = dbl_to_int(getDDDArray("LevelTop", sv));
0086 php.levelZSide_ = static_cast<int>(getDDDValue("LevelZSide", sv));
0087 php.nCellsFine_ = php.nCellsCoarse_ = 0;
0088 php.firstLayer_ = 1;
0089 php.firstMixedLayer_ = static_cast<int>(getDDDValue("FirstMixedLayer", sv));
0090 php.detectorType_ = static_cast<int>(getDDDValue("DetectorType", sv));
0091 php.minTileSize_ = 0;
0092 php.waferMaskMode_ = static_cast<int>(getDDDValue("WaferMaskMode", sv));
0093 php.waferZSide_ = static_cast<int>(getDDDValue("WaferZside", sv));
0094 php.waferNoGap_ = static_cast<int>(getDDDValue("WaferNoGap", sv));
0095 if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) ||
0096 (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) || (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0097 php.useSimWt_ = static_cast<int>(getDDDValue("UseSimWt", sv));
0098 php.layerRotation_ = getDDDValue("LayerRotation", sv);
0099 }
0100 if ((php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteEE) ||
0101 (php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteHE))
0102 php.cassettes_ = getDDDValue("Cassettes", sv);
0103 #ifdef EDM_ML_DEBUG
0104 edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " ZSide Level "
0105 << php.levelZSide_ << " first layers " << php.firstLayer_ << ":"
0106 << php.firstMixedLayer_ << " Det Type " << php.detectorType_ << " Wafer Mask Mode "
0107 << php.waferMaskMode_ << " ZSide " << php.waferZSide_ << " Layer Rotation "
0108 << convertRadToDeg(php.layerRotation_) << " Cassettes " << php.cassettes_
0109 << " UseSimWt " << php.useSimWt_ << " WaferNoGap " << php.waferNoGap_;
0110 #endif
0111 attribute = "OnlyForHGCalNumbering";
0112 value = namet;
0113 DDValue val2(attribute, value, 0.0);
0114 DDSpecificsMatchesValueFilter filter2{val2};
0115 DDFilteredView fv2(*cpv, filter2);
0116 bool ok2 = fv2.firstChild();
0117 if (ok2) {
0118 DDsvalues_type sv2(fv2.mergedSpecifics());
0119 mode = HGCalGeometryMode::getGeometryWaferMode("WaferMode", sv2);
0120 php.nCellsFine_ = static_cast<int>(getDDDValue("NumberOfCellsFine", sv2));
0121 php.nCellsCoarse_ = static_cast<int>(getDDDValue("NumberOfCellsCoarse", sv2));
0122 php.waferSize_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferSize", sv2);
0123 php.waferSizeNominal_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferSizeNominal", sv2);
0124 php.waferThick_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferThickness", sv2);
0125 php.sensorSeparation_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("SensorSeparation", sv2);
0126 php.sensorSizeOffset_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("SensorSizeOffset", sv2);
0127 php.guardRingOffset_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("GuardRingOffset", sv2);
0128 php.mouseBite_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("MouseBite", sv2);
0129 php.useOffset_ = static_cast<int>(getDDDValue("UseOffset", sv2));
0130 php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
0131 assert(php.nCellsFine_ != 0);
0132 assert(php.nCellsCoarse_ != 0);
0133 php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
0134 php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
0135 #ifdef EDM_ML_DEBUG
0136 edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0137 << HGCalGeometryMode::ExtrudedPolygon << " # of cells|size for fine/coarse "
0138 << php.nCellsFine_ << ":" << php.cellSize_[0] << ":" << php.nCellsCoarse_ << ":"
0139 << php.cellSize_[1] << " wafer Params " << php.waferSize_ << ":" << php.waferR_
0140 << ":" << php.waferThick_ << ":" << php.sensorSeparation_ << ":"
0141 << php.sensorSizeOffset_ << ":" << php.guardRingOffset_ << ":" << php.mouseBite_
0142 << ":" << php.useOffset_ << ":" << php.waferR_;
0143 #endif
0144 for (int k = 0; k < 2; ++k)
0145 getCellPosition(php, k);
0146 }
0147 }
0148 if (php.mode_ == HGCalGeometryMode::Hexagon) {
0149
0150 php.firstLayer_ = 1;
0151 geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0152
0153 geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0154
0155 geom->loadCellParsHexagon(cpv, php);
0156
0157 php.defineFull_ = false;
0158 } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0159
0160 php.firstLayer_ = 1;
0161 geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0162
0163 geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0164
0165 geom->loadWaferHexagon(php);
0166
0167 geom->loadCellParsHexagon(cpv, php);
0168
0169 php.defineFull_ = true;
0170 } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
0171
0172 geom->loadSpecParsHexagon8(fv, php);
0173
0174 geom->loadGeometryHexagon8(fv, php, 1);
0175
0176 php.defineFull_ = false;
0177
0178 geom->loadWaferHexagon8(php);
0179 } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
0180
0181 geom->loadSpecParsHexagon8(fv, php);
0182
0183 geom->loadGeometryHexagon8(fv, php, 1);
0184
0185 php.defineFull_ = true;
0186
0187 geom->loadWaferHexagon8(php);
0188 } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) ||
0189 (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
0190 (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0191
0192 geom->loadSpecParsHexagon8(fv, php);
0193
0194 geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
0195
0196 php.defineFull_ = true;
0197
0198 geom->loadWaferHexagon8(php);
0199 } else if ((php.mode_ == HGCalGeometryMode::Trapezoid) || (php.mode_ == HGCalGeometryMode::TrapezoidFile) ||
0200 (php.mode_ == HGCalGeometryMode::TrapezoidModule) ||
0201 (php.mode_ == HGCalGeometryMode::TrapezoidCassette) ||
0202 (php.mode_ == HGCalGeometryMode::TrapezoidFineCell)) {
0203
0204 php.levelT_ = dbl_to_int(getDDDArray("LevelTop", sv));
0205 php.levelZSide_ = static_cast<int>(getDDDValue("LevelZSide", sv));
0206 php.firstLayer_ = (int)(getDDDValue("FirstLayer", sv));
0207 php.firstMixedLayer_ = (int)(getDDDValue("FirstMixedLayer", sv));
0208 php.detectorType_ = (int)(getDDDValue("DetectorType", sv));
0209 php.waferThick_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferThickness", sv);
0210 php.minTileSize_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("MinimumTileSize", sv);
0211 php.nCellsFine_ = php.nCellsCoarse_ = 0;
0212 php.waferSize_ = php.waferSizeNominal_ = php.waferR_ = 0;
0213 php.sensorSeparation_ = php.mouseBite_ = 0;
0214 php.sensorSizeOffset_ = php.guardRingOffset_ = php.useOffset_ = 0;
0215 php.waferMaskMode_ = static_cast<int>(getDDDValue("WaferMaskMode", sv));
0216 php.waferZSide_ = static_cast<int>(getDDDValue("WaferZside", sv));
0217 php.waferNoGap_ = static_cast<int>(getDDDValue("WaferNoGap", sv));
0218 if ((php.mode_ == HGCalGeometryMode::TrapezoidModule) || (php.mode_ == HGCalGeometryMode::TrapezoidCassette) ||
0219 (php.mode_ == HGCalGeometryMode::TrapezoidFineCell))
0220 php.useSimWt_ = static_cast<int>(getDDDValue("UseSimWt", sv));
0221 if ((php.waferMaskMode_ == HGCalGeomParameters::scintillatorCassette) ||
0222 (php.waferMaskMode_ == HGCalGeomParameters::scintillatorFineCell))
0223 php.cassettes_ = getDDDValue("Cassettes", sv);
0224 #ifdef EDM_ML_DEBUG
0225 edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " first layers "
0226 << php.firstLayer_ << ":" << php.firstMixedLayer_ << " Det Type "
0227 << php.detectorType_ << " thickenss " << php.waferThick_ << " Tile Mask Mode "
0228 << php.waferMaskMode_ << " Zside " << php.waferZSide_ << " Cassettes "
0229 << php.cassettes_ << " UseSimWt " << php.useSimWt_ << " WaferNoGap "
0230 << php.waferNoGap_;
0231 #endif
0232
0233 geom->loadSpecParsTrapezoid(fv, php);
0234
0235 geom->loadGeometryHexagon8(fv, php, php.firstLayer_);
0236
0237 geom->loadCellTrapezoid(php);
0238 } else {
0239 edm::LogError("HGCalGeom") << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew
0240 << ":" << namec;
0241 throw cms::Exception("DDException")
0242 << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew << ":" << namec;
0243 }
0244 } else {
0245 edm::LogError("HGCalGeom") << " Attribute " << val << " not found but needed.";
0246 throw cms::Exception("DDException") << "Attribute " << val << " not found but needed.";
0247 }
0248 #ifdef EDM_ML_DEBUG
0249 edm::LogVerbatim("HGCalGeom") << "Return from HGCalParametersFromDD::build"
0250 << " with flag " << ok;
0251 #endif
0252 return ok;
0253 }
0254
0255 bool HGCalParametersFromDD::build(const cms::DDCompactView* cpv,
0256 HGCalParameters& php,
0257 const std::string& name,
0258 const std::string& namew,
0259 const std::string& namec,
0260 const std::string& namet,
0261 const std::string& name2) {
0262 #ifdef EDM_ML_DEBUG
0263 edm::LogVerbatim("HGCalGeom") << "HGCalParametersFromDD (DD4hep)::build called with "
0264 << "names " << name << ":" << namew << ":" << namec << ":" << namet << ":" << name2;
0265 #endif
0266 cms::DDVectorsMap vmap = cpv->detector()->vectors();
0267 const cms::DDFilter filter("Volume", name);
0268 cms::DDFilteredView fv((*cpv), filter);
0269 std::vector<std::string> tempS;
0270 std::vector<double> tempD;
0271 bool ok = fv.firstChild();
0272 tempS = fv.get<std::vector<std::string> >(name2, "GeometryMode");
0273 if (tempS.empty()) {
0274 tempS = fv.get<std::vector<std::string> >(name, "GeometryMode");
0275 }
0276 std::string sv = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Hexagon8Full";
0277 HGCalGeometryMode::WaferMode mode(HGCalGeometryMode::Polyhedra);
0278 #ifdef EDM_ML_DEBUG
0279 edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode ";
0280 #endif
0281
0282 if (ok) {
0283 php.mode_ = HGCalGeometryMode::getGeometryMode(sv);
0284 #ifdef EDM_ML_DEBUG
0285 edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode " << php.mode_ << ":"
0286 << HGCalGeometryMode::Hexagon << ":" << HGCalGeometryMode::HexagonFull << ":"
0287 << HGCalGeometryMode::Hexagon8 << ":" << HGCalGeometryMode::Hexagon8Full << ":"
0288 << HGCalGeometryMode::Hexagon8File << ":" << HGCalGeometryMode::Hexagon8Module << ":"
0289 << HGCalGeometryMode::Trapezoid << ":" << HGCalGeometryMode::TrapezoidFile << ":"
0290 << HGCalGeometryMode::TrapezoidModule << ":" << HGCalGeometryMode::Hexagon8Cassette
0291 << ":" << HGCalGeometryMode::TrapezoidCassette << ":"
0292 << HGCalGeometryMode::Hexagon8CalibCell << ":" << HGCalGeometryMode::TrapezoidFineCell
0293 << ":" << HGCalGeometryMode::Hexagon8FineCell;
0294 #endif
0295 php.levelZSide_ = 3;
0296 php.detectorType_ = 0;
0297 php.firstMixedLayer_ = -1;
0298 php.useSimWt_ = 1;
0299 php.layerRotation_ = 0;
0300 php.cassettes_ = 0;
0301 php.nphiCassette_ = 0;
0302 php.phiOffset_ = 0;
0303 php.calibCellRHD_ = 0;
0304 php.calibCellRLD_ = 0;
0305 std::unique_ptr<HGCalGeomParameters> geom = std::make_unique<HGCalGeomParameters>();
0306 if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
0307 tempS = fv.get<std::vector<std::string> >(namet, "WaferMode");
0308 std::string sv2 = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Polyhedra";
0309 mode = HGCalGeometryMode::getGeometryWaferMode(sv2);
0310 #ifdef EDM_ML_DEBUG
0311 edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0312 << HGCalGeometryMode::ExtrudedPolygon;
0313 #endif
0314 php.minTileSize_ = 0;
0315 php.waferMaskMode_ = 0;
0316 php.waferZSide_ = 0;
0317 php.waferNoGap_ = 0;
0318 }
0319 if ((php.mode_ == HGCalGeometryMode::Hexagon8) || (php.mode_ == HGCalGeometryMode::Hexagon8Full) ||
0320 (php.mode_ == HGCalGeometryMode::Hexagon8File) || (php.mode_ == HGCalGeometryMode::Hexagon8Module) ||
0321 (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) || (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
0322 (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0323 php.levelT_ = dbl_to_int(fv.get<std::vector<double> >(name, "LevelTop"));
0324 tempD = fv.get<std::vector<double> >(name, "LevelZSide");
0325 php.levelZSide_ = static_cast<int>(tempD[0]);
0326 php.nCellsFine_ = php.nCellsCoarse_ = 0;
0327 php.firstLayer_ = 1;
0328 tempD = fv.get<std::vector<double> >(name, "FirstMixedLayer");
0329 php.firstMixedLayer_ = static_cast<int>(tempD[0]);
0330 tempD = fv.get<std::vector<double> >(name, "DetectorType");
0331 php.detectorType_ = static_cast<int>(tempD[0]);
0332 php.minTileSize_ = 0;
0333 tempD = fv.get<std::vector<double> >(name, "WaferMaskMode");
0334 php.waferMaskMode_ = static_cast<int>(tempD[0]);
0335 tempD = fv.get<std::vector<double> >(name, "WaferZside");
0336 php.waferZSide_ = static_cast<int>(tempD[0]);
0337 tempD = fv.get<std::vector<double> >(name, "WaferNoGap");
0338 php.waferNoGap_ = static_cast<int>(tempD[0]);
0339 if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) ||
0340 (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) || (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0341 tempD = fv.get<std::vector<double> >(name, "LayerRotation");
0342 php.layerRotation_ = tempD[0];
0343 tempD = fv.get<std::vector<double> >(name, "UseSimWt");
0344 php.useSimWt_ = tempD[0];
0345 }
0346 if ((php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteEE) ||
0347 (php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteHE)) {
0348 tempD = fv.get<std::vector<double> >(name, "Cassettes");
0349 php.cassettes_ = static_cast<int>(tempD[0]);
0350 }
0351 #ifdef EDM_ML_DEBUG
0352 edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " ZSide Level "
0353 << php.levelZSide_ << " first layers " << php.firstLayer_ << ":"
0354 << php.firstMixedLayer_ << " Det Type " << php.detectorType_ << " Wafer Mask Mode "
0355 << php.waferMaskMode_ << " ZSide " << php.waferZSide_ << " Layer Rotation "
0356 << convertRadToDeg(php.layerRotation_) << " Cassettes " << php.cassettes_
0357 << " UseSimWt " << php.useSimWt_ << " WaferNoGap " << php.waferNoGap_;
0358 #endif
0359
0360 tempS = fv.get<std::vector<std::string> >(namet, "WaferMode");
0361 std::string sv2 = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::ExtrudedPolygon";
0362 mode = HGCalGeometryMode::getGeometryWaferMode(sv2);
0363 tempD = fv.get<std::vector<double> >(namet, "NumberOfCellsFine");
0364 php.nCellsFine_ = static_cast<int>(tempD[0]);
0365 tempD = fv.get<std::vector<double> >(namet, "NumberOfCellsCoarse");
0366 php.nCellsCoarse_ = static_cast<int>(tempD[0]);
0367 tempD = fv.get<std::vector<double> >(namet, "WaferSize");
0368 php.waferSize_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0369 tempD = fv.get<std::vector<double> >(namet, "WaferSizeNominal");
0370 php.waferSizeNominal_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0371 tempD = fv.get<std::vector<double> >(namet, "WaferThickness");
0372 php.waferThick_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0373 tempD = fv.get<std::vector<double> >(namet, "SensorSeparation");
0374 php.sensorSeparation_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0375 tempD = fv.get<std::vector<double> >(namet, "SensorSizeOffset");
0376 php.sensorSizeOffset_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0377 tempD = fv.get<std::vector<double> >(namet, "GuardRingOffset");
0378 php.guardRingOffset_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0379 tempD = fv.get<std::vector<double> >(namet, "MouseBite");
0380 php.mouseBite_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0381 tempD = fv.get<std::vector<double> >(namet, "UseOffset");
0382 php.useOffset_ = static_cast<int>(tempD[0]);
0383 php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
0384 assert(php.nCellsFine_ != 0);
0385 assert(php.nCellsCoarse_ != 0);
0386 php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
0387 php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
0388 #ifdef EDM_ML_DEBUG
0389 edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
0390 << HGCalGeometryMode::ExtrudedPolygon << " # of cells|size for fine/coarse "
0391 << php.nCellsFine_ << ":" << php.cellSize_[0] << ":" << php.nCellsCoarse_ << ":"
0392 << php.cellSize_[1] << " wafer Params " << php.waferSize_ << ":" << php.waferR_
0393 << ":" << php.waferThick_ << ":" << php.sensorSeparation_ << ":"
0394 << php.sensorSizeOffset_ << ":" << php.guardRingOffset_ << ":" << php.mouseBite_
0395 << ":" << php.useOffset_ << ":" << php.waferR_;
0396 #endif
0397 for (int k = 0; k < 2; ++k)
0398 getCellPosition(php, k);
0399 }
0400 if (php.mode_ == HGCalGeometryMode::Hexagon) {
0401
0402 php.firstLayer_ = 1;
0403 geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0404
0405 geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0406
0407 geom->loadCellParsHexagon(vmap, php);
0408
0409 php.defineFull_ = false;
0410 } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0411
0412 php.firstLayer_ = 1;
0413 geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0414
0415 geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0416
0417 geom->loadWaferHexagon(php);
0418
0419 geom->loadCellParsHexagon(vmap, php);
0420
0421 php.defineFull_ = true;
0422 } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
0423
0424 geom->loadSpecParsHexagon8(fv, vmap, php, name);
0425
0426 geom->loadGeometryHexagon8(cpv, php, name, 1);
0427
0428 php.defineFull_ = false;
0429
0430 geom->loadWaferHexagon8(php);
0431 } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
0432
0433 geom->loadSpecParsHexagon8(fv, vmap, php, name);
0434
0435 geom->loadGeometryHexagon8(cpv, php, name, 1);
0436
0437 php.defineFull_ = true;
0438
0439 geom->loadWaferHexagon8(php);
0440 } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette) ||
0441 (php.mode_ == HGCalGeometryMode::Hexagon8CalibCell) ||
0442 (php.mode_ == HGCalGeometryMode::Hexagon8FineCell)) {
0443
0444 geom->loadSpecParsHexagon8(fv, vmap, php, name);
0445
0446 geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
0447
0448 php.defineFull_ = true;
0449
0450 geom->loadWaferHexagon8(php);
0451 } else if ((php.mode_ == HGCalGeometryMode::Trapezoid) || (php.mode_ == HGCalGeometryMode::TrapezoidFile) ||
0452 (php.mode_ == HGCalGeometryMode::TrapezoidModule) ||
0453 (php.mode_ == HGCalGeometryMode::TrapezoidCassette) ||
0454 (php.mode_ == HGCalGeometryMode::TrapezoidFineCell)) {
0455
0456 php.levelT_ = dbl_to_int(fv.get<std::vector<double> >(name, "LevelTop"));
0457 tempD = fv.get<std::vector<double> >(name, "LevelZSide");
0458 php.levelZSide_ = static_cast<int>(tempD[0]);
0459 tempD = fv.get<std::vector<double> >(name, "FirstLayer");
0460 php.firstLayer_ = static_cast<int>(tempD[0]);
0461 tempD = fv.get<std::vector<double> >(name, "FirstMixedLayer");
0462 php.firstMixedLayer_ = static_cast<int>(tempD[0]);
0463 tempD = fv.get<std::vector<double> >(name, "DetectorType");
0464 php.detectorType_ = static_cast<int>(tempD[0]);
0465 tempD = fv.get<std::vector<double> >(name, "WaferThickness");
0466 php.waferThick_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0467 tempD = fv.get<std::vector<double> >(name, "MinimumTileSize");
0468 php.minTileSize_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
0469 php.nCellsFine_ = php.nCellsCoarse_ = 0;
0470 php.waferSize_ = php.waferSizeNominal_ = php.waferR_ = 0;
0471 php.sensorSeparation_ = php.mouseBite_ = 0;
0472 php.sensorSizeOffset_ = php.guardRingOffset_ = php.useOffset_ = 0;
0473 tempD = fv.get<std::vector<double> >(name, "WaferMaskMode");
0474 php.waferMaskMode_ = static_cast<int>(tempD[0]);
0475 tempD = fv.get<std::vector<double> >(name, "WaferZside");
0476 php.waferZSide_ = static_cast<int>(tempD[0]);
0477 tempD = fv.get<std::vector<double> >(name, "WaferNoGap");
0478 php.waferNoGap_ = static_cast<int>(tempD[0]);
0479 if ((php.mode_ == HGCalGeometryMode::TrapezoidModule) || (php.mode_ == HGCalGeometryMode::TrapezoidCassette) ||
0480 (php.mode_ == HGCalGeometryMode::TrapezoidFineCell)) {
0481 tempD = fv.get<std::vector<double> >(name, "UseSimWt");
0482 php.useSimWt_ = tempD[0];
0483 }
0484 if ((php.waferMaskMode_ == HGCalGeomParameters::scintillatorCassette) ||
0485 (php.waferMaskMode_ == HGCalGeomParameters::scintillatorFineCell)) {
0486 tempD = fv.get<std::vector<double> >(name, "Cassettes");
0487 php.cassettes_ = static_cast<int>(tempD[0]);
0488 }
0489 #ifdef EDM_ML_DEBUG
0490 edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " first layers "
0491 << php.firstLayer_ << ":" << php.firstMixedLayer_ << " Det Type "
0492 << php.detectorType_ << " thickenss " << php.waferThick_ << " min tile size "
0493 << php.minTileSize_ << " Tile Mask Mode " << php.waferMaskMode_ << " ZSide "
0494 << php.waferZSide_ << " Cassettes " << php.cassettes_ << " UseSimWt "
0495 << php.useSimWt_ << " WaferNoGap " << php.waferNoGap_;
0496 #endif
0497
0498 geom->loadSpecParsTrapezoid(fv, vmap, php, name);
0499
0500 geom->loadGeometryHexagon8(cpv, php, name, php.firstLayer_);
0501
0502 geom->loadCellTrapezoid(php);
0503 } else {
0504 edm::LogError("HGCalGeom") << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew
0505 << ":" << namec;
0506 throw cms::Exception("DDException")
0507 << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew << ":" << namec;
0508 }
0509 } else {
0510 edm::LogError("HGCalGeom") << " Attribute Volume:" << name << " not found but needed.";
0511 throw cms::Exception("DDException") << "Attribute Volume:" << name << " not found but needed.";
0512 }
0513 #ifdef EDM_ML_DEBUG
0514 edm::LogVerbatim("HGCalGeom") << "Return from HGCalParametersFromDD::build"
0515 << " with flag " << ok;
0516 #endif
0517 return ok;
0518 }
0519
0520 void HGCalParametersFromDD::getCellPosition(HGCalParameters& php, int type) {
0521 if (type == 1) {
0522 php.cellCoarseX_.clear();
0523 php.cellCoarseY_.clear();
0524 } else {
0525 php.cellFineX_.clear();
0526 php.cellFineY_.clear();
0527 }
0528 HGCalParameters::wafer_map cellIndex;
0529 #ifdef EDM_ML_DEBUG
0530 std::vector<int> indtypes;
0531 #endif
0532 int N = (type == 1) ? php.nCellsCoarse_ : php.nCellsFine_;
0533 assert(N != 0);
0534 double R = php.waferSize_ / (3 * N);
0535 double r = 0.5 * R * sqrt(3.0);
0536 int n2 = N / 2;
0537 int ipos(0);
0538 for (int u = 0; u < 2 * N; ++u) {
0539 for (int v = 0; v < 2 * N; ++v) {
0540 if (((v - u) < N) && (u - v) <= N) {
0541 double yp = (u - 0.5 * v - n2) * 2 * r;
0542 double xp = (1.5 * (v - N) + 1.0) * R;
0543 int id = v * 100 + u;
0544 #ifdef EDM_ML_DEBUG
0545 indtypes.emplace_back(id);
0546 #endif
0547 if (type == 1) {
0548 php.cellCoarseX_.emplace_back(xp);
0549 php.cellCoarseY_.emplace_back(yp);
0550 } else {
0551 php.cellFineX_.emplace_back(xp);
0552 php.cellFineY_.emplace_back(yp);
0553 }
0554 cellIndex[id] = ipos;
0555 ++ipos;
0556 }
0557 }
0558 }
0559 if (type == 1)
0560 php.cellCoarseIndex_ = cellIndex;
0561 else
0562 php.cellFineIndex_ = cellIndex;
0563
0564 #ifdef EDM_ML_DEBUG
0565 if (type == 1) {
0566 edm::LogVerbatim("HGCalGeom") << "CellPosition for type " << type << " for " << php.cellCoarseX_.size()
0567 << " cells";
0568 for (unsigned int k = 0; k < php.cellCoarseX_.size(); ++k) {
0569 int id = indtypes[k];
0570 edm::LogVerbatim("HGCalGeom") << "[" << k << "] ID " << id << ":" << php.cellCoarseIndex_[id] << " X "
0571 << php.cellCoarseX_[k] << " Y " << php.cellCoarseY_[k];
0572 }
0573 } else {
0574 edm::LogVerbatim("HGCalGeom") << "CellPosition for type " << type << " for " << php.cellFineX_.size() << " cells";
0575 for (unsigned int k = 0; k < php.cellFineX_.size(); ++k) {
0576 int id = indtypes[k];
0577 edm::LogVerbatim("HGCalGeom") << "[" << k << "] ID " << id << ":" << php.cellFineIndex_[k] << " X "
0578 << php.cellFineX_[k] << " Y " << php.cellFineY_[k];
0579 }
0580 }
0581 #endif
0582 }
0583
0584 double HGCalParametersFromDD::getDDDValue(const char* s, const DDsvalues_type& sv) {
0585 DDValue val(s);
0586 if (DDfetch(&sv, val)) {
0587 const std::vector<double>& fvec = val.doubles();
0588 if (fvec.empty()) {
0589 throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to get " << s << " tag.";
0590 }
0591 return fvec[0];
0592 } else {
0593 throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to fetch " << s << " tag";
0594 }
0595 }
0596
0597 std::vector<double> HGCalParametersFromDD::getDDDArray(const char* s, const DDsvalues_type& sv) {
0598 DDValue val(s);
0599 if (DDfetch(&sv, val)) {
0600 const std::vector<double>& fvec = val.doubles();
0601 if (fvec.empty()) {
0602 throw cms::Exception("HGCalGeom") << "getDDDArray::Failed to get " << s << " tag.";
0603 }
0604 return fvec;
0605 } else {
0606 throw cms::Exception("HGCalGeom") << "getDDDArray:Failed to fetch " << s << " tag";
0607 }
0608 }