Back to home page

Project CMSSW displayed by LXR
 
 

    

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 //#define EDM_ML_DEBUG
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   // 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                                   << 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;        // Default level for ZSide
0051     php.detectorType_ = 0;      // These two parameters are
0052     php.firstMixedLayer_ = -1;  // defined for post TDR geometry
0053     php.useSimWt_ = 1;          // energy weighting for SimHits
0054     php.layerRotation_ = 0;     // default layer rotation angle
0055     php.cassettes_ = 0;         // default number of cassettes
0056     php.nphiCassette_ = 0;      // default number of phi's per cassette
0057     php.phiOffset_ = 0;         // default value of phi offset for cassette
0058     php.calibCellRHD_ = 0;      // default value of R of HD calibration cells
0059     php.calibCellRLD_ = 0;      // default value of R of LD calibration cells
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       // Load the SpecPars
0150       php.firstLayer_ = 1;
0151       geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0152       // Load the Geometry parameters
0153       geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0154       // Load cell parameters
0155       geom->loadCellParsHexagon(cpv, php);
0156       // Set complete fill mode
0157       php.defineFull_ = false;
0158     } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0159       // Load the SpecPars
0160       php.firstLayer_ = 1;
0161       geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
0162       // Load the Geometry parameters
0163       geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
0164       // Modify some constants
0165       geom->loadWaferHexagon(php);
0166       // Load cell parameters
0167       geom->loadCellParsHexagon(cpv, php);
0168       // Set complete fill mode
0169       php.defineFull_ = true;
0170     } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
0171       // Load the SpecPars
0172       geom->loadSpecParsHexagon8(fv, php);
0173       // Load Geometry parameters
0174       geom->loadGeometryHexagon8(fv, php, 1);
0175       // Set complete fill mode
0176       php.defineFull_ = false;
0177       // Load wafer positions
0178       geom->loadWaferHexagon8(php);
0179     } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
0180       // Load the SpecPars
0181       geom->loadSpecParsHexagon8(fv, php);
0182       // Load Geometry parameters
0183       geom->loadGeometryHexagon8(fv, php, 1);
0184       // Set complete fill mode
0185       php.defineFull_ = true;
0186       // Load wafer positions
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       // Load the SpecPars
0192       geom->loadSpecParsHexagon8(fv, php);
0193       // Load Geometry parameters
0194       geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
0195       // Set complete fill mode
0196       php.defineFull_ = true;
0197       // Load wafer positions
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       // Load maximum eta & top level
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       // Load the SpecPars
0233       geom->loadSpecParsTrapezoid(fv, php);
0234       // Load Geometry parameters
0235       geom->loadGeometryHexagon8(fv, php, php.firstLayer_);
0236       // Load cell positions
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;        // Default level for ZSide
0296     php.detectorType_ = 0;      // These two parameters are
0297     php.firstMixedLayer_ = -1;  // defined for post TDR geometry
0298     php.useSimWt_ = 1;          // energy weighting for SimHits
0299     php.layerRotation_ = 0;     // default layer rotation angle
0300     php.cassettes_ = 0;         // default number of cassettes
0301     php.nphiCassette_ = 0;      // default number of phi's per cassette
0302     php.phiOffset_ = 0;         // default value of phi offset for cassette
0303     php.calibCellRHD_ = 0;      // default value of R of HD calibration cells
0304     php.calibCellRLD_ = 0;      // default value of R of LD calibration cells
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       // Load the SpecPars
0402       php.firstLayer_ = 1;
0403       geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0404       // Load the Geometry parameters
0405       geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0406       // Load cell parameters
0407       geom->loadCellParsHexagon(vmap, php);
0408       // Set complete fill mode
0409       php.defineFull_ = false;
0410     } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
0411       // Load the SpecPars
0412       php.firstLayer_ = 1;
0413       geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
0414       // Load the Geometry parameters
0415       geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
0416       // Modify some constants
0417       geom->loadWaferHexagon(php);
0418       // Load cell parameters
0419       geom->loadCellParsHexagon(vmap, php);
0420       // Set complete fill mode
0421       php.defineFull_ = true;
0422     } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
0423       // Load the SpecPars
0424       geom->loadSpecParsHexagon8(fv, vmap, php, name);
0425       // Load Geometry parameters
0426       geom->loadGeometryHexagon8(cpv, php, name, 1);
0427       // Set complete fill mode
0428       php.defineFull_ = false;
0429       // Load wafer positions
0430       geom->loadWaferHexagon8(php);
0431     } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
0432       // Load the SpecPars
0433       geom->loadSpecParsHexagon8(fv, vmap, php, name);
0434       // Load Geometry parameters
0435       geom->loadGeometryHexagon8(cpv, php, name, 1);
0436       // Set complete fill mode
0437       php.defineFull_ = true;
0438       // Load wafer positions
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       // Load the SpecPars
0444       geom->loadSpecParsHexagon8(fv, vmap, php, name);
0445       // Load Geometry parameters
0446       geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
0447       // Set complete fill mode
0448       php.defineFull_ = true;
0449       // Load wafer positions
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       // Load maximum eta & top level
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       // Load the SpecPars
0498       geom->loadSpecParsTrapezoid(fv, vmap, php, name);
0499       // Load Geometry parameters
0500       geom->loadGeometryHexagon8(cpv, php, name, php.firstLayer_);
0501       // Load cell positions
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 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!