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