CMS 3D CMS Logo
HGCalParametersFromDD.cc
Go to the documentation of this file.
1 #include "Geometry/HGCalCommonData/interface/HGCalParametersFromDD.h"
2 
3 #include "DataFormats/Math/interface/GeantUnits.h"
4 #include "DetectorDescription/Core/interface/DDFilteredView.h"
5 #include "DetectorDescription/Core/interface/DDutils.h"
6 #include "DetectorDescription/DDCMS/interface/DDFilteredView.h"
7 #include "Geometry/HGCalCommonData/interface/HGCalGeomParameters.h"
8 #include "Geometry/HGCalCommonData/interface/HGCalGeometryMode.h"
9 #include "Geometry/HGCalCommonData/interface/HGCalParameters.h"
10 
11 //#define EDM_ML_DEBUG
12 using namespace geant_units::operators;
13 
14 bool HGCalParametersFromDD::build(const DDCompactView* cpv,
15  HGCalParameters& php,
16  const std::string& name,
17  const std::string& namew,
18  const std::string& namec,
19  const std::string& namet) {
20 #ifdef EDM_ML_DEBUG
21  edm::LogVerbatim("HGCalGeom") << "HGCalParametersFromDD (DDD)::build called with "
22  << "names " << name << ":" << namew << ":" << namec << ":" << namet;
23 #endif
24 
25  // Special parameters at simulation level
26  std::string attribute = "Volume";
27  std::string value = name;
28  DDValue val(attribute, value, 0.0);
29  DDSpecificsMatchesValueFilter filter{val};
30  DDFilteredView fv(*cpv, filter);
31  bool ok = fv.firstChild();
32  HGCalGeometryMode::WaferMode mode(HGCalGeometryMode::Polyhedra);
33 #ifdef EDM_ML_DEBUG
34  edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode ";
35 #endif
36  if (ok) {
37  DDsvalues_type sv(fv.mergedSpecifics());
38  php.mode_ = HGCalGeometryMode::getGeometryMode("GeometryMode", sv);
39 #ifdef EDM_ML_DEBUG
40  edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode " << php.mode_ << ":"
41  << HGCalGeometryMode::Hexagon << ":" << HGCalGeometryMode::HexagonFull << ":"
42  << HGCalGeometryMode::Hexagon8 << ":" << HGCalGeometryMode::Hexagon8Full << ":"
43  << HGCalGeometryMode::Hexagon8File << ":" << HGCalGeometryMode::Hexagon8Module << ":"
44  << HGCalGeometryMode::Trapezoid << ":" << HGCalGeometryMode::TrapezoidFile << ":"
45  << HGCalGeometryMode::TrapezoidModule;
46 #endif
47  php.levelZSide_ = 3; // Default level for ZSide
48  php.detectorType_ = 0; // These two parameters are
49  php.firstMixedLayer_ = -1; // defined for post TDR geometry
50  php.useSimWt_ = 1; // energy weighting for SimHits
51  php.layerRotation_ = 0; // default layer rotation angle
52  php.cassettes_ = 0; // default number of cassettes
53  php.nphiCassette_ = 0; // default number of phi's per cassette
54  php.phiOffset_ = 0; // default value of phi offset for cassette
55  std::unique_ptr<HGCalGeomParameters> geom = std::make_unique<HGCalGeomParameters>();
56  if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
57  attribute = "OnlyForHGCalNumbering";
58  value = namet;
59  DDValue val2(attribute, value, 0.0);
60  DDSpecificsMatchesValueFilter filter2{val2};
61  DDFilteredView fv2(*cpv, filter2);
62  bool ok2 = fv2.firstChild();
63  if (ok2) {
64  DDsvalues_type sv2(fv2.mergedSpecifics());
65  mode = HGCalGeometryMode::getGeometryWaferMode("WaferMode", sv2);
66 #ifdef EDM_ML_DEBUG
67  edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
68  << HGCalGeometryMode::ExtrudedPolygon;
69 #endif
70  }
71  php.minTileSize_ = 0;
72  php.waferMaskMode_ = 0;
73  php.waferZSide_ = 0;
74  }
75  if ((php.mode_ == HGCalGeometryMode::Hexagon8) || (php.mode_ == HGCalGeometryMode::Hexagon8Full) ||
76  (php.mode_ == HGCalGeometryMode::Hexagon8File) || (php.mode_ == HGCalGeometryMode::Hexagon8Module) ||
77  (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
78  php.levelT_ = dbl_to_int(getDDDArray("LevelTop", sv));
79  php.levelZSide_ = static_cast<int>(getDDDValue("LevelZSide", sv));
80  php.nCellsFine_ = php.nCellsCoarse_ = 0;
81  php.firstLayer_ = 1;
82  php.firstMixedLayer_ = static_cast<int>(getDDDValue("FirstMixedLayer", sv));
83  php.detectorType_ = static_cast<int>(getDDDValue("DetectorType", sv));
84  php.minTileSize_ = 0;
85  php.waferMaskMode_ = static_cast<int>(getDDDValue("WaferMaskMode", sv));
86  php.waferZSide_ = static_cast<int>(getDDDValue("WaferZside", sv));
87  if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
88  php.useSimWt_ = static_cast<int>(getDDDValue("UseSimWt", sv));
89  php.layerRotation_ = getDDDValue("LayerRotation", sv);
90  }
91  if ((php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteEE) ||
92  (php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteHE))
93  php.cassettes_ = getDDDValue("Cassettes", sv);
94 #ifdef EDM_ML_DEBUG
95  edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " ZSide Level "
96  << php.levelZSide_ << " first layers " << php.firstLayer_ << ":"
97  << php.firstMixedLayer_ << " Det Type " << php.detectorType_ << " Wafer Mask Mode "
98  << php.waferMaskMode_ << " Zside " << php.waferZSide_ << " Layer Rotation "
99  << convertRadToDeg(php.layerRotation_) << " Cassettes " << php.cassettes_
100  << " UseSimWt " << php.useSimWt_;
101 #endif
102  attribute = "OnlyForHGCalNumbering";
103  value = namet;
104  DDValue val2(attribute, value, 0.0);
105  DDSpecificsMatchesValueFilter filter2{val2};
106  DDFilteredView fv2(*cpv, filter2);
107  bool ok2 = fv2.firstChild();
108  if (ok2) {
109  DDsvalues_type sv2(fv2.mergedSpecifics());
110  mode = HGCalGeometryMode::getGeometryWaferMode("WaferMode", sv2);
111  php.nCellsFine_ = static_cast<int>(getDDDValue("NumberOfCellsFine", sv2));
112  php.nCellsCoarse_ = static_cast<int>(getDDDValue("NumberOfCellsCoarse", sv2));
113  php.waferSize_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferSize", sv2);
114  php.waferThick_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferThickness", sv2);
115  php.sensorSeparation_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("SensorSeparation", sv2);
116  php.sensorSizeOffset_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("SensorSizeOffset", sv2);
117  php.guardRingOffset_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("GuardRingOffset", sv2);
118  php.mouseBite_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("MouseBite", sv2);
119  php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
120  php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
121  php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
122 #ifdef EDM_ML_DEBUG
123  edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
124  << HGCalGeometryMode::ExtrudedPolygon << " # of cells|size for fine/coarse "
125  << php.nCellsFine_ << ":" << php.cellSize_[0] << ":" << php.nCellsCoarse_ << ":"
126  << php.cellSize_[1] << " wafer Params " << php.waferSize_ << ":" << php.waferR_
127  << ":" << php.waferThick_ << ":" << php.sensorSeparation_ << ":"
128  << php.sensorSizeOffset_ << ":" << php.guardRingOffset_ << ":" << php.mouseBite_
129  << ":" << php.waferR_;
130 #endif
131  for (int k = 0; k < 2; ++k)
132  getCellPosition(php, k);
133  }
134  }
135  if (php.mode_ == HGCalGeometryMode::Hexagon) {
136  // Load the SpecPars
137  php.firstLayer_ = 1;
138  geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
139  // Load the Geometry parameters
140  geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
141  // Load cell parameters
142  geom->loadCellParsHexagon(cpv, php);
143  // Set complete fill mode
144  php.defineFull_ = false;
145  } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
146  // Load the SpecPars
147  php.firstLayer_ = 1;
148  geom->loadSpecParsHexagon(fv, php, cpv, namew, namec);
149  // Load the Geometry parameters
150  geom->loadGeometryHexagon(fv, php, name, cpv, namew, namec, mode);
151  // Modify some constants
152  geom->loadWaferHexagon(php);
153  // Load cell parameters
154  geom->loadCellParsHexagon(cpv, php);
155  // Set complete fill mode
156  php.defineFull_ = true;
157  } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
158  // Load the SpecPars
159  geom->loadSpecParsHexagon8(fv, php);
160  // Load Geometry parameters
161  geom->loadGeometryHexagon8(fv, php, 1);
162  // Set complete fill mode
163  php.defineFull_ = false;
164  // Load wafer positions
165  geom->loadWaferHexagon8(php);
166  } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
167  // Load the SpecPars
168  geom->loadSpecParsHexagon8(fv, php);
169  // Load Geometry parameters
170  geom->loadGeometryHexagon8(fv, php, 1);
171  // Set complete fill mode
172  php.defineFull_ = true;
173  // Load wafer positions
174  geom->loadWaferHexagon8(php);
175  } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
176  // Load the SpecPars
177  geom->loadSpecParsHexagon8(fv, php);
178  // Load Geometry parameters
179  geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
180  // Set complete fill mode
181  php.defineFull_ = true;
182  // Load wafer positions
183  geom->loadWaferHexagon8(php);
184  } else if ((php.mode_ == HGCalGeometryMode::Trapezoid) || (php.mode_ == HGCalGeometryMode::TrapezoidFile) ||
185  (php.mode_ == HGCalGeometryMode::TrapezoidModule) ||
186  (php.mode_ == HGCalGeometryMode::TrapezoidCassette)) {
187  // Load maximum eta & top level
188  php.levelT_ = dbl_to_int(getDDDArray("LevelTop", sv));
189  php.firstLayer_ = (int)(getDDDValue("FirstLayer", sv));
190  php.firstMixedLayer_ = (int)(getDDDValue("FirstMixedLayer", sv));
191  php.detectorType_ = (int)(getDDDValue("DetectorType", sv));
192  php.waferThick_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("WaferThickness", sv);
193  php.minTileSize_ = HGCalParameters::k_ScaleFromDDD * getDDDValue("MinimumTileSize", sv);
194  php.waferSize_ = php.waferR_ = 0;
195  php.sensorSeparation_ = php.mouseBite_ = 0;
196  php.sensorSizeOffset_ = php.guardRingOffset_ = 0;
197  php.waferMaskMode_ = static_cast<int>(getDDDValue("WaferMaskMode", sv));
198  php.waferZSide_ = static_cast<int>(getDDDValue("WaferZside", sv));
199  if ((php.mode_ == HGCalGeometryMode::TrapezoidModule) || (php.mode_ == HGCalGeometryMode::TrapezoidCassette))
200  php.useSimWt_ = static_cast<int>(getDDDValue("UseSimWt", sv));
201  if (php.waferMaskMode_ == HGCalGeomParameters::scintillatorCassette)
202  php.cassettes_ = getDDDValue("Cassettes", sv);
203 #ifdef EDM_ML_DEBUG
204  edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " first layers "
205  << php.firstLayer_ << ":" << php.firstMixedLayer_ << " Det Type "
206  << php.detectorType_ << " thickenss " << php.waferThick_ << " Tile Mask Mode "
207  << php.waferMaskMode_ << " Zside " << php.waferZSide_ << " Cassettes "
208  << php.cassettes_ << " UseSimWt " << php.useSimWt_;
209 #endif
210  // Load the SpecPars
211  geom->loadSpecParsTrapezoid(fv, php);
212  // Load Geometry parameters
213  geom->loadGeometryHexagon8(fv, php, php.firstLayer_);
214  // Load cell positions
215  geom->loadCellTrapezoid(php);
216  } else {
217  edm::LogError("HGCalGeom") << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew
218  << ":" << namec;
219  throw cms::Exception("DDException")
220  << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew << ":" << namec;
221  }
222  } else {
223  edm::LogError("HGCalGeom") << " Attribute " << val << " not found but needed.";
224  throw cms::Exception("DDException") << "Attribute " << val << " not found but needed.";
225  }
226 #ifdef EDM_ML_DEBUG
227  edm::LogVerbatim("HGCalGeom") << "Return from HGCalParametersFromDD::build"
228  << " with flag " << ok;
229 #endif
230  return ok;
231 }
232 
233 bool HGCalParametersFromDD::build(const cms::DDCompactView* cpv,
234  HGCalParameters& php,
235  const std::string& name,
236  const std::string& namew,
237  const std::string& namec,
238  const std::string& namet,
239  const std::string& name2) {
240 #ifdef EDM_ML_DEBUG
241  edm::LogVerbatim("HGCalGeom") << "HGCalParametersFromDD (DD4hep)::build called with "
242  << "names " << name << ":" << namew << ":" << namec << ":" << namet << ":" << name2;
243 #endif
244  cms::DDVectorsMap vmap = cpv->detector()->vectors();
245  const cms::DDFilter filter("Volume", name);
246  cms::DDFilteredView fv((*cpv), filter);
247  std::vector<std::string> tempS;
248  std::vector<double> tempD;
249  bool ok = fv.firstChild();
250  tempS = fv.get<std::vector<std::string> >(name2, "GeometryMode");
251  if (tempS.empty()) {
252  tempS = fv.get<std::vector<std::string> >(name, "GeometryMode");
253  }
254  std::string sv = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Hexagon8Full";
255  HGCalGeometryMode::WaferMode mode(HGCalGeometryMode::Polyhedra);
256 #ifdef EDM_ML_DEBUG
257  edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode ";
258 #endif
259 
260  if (ok) {
261  php.mode_ = HGCalGeometryMode::getGeometryMode(sv);
262 #ifdef EDM_ML_DEBUG
263  edm::LogVerbatim("HGCalGeom") << "Volume " << name << " GeometryMode " << php.mode_ << ":"
264  << HGCalGeometryMode::Hexagon << ":" << HGCalGeometryMode::HexagonFull << ":"
265  << HGCalGeometryMode::Hexagon8 << ":" << HGCalGeometryMode::Hexagon8Full << ":"
266  << HGCalGeometryMode::Hexagon8File << ":" << HGCalGeometryMode::Hexagon8Module << ":"
267  << HGCalGeometryMode::Trapezoid << ":" << HGCalGeometryMode::TrapezoidFile << ":"
268  << HGCalGeometryMode::TrapezoidModule << ":" << HGCalGeometryMode::Hexagon8Cassette
269  << ":" << HGCalGeometryMode::TrapezoidCassette;
270 #endif
271  php.levelZSide_ = 3; // Default level for ZSide
272  php.detectorType_ = 0; // These two parameters are
273  php.firstMixedLayer_ = -1; // defined for post TDR geometry
274  php.useSimWt_ = 1; // energy weighting for SimHits
275  php.layerRotation_ = 0; // default layer rotation angle
276  php.cassettes_ = 0; // default number of cassettes
277  std::unique_ptr<HGCalGeomParameters> geom = std::make_unique<HGCalGeomParameters>();
278  if ((php.mode_ == HGCalGeometryMode::Hexagon) || (php.mode_ == HGCalGeometryMode::HexagonFull)) {
279  tempS = fv.get<std::vector<std::string> >(namet, "WaferMode");
280  std::string sv2 = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::Polyhedra";
281  mode = HGCalGeometryMode::getGeometryWaferMode(sv2);
282 #ifdef EDM_ML_DEBUG
283  edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
284  << HGCalGeometryMode::ExtrudedPolygon;
285 #endif
286  php.minTileSize_ = 0;
287  php.waferMaskMode_ = 0;
288  php.waferZSide_ = 0;
289  }
290  if ((php.mode_ == HGCalGeometryMode::Hexagon8) || (php.mode_ == HGCalGeometryMode::Hexagon8Full) ||
291  (php.mode_ == HGCalGeometryMode::Hexagon8File) || (php.mode_ == HGCalGeometryMode::Hexagon8Module) ||
292  (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
293  php.levelT_ = dbl_to_int(fv.get<std::vector<double> >(name, "LevelTop"));
294  tempD = fv.get<std::vector<double> >(name, "LevelZSide");
295  php.levelZSide_ = static_cast<int>(tempD[0]);
296  php.nCellsFine_ = php.nCellsCoarse_ = 0;
297  php.firstLayer_ = 1;
298  tempD = fv.get<std::vector<double> >(name, "FirstMixedLayer");
299  php.firstMixedLayer_ = static_cast<int>(tempD[0]);
300  tempD = fv.get<std::vector<double> >(name, "DetectorType");
301  php.detectorType_ = static_cast<int>(tempD[0]);
302  php.minTileSize_ = 0;
303  tempD = fv.get<std::vector<double> >(name, "WaferMaskMode");
304  php.waferMaskMode_ = static_cast<int>(tempD[0]);
305  tempD = fv.get<std::vector<double> >(name, "WaferZside");
306  php.waferZSide_ = static_cast<int>(tempD[0]);
307  if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
308  tempD = fv.get<std::vector<double> >(name, "LayerRotation");
309  php.layerRotation_ = tempD[0];
310  tempD = fv.get<std::vector<double> >(name, "UseSimWt");
311  php.useSimWt_ = tempD[0];
312  }
313  if ((php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteEE) ||
314  (php.waferMaskMode_ == HGCalGeomParameters::siliconCassetteHE)) {
315  tempD = fv.get<std::vector<double> >(name, "Cassettes");
316  php.cassettes_ = static_cast<int>(tempD[0]);
317  }
318 #ifdef EDM_ML_DEBUG
319  edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " ZSide Level "
320  << php.levelZSide_ << " first layers " << php.firstLayer_ << ":"
321  << php.firstMixedLayer_ << " Det Type " << php.detectorType_ << " Wafer Mask Mode "
322  << php.waferMaskMode_ << " ZSide " << php.waferZSide_ << " Layer Rotation "
323  << convertRadToDeg(php.layerRotation_) << " Cassettes " << php.cassettes_
324  << " UseSimWt " << php.useSimWt_;
325 #endif
326 
327  tempS = fv.get<std::vector<std::string> >(namet, "WaferMode");
328  std::string sv2 = (!tempS.empty()) ? tempS[0] : "HGCalGeometryMode::ExtrudedPolygon";
329  mode = HGCalGeometryMode::getGeometryWaferMode(sv2);
330  tempD = fv.get<std::vector<double> >(namet, "NumberOfCellsFine");
331  php.nCellsFine_ = static_cast<int>(tempD[0]);
332  tempD = fv.get<std::vector<double> >(namet, "NumberOfCellsCoarse");
333  php.nCellsCoarse_ = static_cast<int>(tempD[0]);
334  tempD = fv.get<std::vector<double> >(namet, "WaferSize");
335  php.waferSize_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
336  tempD = fv.get<std::vector<double> >(namet, "WaferThickness");
337  php.waferThick_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
338  tempD = fv.get<std::vector<double> >(namet, "SensorSeparation");
339  php.sensorSeparation_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
340  tempD = fv.get<std::vector<double> >(namet, "SensorSizeOffset");
341  php.sensorSizeOffset_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
342  tempD = fv.get<std::vector<double> >(namet, "GuardRingOffset");
343  php.guardRingOffset_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
344  tempD = fv.get<std::vector<double> >(namet, "MouseBite");
345  php.mouseBite_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
346  php.waferR_ = HGCalParameters::k_ScaleToDDD * php.waferSize_ * tan30deg_;
347  php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsFine_);
348  php.cellSize_.emplace_back(HGCalParameters::k_ScaleToDDD * php.waferSize_ / php.nCellsCoarse_);
349 #ifdef EDM_ML_DEBUG
350  edm::LogVerbatim("HGCalGeom") << "WaferMode " << mode << ":" << HGCalGeometryMode::Polyhedra << ":"
351  << HGCalGeometryMode::ExtrudedPolygon << " # of cells|size for fine/coarse "
352  << php.nCellsFine_ << ":" << php.cellSize_[0] << ":" << php.nCellsCoarse_ << ":"
353  << php.cellSize_[1] << " wafer Params " << php.waferSize_ << ":" << php.waferR_
354  << ":" << php.waferThick_ << ":" << php.sensorSeparation_ << ":"
355  << php.sensorSizeOffset_ << ":" << php.guardRingOffset_ << ":" << php.mouseBite_
356  << ":" << php.waferR_;
357 #endif
358  for (int k = 0; k < 2; ++k)
359  getCellPosition(php, k);
360  }
361  if (php.mode_ == HGCalGeometryMode::Hexagon) {
362  // Load the SpecPars
363  php.firstLayer_ = 1;
364  geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
365  // Load the Geometry parameters
366  geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
367  // Load cell parameters
368  geom->loadCellParsHexagon(vmap, php);
369  // Set complete fill mode
370  php.defineFull_ = false;
371  } else if (php.mode_ == HGCalGeometryMode::HexagonFull) {
372  // Load the SpecPars
373  php.firstLayer_ = 1;
374  geom->loadSpecParsHexagon(fv, php, name, namew, namec, name2);
375  // Load the Geometry parameters
376  geom->loadGeometryHexagon(cpv, php, name, namew, namec, mode);
377  // Modify some constants
378  geom->loadWaferHexagon(php);
379  // Load cell parameters
380  geom->loadCellParsHexagon(vmap, php);
381  // Set complete fill mode
382  php.defineFull_ = true;
383  } else if (php.mode_ == HGCalGeometryMode::Hexagon8) {
384  // Load the SpecPars
385  geom->loadSpecParsHexagon8(fv, vmap, php, name);
386  // Load Geometry parameters
387  geom->loadGeometryHexagon8(cpv, php, name, 1);
388  // Set complete fill mode
389  php.defineFull_ = false;
390  // Load wafer positions
391  geom->loadWaferHexagon8(php);
392  } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Full) || (php.mode_ == HGCalGeometryMode::Hexagon8File)) {
393  // Load the SpecPars
394  geom->loadSpecParsHexagon8(fv, vmap, php, name);
395  // Load Geometry parameters
396  geom->loadGeometryHexagon8(cpv, php, name, 1);
397  // Set complete fill mode
398  php.defineFull_ = true;
399  // Load wafer positions
400  geom->loadWaferHexagon8(php);
401  } else if ((php.mode_ == HGCalGeometryMode::Hexagon8Module) || (php.mode_ == HGCalGeometryMode::Hexagon8Cassette)) {
402  // Load the SpecPars
403  geom->loadSpecParsHexagon8(fv, vmap, php, name);
404  // Load Geometry parameters
405  geom->loadGeometryHexagonModule(cpv, php, name, namec, 1);
406  // Set complete fill mode
407  php.defineFull_ = true;
408  // Load wafer positions
409  geom->loadWaferHexagon8(php);
410  } else if ((php.mode_ == HGCalGeometryMode::Trapezoid) || (php.mode_ == HGCalGeometryMode::TrapezoidFile) ||
411  (php.mode_ == HGCalGeometryMode::TrapezoidModule) ||
412  (php.mode_ == HGCalGeometryMode::TrapezoidCassette)) {
413  // Load maximum eta & top level
414  php.levelT_ = dbl_to_int(fv.get<std::vector<double> >(name, "LevelTop"));
415  tempD = fv.get<std::vector<double> >(name, "LevelZSide");
416  php.levelZSide_ = static_cast<int>(tempD[0]);
417  php.nCellsFine_ = php.nCellsCoarse_ = 0;
418  tempD = fv.get<std::vector<double> >(name, "FirstLayer");
419  php.firstLayer_ = static_cast<int>(tempD[0]);
420  tempD = fv.get<std::vector<double> >(name, "FirstMixedLayer");
421  php.firstMixedLayer_ = static_cast<int>(tempD[0]);
422  tempD = fv.get<std::vector<double> >(name, "DetectorType");
423  php.detectorType_ = static_cast<int>(tempD[0]);
424  tempD = fv.get<std::vector<double> >(name, "WaferThickness");
425  php.waferThick_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
426  tempD = fv.get<std::vector<double> >(name, "MinimumTileSize");
427  php.minTileSize_ = HGCalParameters::k_ScaleFromDD4hep * tempD[0];
428  php.waferSize_ = php.waferR_ = 0;
429  php.sensorSeparation_ = php.mouseBite_ = 0;
430  php.sensorSizeOffset_ = php.guardRingOffset_ = 0;
431  tempD = fv.get<std::vector<double> >(name, "WaferMaskMode");
432  php.waferMaskMode_ = static_cast<int>(tempD[0]);
433  tempD = fv.get<std::vector<double> >(name, "WaferZside");
434  php.waferZSide_ = static_cast<int>(tempD[0]);
435  if ((php.mode_ == HGCalGeometryMode::TrapezoidModule) || (php.mode_ == HGCalGeometryMode::TrapezoidCassette)) {
436  tempD = fv.get<std::vector<double> >(name, "UseSimWt");
437  php.useSimWt_ = tempD[0];
438  }
439  if (php.waferMaskMode_ == HGCalGeomParameters::scintillatorCassette) {
440  tempD = fv.get<std::vector<double> >(name, "Cassettes");
441  php.cassettes_ = static_cast<int>(tempD[0]);
442  }
443 #ifdef EDM_ML_DEBUG
444  edm::LogVerbatim("HGCalGeom") << "Top levels " << php.levelT_[0] << ":" << php.levelT_[1] << " first layers "
445  << php.firstLayer_ << ":" << php.firstMixedLayer_ << " Det Type "
446  << php.detectorType_ << " thickenss " << php.waferThick_ << " min tile size "
447  << php.minTileSize_ << " Tile Mask Mode " << php.waferMaskMode_ << " ZSide "
448  << php.waferZSide_ << " Cassettes " << php.cassettes_ << " UseSimWt "
449  << php.useSimWt_;
450 #endif
451  // Load the SpecPars
452  geom->loadSpecParsTrapezoid(fv, vmap, php, name);
453  // Load Geometry parameters
454  geom->loadGeometryHexagon8(cpv, php, name, php.firstLayer_);
455  // Load cell positions
456  geom->loadCellTrapezoid(php);
457  } else {
458  edm::LogError("HGCalGeom") << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew
459  << ":" << namec;
460  throw cms::Exception("DDException")
461  << "Unknown Geometry type " << php.mode_ << " for HGCal " << name << ":" << namew << ":" << namec;
462  }
463  } else {
464  edm::LogError("HGCalGeom") << " Attribute Volume:" << name << " not found but needed.";
465  throw cms::Exception("DDException") << "Attribute Volume:" << name << " not found but needed.";
466  }
467 #ifdef EDM_ML_DEBUG
468  edm::LogVerbatim("HGCalGeom") << "Return from HGCalParametersFromDD::build"
469  << " with flag " << ok;
470 #endif
471  return ok;
472 }
473 
474 void HGCalParametersFromDD::getCellPosition(HGCalParameters& php, int type) {
475  if (type == 1) {
476  php.cellCoarseX_.clear();
477  php.cellCoarseY_.clear();
478  } else {
479  php.cellFineX_.clear();
480  php.cellFineY_.clear();
481  }
482  HGCalParameters::wafer_map cellIndex;
483 #ifdef EDM_ML_DEBUG
484  std::vector<int> indtypes;
485 #endif
486  int N = (type == 1) ? php.nCellsCoarse_ : php.nCellsFine_;
487  double R = php.waferSize_ / (3 * N);
488  double r = 0.5 * R * sqrt(3.0);
489  int n2 = N / 2;
490  int ipos(0);
491  for (int u = 0; u < 2 * N; ++u) {
492  for (int v = 0; v < 2 * N; ++v) {
493  if (((v - u) < N) && (u - v) <= N) {
494  double yp = (u - 0.5 * v - n2) * 2 * r;
495  double xp = (1.5 * (v - N) + 1.0) * R;
496  int id = v * 100 + u;
497 #ifdef EDM_ML_DEBUG
498  indtypes.emplace_back(id);
499 #endif
500  if (type == 1) {
501  php.cellCoarseX_.emplace_back(xp);
502  php.cellCoarseY_.emplace_back(yp);
503  } else {
504  php.cellFineX_.emplace_back(xp);
505  php.cellFineY_.emplace_back(yp);
506  }
507  cellIndex[id] = ipos;
508  ++ipos;
509  }
510  }
511  }
512  if (type == 1)
513  php.cellCoarseIndex_ = cellIndex;
514  else
515  php.cellFineIndex_ = cellIndex;
516 
517 #ifdef EDM_ML_DEBUG
518  if (type == 1) {
519  edm::LogVerbatim("HGCalGeom") << "CellPosition for type " << type << " for " << php.cellCoarseX_.size()
520  << " cells";
521  for (unsigned int k = 0; k < php.cellCoarseX_.size(); ++k) {
522  int id = indtypes[k];
523  edm::LogVerbatim("HGCalGeom") << "[" << k << "] ID " << id << ":" << php.cellCoarseIndex_[id] << " X "
524  << php.cellCoarseX_[k] << " Y " << php.cellCoarseY_[k];
525  }
526  } else {
527  edm::LogVerbatim("HGCalGeom") << "CellPosition for type " << type << " for " << php.cellFineX_.size() << " cells";
528  for (unsigned int k = 0; k < php.cellFineX_.size(); ++k) {
529  int id = indtypes[k];
530  edm::LogVerbatim("HGCalGeom") << "[" << k << "] ID " << id << ":" << php.cellFineIndex_[k] << " X "
531  << php.cellFineX_[k] << " Y " << php.cellFineY_[k];
532  }
533  }
534 #endif
535 }
536 
537 double HGCalParametersFromDD::getDDDValue(const char* s, const DDsvalues_type& sv) {
538  DDValue val(s);
539  if (DDfetch(&sv, val)) {
540  const std::vector<double>& fvec = val.doubles();
541  if (fvec.empty()) {
542  throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to get " << s << " tag.";
543  }
544  return fvec[0];
545  } else {
546  throw cms::Exception("HGCalGeom") << "getDDDValue::Failed to fetch " << s << " tag";
547  }
548 }
549 
550 std::vector<double> HGCalParametersFromDD::getDDDArray(const char* s, const DDsvalues_type& sv) {
551  DDValue val(s);
552  if (DDfetch(&sv, val)) {
553  const std::vector<double>& fvec = val.doubles();
554  if (fvec.empty()) {
555  throw cms::Exception("HGCalGeom") << "getDDDArray::Failed to get " << s << " tag.";
556  }
557  return fvec;
558  } else {
559  throw cms::Exception("HGCalGeom") << "getDDDArray:Failed to fetch " << s << " tag";
560  }
561 }
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
HGCalGeomParameters::scintillatorCassette
static constexpr int scintillatorCassette
Definition: HGCalGeomParameters.h:107
HGCalParameters::cellFineIndex_
wafer_map cellFineIndex_
Definition: HGCalParameters.h:123
angle_units::operators::convertRadToDeg
constexpr NumType convertRadToDeg(NumType radians)
Definition: angle_units.h:21
HGCalParameters::cellFineY_
std::vector< double > cellFineY_
Definition: HGCalParameters.h:125
cms::DDCompactView::detector
const cms::DDDetector * detector() const
Definition: DDCompactView.h:34
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:65
pfDeepBoostedJetPreprocessParams_cfi.sv
sv
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:352
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
HGCalParametersFromDD::build
bool build(const DDCompactView *cpv, HGCalParameters &php, const std::string &name, const std::string &namew, const std::string &namec, const std::string &namet)
Definition: HGCalParametersFromDD.cc:14
hfnoseParametersInitialization_cfi.name2
name2
Definition: hfnoseParametersInitialization_cfi.py:7
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
DDCompactView
Compact representation of the geometrical detector hierarchy.
Definition: DDCompactView.h:81
DDfetch
bool DDfetch(const DDsvalues_type *, DDValue &)
helper for retrieving DDValues from DDsvalues_type *.
Definition: DDsvalues.cc:79
HGCalParameters::mode_
HGCalGeometryMode::GeometryMode mode_
Definition: HGCalParameters.h:79
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
cms::DDVectorsMap
std::unordered_map< std::string, std::vector< double > > DDVectorsMap
Definition: DDNamespace.h:20
HGCalGeometryMode::getGeometryWaferMode
WaferMode getGeometryWaferMode(const char *s, const DDsvalues_type &sv)
Definition: HGCalGeometryMode.cc:48
HGCalParameters::cellCoarseX_
std::vector< double > cellCoarseX_
Definition: HGCalParameters.h:128
HGCalGeomParameters::siliconCassetteHE
static constexpr int siliconCassetteHE
Definition: HGCalGeomParameters.h:106
DDsvalues_type
std::vector< std::pair< unsigned int, DDValue > > DDsvalues_type
Definition: DDsvalues.h:12
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
HGCalParameters::cellSize_
std::vector< double > cellSize_
Definition: HGCalParameters.h:81
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
HGCalGeomParameters::siliconCassetteEE
static constexpr int siliconCassetteEE
Definition: HGCalGeomParameters.h:105
HGCalGeometryMode::getGeometryMode
GeometryMode getGeometryMode(const char *s, const DDsvalues_type &sv)
Definition: HGCalGeometryMode.cc:26
HGCalParameters::k_ScaleFromDD4hep
static constexpr double k_ScaleFromDD4hep
Definition: HGCalParameters.h:41
value
Definition: value.py:1
cms::DDFilteredView::firstChild
bool firstChild()
set the current node to the first child
Definition: DDFilteredView.cc:268
dbl_to_int
std::vector< int > dbl_to_int(const std::vector< double > &vecdbl)
Converts a std::vector of doubles to a std::vector of int.
Definition: DDutils.h:7
DDFilteredView::mergedSpecifics
DDsvalues_type mergedSpecifics() const
Definition: DDFilteredView.cc:42
cms::DDFilteredView::get
T get(const std::string &)
extract attribute value
HGCalParameters::k_ScaleToDDD
static constexpr double k_ScaleToDDD
Definition: HGCalParameters.h:38
geant_units::operators
Definition: GeantUnits.h:18
N
#define N
Definition: blowfish.cc:9
HGCalParameters::wafer_map
std::unordered_map< int32_t, int32_t > wafer_map
Definition: HGCalParameters.h:32
HGCalParametersFromDD::getDDDValue
double getDDDValue(const char *s, const DDsvalues_type &sv)
Definition: HGCalParametersFromDD.cc:537
HGCalParameters::cellCoarseIndex_
wafer_map cellCoarseIndex_
Definition: HGCalParameters.h:127
ALCARECOTkAlBeamHalo_cff.filter
filter
Definition: ALCARECOTkAlBeamHalo_cff.py:27
HGCalParameters::cellFineX_
std::vector< double > cellFineX_
Definition: HGCalParameters.h:124
HGCalParameters::k_ScaleFromDDD
static constexpr double k_ScaleFromDDD
Definition: HGCalParameters.h:37
DDFilteredView::firstChild
bool firstChild()
set the current node to the first child ...
Definition: DDFilteredView.cc:86
HGCalParameters::levelT_
std::vector< int > levelT_
Definition: HGCalParameters.h:148
HGCalParameters::cellCoarseY_
std::vector< double > cellCoarseY_
Definition: HGCalParameters.h:129
heppy_batch.val
val
Definition: heppy_batch.py:351
cms::DDDetector::vectors
cms::DDVectorsMap const & vectors() const
Definition: DDDetector.h:17
HGCalParametersFromDD::getDDDArray
std::vector< double > getDDDArray(const char *s, const DDsvalues_type &sv)
Definition: HGCalParametersFromDD.cc:550
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
HGCalParametersFromDD::getCellPosition
void getCellPosition(HGCalParameters &php, int type)
Definition: HGCalParametersFromDD.cc:474
Generated for CMSSW Reference Manual by doxygen 1.8.14