Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-07-24 04:44:56 

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