Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-08-06 22:36:38 

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