CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Member Functions | Protected Member Functions | Private Attributes | Static Private Attributes
DDHGCalMixLayer Class Reference
Inheritance diagram for DDHGCalMixLayer:

Public Member Functions

 DDHGCalMixLayer ()
 
void execute (DDCompactView &cpv) override
 
void initialize (const DDNumericArguments &nArgs, const DDVectorArguments &vArgs, const DDMapArguments &mArgs, const DDStringArguments &sArgs, const DDStringVectorArguments &vsArgs) override
 

Protected Member Functions

void constructLayers (const DDLogicalPart &, DDCompactView &cpv)
 
void positionMix (const DDLogicalPart &glog, const std::string &nameM, int copyM, double thick, const DDMaterial &matter, DDCompactView &cpv)
 

Private Attributes

int absorbMode_
 
double alpha_
 
std::unordered_set< int > copies_
 
std::vector< int > copyNumber_
 
std::vector< int > copyNumberTop_
 
double cosAlpha_
 
int facingTypes_
 
int firstLayer_
 
HGCalGeomTools geomTools_
 
std::vector< int > layers_
 
std::vector< int > layerSense_
 
std::vector< double > layerThick_
 
std::vector< double > layerThickTop_
 
std::vector< int > layerType_
 
std::vector< int > layerTypes_
 
std::vector< int > layerTypeTop_
 
std::vector< std::string > materials_
 
std::vector< std::string > materialTop_
 
std::vector< std::string > names_
 
std::string nameSpace_
 
std::vector< std::string > namesTop_
 
int orientationTypes_
 
int partialTypes_
 
int phiBinsScint_
 
std::vector< double > rMaxFront_
 
std::vector< double > rMinFront_
 
int sectors_
 
int sensitiveMode_
 
std::vector< double > slopeB_
 
std::vector< double > slopeT_
 
std::vector< double > thick_
 
std::vector< int > tileIndex_
 
std::vector< int > tileLayerStart_
 
std::vector< int > tilePhis_
 
std::vector< double > tileRMax_
 
std::vector< double > tileRMin_
 
std::vector< std::string > waferFull_
 
std::vector< int > waferIndex_
 
std::vector< int > waferLayerStart_
 
std::vector< std::string > waferPart_
 
std::vector< int > waferProperty_
 
double waferSepar_
 
double waferSize_
 
int waferTypes_
 
std::vector< double > zFrontB_
 
std::vector< double > zFrontT_
 
double zMinBlock_
 

Static Private Attributes

static constexpr double tol1_ = 0.01
 
static constexpr double tol2_ = 0.00001
 

Detailed Description

Definition at line 35 of file DDHGCalMixLayer.cc.

Constructor & Destructor Documentation

◆ DDHGCalMixLayer()

DDHGCalMixLayer::DDHGCalMixLayer ( )

Definition at line 108 of file DDHGCalMixLayer.cc.

108  {
109 #ifdef EDM_ML_DEBUG
110  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Creating an instance";
111 #endif
112 }
Log< level::Info, true > LogVerbatim

Member Function Documentation

◆ constructLayers()

void DDHGCalMixLayer::constructLayers ( const DDLogicalPart module,
DDCompactView cpv 
)
protected

Definition at line 310 of file DDHGCalMixLayer.cc.

References funct::abs(), angle_units::operators::convertRadToDeg(), filterCSVwithJSON::copy, DDBase< N, C >::ddname(), DDSplit(), first, mps_fire::i, cuy::ii, dqmdumpme::k, SiStripPI::min, callgraph::module, Skims_PA_cff::name, DDBase< N, C >::name(), DDSolidFactory::polyhedra(), DDCompactView::position(), diffTwoXMLs::r1, HGCalGeomTools::radius(), makeMuonMisalignmentScenario::rot, edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, cond::impl::to_string(), DDSolidFactory::tubs(), and geometryCSVtoXML::zz.

310  {
311  double zi(zMinBlock_);
312  int laymin(0);
313  for (unsigned int i = 0; i < layers_.size(); i++) {
314  double zo = zi + layerThick_[i];
315  double routF = HGCalGeomTools::radius(zi, zFrontT_, rMaxFront_, slopeT_);
316  int laymax = laymin + layers_[i];
317  double zz = zi;
318  double thickTot(0);
319  for (int ly = laymin; ly < laymax; ++ly) {
320  int ii = layerType_[ly];
321  int copy = copyNumber_[ii];
322  double hthick = 0.5 * thick_[ii];
323  double rinB = HGCalGeomTools::radius(zo, zFrontB_, rMinFront_, slopeB_);
324  zz += hthick;
325  thickTot += thick_[ii];
326 
328 #ifdef EDM_ML_DEBUG
329  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Layer " << ly << ":" << ii << " Front " << zi << ", " << routF
330  << " Back " << zo << ", " << rinB << " superlayer thickness " << layerThick_[i];
331 #endif
333  DDMaterial matter(matName);
334  DDLogicalPart glog;
335  if (layerSense_[ly] < 1) {
336  std::vector<double> pgonZ, pgonRin, pgonRout;
337  double rmax =
339  HGCalGeomTools::radius(zz - hthick,
340  zz + hthick,
341  zFrontB_,
342  rMinFront_,
343  slopeB_,
344  zFrontT_,
345  rMaxFront_,
346  slopeT_,
347  -layerSense_[ly],
348  pgonZ,
349  pgonRin,
350  pgonRout);
351  for (unsigned int isec = 0; isec < pgonZ.size(); ++isec) {
352  pgonZ[isec] -= zz;
353  if (layerSense_[ly] == 0 || absorbMode_ == 0)
354  pgonRout[isec] = rmax;
355  else
356  pgonRout[isec] = pgonRout[isec] * cosAlpha_ - tol1_;
357  }
358  DDSolid solid =
359  DDSolidFactory::polyhedra(DDName(name, nameSpace_), sectors_, -alpha_, 2._pi, pgonZ, pgonRin, pgonRout);
360  glog = DDLogicalPart(solid.ddname(), matter, solid);
361 #ifdef EDM_ML_DEBUG
362  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << solid.name() << " polyhedra of " << sectors_
363  << " sectors covering " << convertRadToDeg(-alpha_) << ":"
364  << convertRadToDeg(-alpha_ + 2._pi) << " with " << pgonZ.size() << " sections";
365  for (unsigned int k = 0; k < pgonZ.size(); ++k)
366  edm::LogVerbatim("HGCalGeom") << "[" << k << "] z " << pgonZ[k] << " R " << pgonRin[k] << ":" << pgonRout[k];
367 #endif
368  } else {
369  double rins = (sensitiveMode_ < 1) ? rinB : HGCalGeomTools::radius(zz + hthick, zFrontB_, rMinFront_, slopeB_);
370  double routs =
371  (sensitiveMode_ < 1) ? routF : HGCalGeomTools::radius(zz - hthick, zFrontT_, rMaxFront_, slopeT_);
372  DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), hthick, rins, routs, 0.0, 2._pi);
373  glog = DDLogicalPart(solid.ddname(), matter, solid);
374 #ifdef EDM_ML_DEBUG
375  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << solid.name() << " Tubs made of " << matName
376  << " of dimensions " << rinB << ":" << rins << ", " << routF << ":" << routs
377  << ", " << hthick << ", 0.0, 360.0 and positioned in: " << glog.name()
378  << " number " << copy;
379 #endif
380  positionMix(glog, name, copy, thick_[ii], matter, cpv);
381  }
382  DDTranslation r1(0, 0, zz);
383  DDRotation rot;
384  cpv.position(glog, module, copy, r1, rot);
385  ++copyNumber_[ii];
386 #ifdef EDM_ML_DEBUG
387  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << glog.name() << " number " << copy << " positioned in "
388  << module.name() << " at " << r1 << " with no rotation";
389 #endif
390  zz += hthick;
391  } // End of loop over layers in a block
392  zi = zo;
393  laymin = laymax;
394  // Make consistency check of all the partitions of the block
395  if (std::abs(thickTot - layerThick_[i]) >= tol2_) {
396  if (thickTot > layerThick_[i]) {
397  edm::LogError("HGCalGeom") << "Thickness of the partition " << layerThick_[i] << " is smaller than " << thickTot
398  << ": thickness of all its components **** ERROR ****";
399  } else {
400  edm::LogWarning("HGCalGeom") << "Thickness of the partition " << layerThick_[i] << " does not match with "
401  << thickTot << " of the components";
402  }
403  }
404  } // End of loop over blocks
405 }
Log< level::Info, true > LogVerbatim
std::vector< double > zFrontT_
static void radius(double zf, double zb, std::vector< double > const &zFront1, std::vector< double > const &rFront1, std::vector< double > const &slope1, std::vector< double > const &zFront2, std::vector< double > const &rFront2, std::vector< double > const &slope2, int flag, std::vector< double > &zz, std::vector< double > &rin, std::vector< double > &rout)
std::vector< double > rMinFront_
void position(const DDLogicalPart &self, const DDLogicalPart &parent, const std::string &copyno, const DDTranslation &trans, const DDRotation &rot, const DDDivision *div=nullptr)
DDMaterial is used to define and access material information.
Definition: DDMaterial.h:45
constexpr NumType convertRadToDeg(NumType radians)
Definition: angle_units.h:21
std::vector< double > thick_
DDName is used to identify DDD entities uniquely.
Definition: DDName.h:17
std::string to_string(const V &value)
Definition: OMSAccess.h:71
Log< level::Error, false > LogError
std::string nameSpace_
A DDSolid represents the shape of a part.
Definition: DDSolid.h:39
Represents a uniquely identifyable rotation matrix.
Definition: DDTransform.h:57
std::vector< double > slopeB_
U second(std::pair< T, U > const &p)
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
A DDLogicalPart aggregates information concerning material, solid and sensitveness ...
Definition: DDLogicalPart.h:93
static constexpr double tol2_
static DDSolid tubs(const DDName &name, double zhalf, double rIn, double rOut, double startPhi, double deltaPhi)
Definition: DDSolid.cc:667
ii
Definition: cuy.py:589
void positionMix(const DDLogicalPart &glog, const std::string &nameM, int copyM, double thick, const DDMaterial &matter, DDCompactView &cpv)
const N & name() const
Definition: DDBase.h:59
std::vector< int > copyNumber_
const N & ddname() const
Definition: DDBase.h:61
static constexpr double tol1_
std::vector< double > layerThick_
std::vector< double > slopeT_
std::vector< int > layers_
std::vector< std::string > names_
std::vector< int > layerType_
std::vector< double > rMaxFront_
Log< level::Warning, false > LogWarning
std::vector< double > zFrontB_
std::pair< std::string, std::string > DDSplit(const std::string &n)
split into (name,namespace), separator = &#39;:&#39;
Definition: DDSplit.cc:3
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double > > DDTranslation
Definition: DDTranslation.h:7
static DDSolid polyhedra(const DDName &name, int sides, double startPhi, double deltaPhi, const std::vector< double > &z, const std::vector< double > &rmin, const std::vector< double > &rmax)
Creates a polyhedra (refere to Geant3 or Geant4 documentation)
Definition: DDSolid.cc:565
std::vector< std::string > materials_
std::vector< int > layerSense_

◆ execute()

void DDHGCalMixLayer::execute ( DDCompactView cpv)
override

Definition at line 293 of file DDHGCalMixLayer.cc.

References DDHGCalGeom::constructLayers(), dqmdumpme::k, and class-composition::parent.

293  {
294 #ifdef EDM_ML_DEBUG
295  edm::LogVerbatim("HGCalGeom") << "==>> Constructing DDHGCalMixLayer...";
296  copies_.clear();
297 #endif
298  constructLayers(parent(), cpv);
299 #ifdef EDM_ML_DEBUG
300  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << copies_.size() << " different wafer copy numbers";
301  int k(0);
302  for (std::unordered_set<int>::const_iterator itr = copies_.begin(); itr != copies_.end(); ++itr, ++k) {
303  edm::LogVerbatim("HGCalGeom") << "Copy [" << k << "] : " << (*itr);
304  }
305  copies_.clear();
306  edm::LogVerbatim("HGCalGeom") << "<<== End of DDHGCalMixLayer construction...";
307 #endif
308 }
Log< level::Info, true > LogVerbatim
void constructLayers(const DDLogicalPart &, DDCompactView &cpv)
std::unordered_set< int > copies_

◆ initialize()

void DDHGCalMixLayer::initialize ( const DDNumericArguments nArgs,
const DDVectorArguments vArgs,
const DDMapArguments mArgs,
const DDStringArguments sArgs,
const DDStringVectorArguments vsArgs 
)
override

Definition at line 114 of file DDHGCalMixLayer.cc.

References angle_units::operators::convertRadToDeg(), funct::cos(), dbl_to_int(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, cuy::ii, createfilelist::int, dqmdumpme::k, SiStripPI::min, DDCurrentNamespace::ns(), HGCalTileIndex::tileUnpack(), HGCalWaferIndex::waferLayer(), HGCalProperty::waferOrient(), HGCalProperty::waferPartial(), HGCalProperty::waferThick(), HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

118  {
119  waferTypes_ = static_cast<int>(nArgs["WaferTypes"]);
120  facingTypes_ = static_cast<int>(nArgs["FacingTypes"]);
121  partialTypes_ = static_cast<int>(nArgs["PartialTypes"]);
122  orientationTypes_ = static_cast<int>(nArgs["OrientationTypes"]);
123  phiBinsScint_ = static_cast<int>(nArgs["NPhiBinScint"]);
124 #ifdef EDM_ML_DEBUG
125  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer::Number of types of wafers: " << waferTypes_
126  << " facings: " << facingTypes_ << " partials: " << partialTypes_
127  << " Orientations: " << orientationTypes_ << "; number of cells along phi "
128  << phiBinsScint_;
129 #endif
130  firstLayer_ = (int)(nArgs["FirstLayer"]);
131  absorbMode_ = (int)(nArgs["AbsorberMode"]);
132  sensitiveMode_ = (int)(nArgs["SensitiveMode"]);
133 #ifdef EDM_ML_DEBUG
134  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer::First Layer " << firstLayer_ << " and "
135  << "Absober:Sensitive mode " << absorbMode_ << ":" << sensitiveMode_;
136 #endif
137  zMinBlock_ = nArgs["zMinBlock"];
138  waferSize_ = nArgs["waferSize"];
139  waferSepar_ = nArgs["SensorSeparation"];
140  sectors_ = (int)(nArgs["Sectors"]);
141  alpha_ = (1._pi) / sectors_;
142  cosAlpha_ = cos(alpha_);
143 #ifdef EDM_ML_DEBUG
144  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: zStart " << zMinBlock_ << " wafer width " << waferSize_
145  << " separations " << waferSepar_ << " sectors " << sectors_ << ":"
146  << convertRadToDeg(alpha_) << ":" << cosAlpha_;
147 #endif
148  slopeB_ = vArgs["SlopeBottom"];
149  zFrontB_ = vArgs["ZFrontBottom"];
150  rMinFront_ = vArgs["RMinFront"];
151  slopeT_ = vArgs["SlopeTop"];
152  zFrontT_ = vArgs["ZFrontTop"];
153  rMaxFront_ = vArgs["RMaxFront"];
154 #ifdef EDM_ML_DEBUG
155  for (unsigned int i = 0; i < slopeB_.size(); ++i)
156  edm::LogVerbatim("HGCalGeom") << "Bottom Block [" << i << "] Zmin " << zFrontB_[i] << " Rmin " << rMinFront_[i]
157  << " Slope " << slopeB_[i];
158  for (unsigned int i = 0; i < slopeT_.size(); ++i)
159  edm::LogVerbatim("HGCalGeom") << "Top Block [" << i << "] Zmin " << zFrontT_[i] << " Rmax " << rMaxFront_[i]
160  << " Slope " << slopeT_[i];
161 #endif
162  waferFull_ = vsArgs["WaferNamesFull"];
163  waferPart_ = vsArgs["WaferNamesPartial"];
164 #ifdef EDM_ML_DEBUG
165  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << waferFull_.size() << " full and " << waferPart_.size()
166  << " partial modules\nDDHGCalMixLayer:Full Modules:";
167  unsigned int i1max = static_cast<unsigned int>(waferFull_.size());
168  for (unsigned int i1 = 0; i1 < i1max; i1 += 2) {
169  std::ostringstream st1;
170  unsigned int i2 = std::min((i1 + 2), i1max);
171  for (unsigned int i = i1; i < i2; ++i)
172  st1 << " [" << i << "] " << waferFull_[i];
173  edm::LogVerbatim("HGCalGeom") << st1.str() << std::endl;
174  }
175  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Partial Modules:";
176  i1max = static_cast<unsigned int>(waferPart_.size());
177  for (unsigned int i1 = 0; i1 < i1max; i1 += 2) {
178  std::ostringstream st1;
179  unsigned int i2 = std::min((i1 + 2), i1max);
180  for (unsigned int i = i1; i < i2; ++i)
181  st1 << " [" << i << "] " << waferPart_[i];
182  edm::LogVerbatim("HGCalGeom") << st1.str() << std::endl;
183  }
184 #endif
185  materials_ = vsArgs["MaterialNames"];
186  names_ = vsArgs["VolumeNames"];
187  thick_ = vArgs["Thickness"];
188  copyNumber_.resize(materials_.size(), 1);
189 #ifdef EDM_ML_DEBUG
190  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << materials_.size() << " types of volumes";
191  for (unsigned int i = 0; i < names_.size(); ++i)
192  edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << names_[i] << " of thickness " << thick_[i]
193  << " filled with " << materials_[i] << " first copy number " << copyNumber_[i];
194 #endif
195  layers_ = dbl_to_int(vArgs["Layers"]);
196  layerThick_ = vArgs["LayerThick"];
197 #ifdef EDM_ML_DEBUG
198  edm::LogVerbatim("HGCalGeom") << "There are " << layers_.size() << " blocks";
199  for (unsigned int i = 0; i < layers_.size(); ++i)
200  edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] of thickness " << layerThick_[i] << " with " << layers_[i]
201  << " layers";
202 #endif
203  layerType_ = dbl_to_int(vArgs["LayerType"]);
204  layerSense_ = dbl_to_int(vArgs["LayerSense"]);
205  layerTypes_ = dbl_to_int(vArgs["LayerTypes"]);
206 #ifdef EDM_ML_DEBUG
207  for (unsigned int i = 0; i < layerTypes_.size(); ++i)
208  edm::LogVerbatim("HGCalGeom") << "LayerTypes [" << i << "] " << layerTypes_[i];
209 #endif
210  if (firstLayer_ > 0) {
211  for (unsigned int i = 0; i < layerType_.size(); ++i) {
212  if (layerSense_[i] > 0) {
213  int ii = layerType_[i];
215 #ifdef EDM_ML_DEBUG
216  edm::LogVerbatim("HGCalGeom") << "First copy number for layer type " << i << ":" << ii << " with "
217  << materials_[ii] << " changed to " << copyNumber_[ii];
218 #endif
219  break;
220  }
221  }
222  } else {
223  firstLayer_ = 1;
224  }
225 #ifdef EDM_ML_DEBUG
226  edm::LogVerbatim("HGCalGeom") << "There are " << layerType_.size() << " layers";
227  for (unsigned int i = 0; i < layerType_.size(); ++i)
228  edm::LogVerbatim("HGCalGeom") << "Layer [" << i << "] with material type " << layerType_[i] << " sensitive class "
229  << layerSense_[i];
230 #endif
231  materialTop_ = vsArgs["TopMaterialNames"];
232  namesTop_ = vsArgs["TopVolumeNames"];
233  layerThickTop_ = vArgs["TopLayerThickness"];
234  layerTypeTop_ = dbl_to_int(vArgs["TopLayerType"]);
235  copyNumberTop_.resize(materialTop_.size(), firstLayer_);
236 #ifdef EDM_ML_DEBUG
237  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << materialTop_.size() << " types of volumes in the top part";
238  for (unsigned int i = 0; i < materialTop_.size(); ++i)
239  edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << namesTop_[i] << " of thickness " << layerThickTop_[i]
240  << " filled with " << materialTop_[i] << " first copy number " << copyNumberTop_[i];
241  edm::LogVerbatim("HGCalGeom") << "There are " << layerTypeTop_.size() << " layers in the top part";
242  for (unsigned int i = 0; i < layerTypeTop_.size(); ++i)
243  edm::LogVerbatim("HGCalGeom") << "Layer [" << i << "] with material type " << layerTypeTop_[i];
244 #endif
245  waferIndex_ = dbl_to_int(vArgs["WaferIndex"]);
246  waferProperty_ = dbl_to_int(vArgs["WaferProperties"]);
247  waferLayerStart_ = dbl_to_int(vArgs["WaferLayerStart"]);
248 #ifdef EDM_ML_DEBUG
249  edm::LogVerbatim("HGCalGeom") << "waferProperties with " << waferIndex_.size() << " entries in "
250  << waferLayerStart_.size() << " layers";
251  for (unsigned int k = 0; k < waferLayerStart_.size(); ++k)
252  edm::LogVerbatim("HGCalGeom") << "LayerStart[" << k << "] " << waferLayerStart_[k];
253  for (unsigned int k = 0; k < waferIndex_.size(); ++k)
254  edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << waferIndex_[k] << " ("
257  << HGCalWaferIndex::waferV(waferIndex_[k]) << ") : ("
261 #endif
262  tileRMin_ = vArgs["TileRMin"];
263  tileRMax_ = vArgs["TileRMax"];
264  tileIndex_ = dbl_to_int(vArgs["TileLayerRings"]);
265  tilePhis_ = dbl_to_int(vArgs["TilePhiRange"]);
266  tileLayerStart_ = dbl_to_int(vArgs["TileLayerStart"]);
267 #ifdef EDM_ML_DEBUG
268  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer:: with " << tileRMin_.size() << " rings";
269  for (unsigned int k = 0; k < tileRMin_.size(); ++k)
270  edm::LogVerbatim("HGCalGeom") << "Ring[" << k << "] " << tileRMin_[k] << " : " << tileRMax_[k];
271  edm::LogVerbatim("HGCalGeom") << "TileProperties with " << tileIndex_.size() << " entries in "
272  << tileLayerStart_.size() << " layers";
273  for (unsigned int k = 0; k < tileLayerStart_.size(); ++k)
274  edm::LogVerbatim("HGCalGeom") << "LayerStart[" << k << "] " << tileLayerStart_[k];
275  for (unsigned int k = 0; k < tileIndex_.size(); ++k)
276  edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << tileIndex_[k] << " ("
277  << "Layer " << std::get<0>(HGCalTileIndex::tileUnpack(tileIndex_[k])) << " Ring "
278  << std::get<1>(HGCalTileIndex::tileUnpack(tileIndex_[k])) << ":"
279  << std::get<2>(HGCalTileIndex::tileUnpack(tileIndex_[k])) << ") Phi "
280  << std::get<1>(HGCalTileIndex::tileUnpack(tilePhis_[k])) << ":"
281  << std::get<2>(HGCalTileIndex::tileUnpack(tilePhis_[k]));
282 #endif
284 #ifdef EDM_ML_DEBUG
285  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: NameSpace " << nameSpace_ << ":";
286 #endif
287 }
Log< level::Info, true > LogVerbatim
std::vector< double > zFrontT_
std::vector< int > tileIndex_
std::vector< double > rMinFront_
int32_t waferU(const int32_t index)
int32_t waferLayer(const int32_t index)
std::vector< int > layerTypes_
std::vector< double > layerThickTop_
constexpr NumType convertRadToDeg(NumType radians)
Definition: angle_units.h:21
std::vector< double > thick_
static std::string & ns()
std::vector< int > tilePhis_
std::string nameSpace_
int32_t waferOrient(const int32_t property)
std::vector< double > tileRMax_
std::vector< double > slopeB_
std::vector< int > copyNumberTop_
std::vector< std::string > materialTop_
std::vector< int > waferIndex_
std::vector< int > waferLayerStart_
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
int32_t waferThick(const int32_t property)
std::vector< std::string > namesTop_
ii
Definition: cuy.py:589
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
std::tuple< int32_t, int32_t, int32_t > tileUnpack(int32_t index)
std::vector< int > layerTypeTop_
std::vector< int > copyNumber_
std::vector< int > tileLayerStart_
std::vector< std::string > waferPart_
std::vector< double > layerThick_
std::vector< double > slopeT_
int32_t waferPartial(const int32_t property)
std::vector< int > layers_
std::vector< int > waferProperty_
std::vector< std::string > names_
std::vector< int > layerType_
int32_t waferV(const int32_t index)
std::vector< std::string > waferFull_
std::vector< double > rMaxFront_
std::vector< double > zFrontB_
std::vector< std::string > materials_
std::vector< double > tileRMin_
std::vector< int > layerSense_

◆ positionMix()

void DDHGCalMixLayer::positionMix ( const DDLogicalPart glog,
const std::string &  nameM,
int  copyM,
double  thick,
const DDMaterial matter,
DDCompactView cpv 
)
protected

Definition at line 407 of file DDHGCalMixLayer.cc.

References funct::abs(), angle_units::operators::convertRadToDeg(), filterCSVwithJSON::copy, HGCalTypes::CornerCenteredLambda, HGCalTypes::CornerCenteredY, DDBase< N, C >::ddname(), DDSplit(), PVValHelper::dy, first, mps_fire::i, cuy::ii, gpuVertexFinder::iv, dqmdumpme::k, phase1PixelTopology::layer, Skims_PA_cff::name, DDBase< N, C >::name(), EgHLTOffHistBins_cfi::nr, HGCalTypes::packTypeUV(), DDCompactView::position(), dttmaxenums::R, alignCSCRings::r, diffTwoXMLs::r1, diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, edm::second(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, HGCalTileIndex::tileUnpack(), cond::impl::to_string(), DDSolidFactory::tubs(), findQualityFiles::v, HGCalTypes::WaferCenteredBack, HGCalTypes::WaferFull, HGCalWaferIndex::waferLayer(), HGCalProperty::waferOrient(), HGCalProperty::waferPartial(), HGCalProperty::waferThick(), HGCalWaferIndex::waferU(), and HGCalWaferIndex::waferV().

412  {
413  DDRotation rot;
414 
415  // Make the top part first
416  for (unsigned int ly = 0; ly < layerTypeTop_.size(); ++ly) {
417  int ii = layerTypeTop_[ly];
418  copyNumberTop_[ii] = copyM;
419  }
420  double hthick = 0.5 * thick;
421  double dphi = (2._pi) / phiBinsScint_;
422  double thickTot(0), zpos(-hthick);
423  for (unsigned int ly = 0; ly < layerTypeTop_.size(); ++ly) {
424  int ii = layerTypeTop_[ly];
425  int copy = copyNumberTop_[ii];
426  int layer = copy - firstLayer_;
427  double hthickl = 0.5 * layerThickTop_[ii];
428  thickTot += layerThickTop_[ii];
429  zpos += hthickl;
431  DDMaterial matter1(matName);
432  unsigned int k = 0;
433  int firstTile = tileLayerStart_[layer];
434  int lastTile = ((layer + 1 < static_cast<int>(tileLayerStart_.size())) ? tileLayerStart_[layer + 1]
435  : static_cast<int>(tileIndex_.size()));
436 #ifdef EDM_ML_DEBUG
437  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Layer " << ly << ":" << ii << " Copy " << copy << " Tiles "
438  << firstTile << ":" << lastTile;
439 #endif
440  for (int ti = firstTile; ti < lastTile; ++ti) {
441  double r1 = tileRMin_[std::get<1>(HGCalTileIndex::tileUnpack(tileIndex_[ti])) - 1];
442  double r2 = tileRMax_[std::get<2>(HGCalTileIndex::tileUnpack(tileIndex_[ti])) - 1];
443  int fimin = std::get<1>(HGCalTileIndex::tileUnpack(tilePhis_[ti]));
444  int fimax = std::get<2>(HGCalTileIndex::tileUnpack(tilePhis_[ti]));
445  double phi1 = dphi * (fimin - 1);
446  double phi2 = dphi * (fimax - fimin + 1);
447 #ifdef EDM_ML_DEBUG
448  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Layer " << copy << " iR "
449  << std::get<1>(HGCalTileIndex::tileUnpack(tileIndex_[ly])) << ":"
450  << std::get<2>(HGCalTileIndex::tileUnpack(tileIndex_[ly])) << " R " << r1 << ":"
451  << r2 << " Thick " << (2.0 * hthickl) << " phi " << fimin << ":" << fimax << ":"
452  << convertRadToDeg(phi1) << ":" << convertRadToDeg(phi2);
453  ;
454 #endif
456  ++k;
457  DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), hthickl, r1, r2, phi1, phi2);
458  DDLogicalPart glog1 = DDLogicalPart(solid.ddname(), matter1, solid);
459 #ifdef EDM_ML_DEBUG
460  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << glog1.name() << " Tubs made of " << matName
461  << " of dimensions " << r1 << ", " << r2 << ", " << hthickl << ", "
462  << convertRadToDeg(phi1) << ", " << convertRadToDeg(phi2);
463 #endif
464  DDTranslation tran(0, 0, zpos);
465  cpv.position(glog1, glog, copy, tran, rot);
466 #ifdef EDM_ML_DEBUG
467  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Position " << glog1.name() << " number " << copy << " in "
468  << glog.name() << " at " << tran << " with no rotation";
469 #endif
470  }
471  ++copyNumberTop_[ii];
472  zpos += hthickl;
473  }
474  if (std::abs(thickTot - thick) >= tol2_) {
475  if (thickTot > thick) {
476  edm::LogError("HGCalGeom") << "Thickness of the partition " << thick << " is smaller than " << thickTot
477  << ": thickness of all its components in the top part **** ERROR ****";
478  } else {
479  edm::LogWarning("HGCalGeom") << "Thickness of the partition " << thick << " does not match with " << thickTot
480  << " of the components in top part";
481  }
482  }
483 
484  // Make the bottom part next
485  int layer = (copyM - firstLayer_);
486  static const double sqrt3 = std::sqrt(3.0);
487  int layercenter = (layerTypes_[layer] == HGCalTypes::CornerCenteredLambda)
488  ? 1
490  int layerType = (layerTypes_[layer] == HGCalTypes::WaferCenteredBack) ? 1 : 0;
491  int firstWafer = waferLayerStart_[layer];
492  int lastWafer = ((layer + 1 < static_cast<int>(waferLayerStart_.size())) ? waferLayerStart_[layer + 1]
493  : static_cast<int>(waferIndex_.size()));
494  double r = 0.5 * (waferSize_ + waferSepar_);
495  double R = 2.0 * r / sqrt3;
496  double dy = 0.75 * R;
497  const auto& xyoff = geomTools_.shiftXY(layercenter, (waferSize_ + waferSepar_));
498 #ifdef EDM_ML_DEBUG
499  int ium(0), ivm(0), kount(0);
500  std::vector<int> ntype(3, 0);
501  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: " << glog.ddname() << " r " << r << " R " << R << " dy " << dy
502  << " Shift " << xyoff.first << ":" << xyoff.second << " WaferSize "
503  << (waferSize_ + waferSepar_) << " index " << firstWafer << ":" << (lastWafer - 1);
504 #endif
505  for (int k = firstWafer; k < lastWafer; ++k) {
508 #ifdef EDM_ML_DEBUG
509  int iu = std::abs(u);
510  int iv = std::abs(v);
511 #endif
512  int nr = 2 * v;
513  int nc = -2 * u + v;
514  double xpos = xyoff.first + nc * r;
515  double ypos = xyoff.second + nr * dy;
519  std::string wafer;
520  int i(999);
521  if (part == HGCalTypes::WaferFull) {
522  i = layerType * waferTypes_ + type;
523  wafer = waferFull_[i];
524  } else {
526  type * orientationTypes_ + orien;
527 #ifdef EDM_ML_DEBUG
528  edm::LogVerbatim("HGCalGeom") << " layertype:type:part:orien:ind " << layerType << ":" << type << ":" << part
529  << ":" << orien << ":" << i << ":" << waferPart_.size();
530 #endif
531  wafer = waferPart_[i];
532  }
533  int copy = HGCalTypes::packTypeUV(type, u, v);
534 #ifdef EDM_ML_DEBUG
535  edm::LogVerbatim("HGCalGeom") << " DDHGCalMixLayer: Layer " << HGCalWaferIndex::waferLayer(waferIndex_[k])
536  << " Wafer " << wafer << " number " << copy << " type :part:orien:ind " << type << ":"
537  << part << ":" << orien << ":" << i << " layer:u:v " << (layer + firstLayer_) << ":"
538  << u << ":" << v;
539  if (iu > ium)
540  ium = iu;
541  if (iv > ivm)
542  ivm = iv;
543  kount++;
544  if (copies_.count(copy) == 0)
545  copies_.insert(copy);
546 #endif
547  DDTranslation tran(xpos, ypos, 0.0);
548  DDName name = DDName(DDSplit(wafer).first, DDSplit(wafer).second);
549  cpv.position(name, glog.ddname(), copy, tran, rot);
550 #ifdef EDM_ML_DEBUG
551  ++ntype[type];
552  edm::LogVerbatim("HGCalGeom") << " DDHGCalMixLayer: " << name << " number " << copy << " type " << layerType << ":"
553  << type << " positioned in " << glog.ddname() << " at " << tran
554  << " with no rotation";
555 #endif
556  }
557 #ifdef EDM_ML_DEBUG
558  edm::LogVerbatim("HGCalGeom") << "DDHGCalMixLayer: Maximum # of u " << ium << " # of v " << ivm << " and " << kount
559  << " wafers (" << ntype[0] << ":" << ntype[1] << ":" << ntype[2] << ") for "
560  << glog.ddname();
561 #endif
562 }
Log< level::Info, true > LogVerbatim
std::vector< int > tileIndex_
int32_t *__restrict__ iv
void position(const DDLogicalPart &self, const DDLogicalPart &parent, const std::string &copyno, const DDTranslation &trans, const DDRotation &rot, const DDDivision *div=nullptr)
DDMaterial is used to define and access material information.
Definition: DDMaterial.h:45
int32_t waferU(const int32_t index)
int32_t waferLayer(const int32_t index)
std::vector< int > layerTypes_
std::vector< double > layerThickTop_
constexpr NumType convertRadToDeg(NumType radians)
Definition: angle_units.h:21
HGCalGeomTools geomTools_
DDName is used to identify DDD entities uniquely.
Definition: DDName.h:17
std::string to_string(const V &value)
Definition: OMSAccess.h:71
std::unordered_set< int > copies_
std::vector< int > tilePhis_
Log< level::Error, false > LogError
std::string nameSpace_
int32_t waferOrient(const int32_t property)
std::pair< double, double > shiftXY(int waferPosition, double waferSize) const
A DDSolid represents the shape of a part.
Definition: DDSolid.h:39
constexpr std::array< uint8_t, layerIndexSize > layer
std::vector< double > tileRMax_
Represents a uniquely identifyable rotation matrix.
Definition: DDTransform.h:57
U second(std::pair< T, U > const &p)
std::vector< int > copyNumberTop_
static constexpr int32_t WaferFull
Definition: HGCalTypes.h:34
std::vector< std::string > materialTop_
T sqrt(T t)
Definition: SSEVec.h:19
std::vector< int > waferIndex_
std::vector< int > waferLayerStart_
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
A DDLogicalPart aggregates information concerning material, solid and sensitveness ...
Definition: DDLogicalPart.h:93
static constexpr double tol2_
static DDSolid tubs(const DDName &name, double zhalf, double rIn, double rOut, double startPhi, double deltaPhi)
Definition: DDSolid.cc:667
int32_t waferThick(const int32_t property)
std::vector< std::string > namesTop_
ii
Definition: cuy.py:589
const N & name() const
Definition: DDBase.h:59
std::tuple< int32_t, int32_t, int32_t > tileUnpack(int32_t index)
std::vector< int > layerTypeTop_
static constexpr int32_t WaferCenteredBack
Definition: HGCalTypes.h:68
std::vector< int > tileLayerStart_
part
Definition: HCALResponse.h:20
const N & ddname() const
Definition: DDBase.h:61
std::vector< std::string > waferPart_
static constexpr int32_t CornerCenteredLambda
Definition: HGCalTypes.h:70
int32_t waferPartial(const int32_t property)
std::vector< int > waferProperty_
static constexpr int32_t CornerCenteredY
Definition: HGCalTypes.h:69
int32_t waferV(const int32_t index)
static int32_t packTypeUV(int type, int u, int v)
Definition: HGCalTypes.cc:3
std::vector< std::string > waferFull_
Log< level::Warning, false > LogWarning
std::pair< std::string, std::string > DDSplit(const std::string &n)
split into (name,namespace), separator = &#39;:&#39;
Definition: DDSplit.cc:3
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double > > DDTranslation
Definition: DDTranslation.h:7
std::vector< double > tileRMin_

Member Data Documentation

◆ absorbMode_

int DDHGCalMixLayer::absorbMode_
private

Definition at line 67 of file DDHGCalMixLayer.cc.

◆ alpha_

double DDHGCalMixLayer::alpha_
private

Definition at line 105 of file DDHGCalMixLayer.cc.

◆ copies_

std::unordered_set<int> DDHGCalMixLayer::copies_
private

Definition at line 104 of file DDHGCalMixLayer.cc.

◆ copyNumber_

std::vector<int> DDHGCalMixLayer::copyNumber_
private

Definition at line 84 of file DDHGCalMixLayer.cc.

◆ copyNumberTop_

std::vector<int> DDHGCalMixLayer::copyNumberTop_
private

Definition at line 93 of file DDHGCalMixLayer.cc.

◆ cosAlpha_

double DDHGCalMixLayer::cosAlpha_
private

Definition at line 105 of file DDHGCalMixLayer.cc.

◆ facingTypes_

int DDHGCalMixLayer::facingTypes_
private

Definition at line 62 of file DDHGCalMixLayer.cc.

◆ firstLayer_

int DDHGCalMixLayer::firstLayer_
private

Definition at line 66 of file DDHGCalMixLayer.cc.

◆ geomTools_

HGCalGeomTools DDHGCalMixLayer::geomTools_
private

Definition at line 56 of file DDHGCalMixLayer.cc.

◆ layers_

std::vector<int> DDHGCalMixLayer::layers_
private

Definition at line 85 of file DDHGCalMixLayer.cc.

◆ layerSense_

std::vector<int> DDHGCalMixLayer::layerSense_
private

Definition at line 88 of file DDHGCalMixLayer.cc.

◆ layerThick_

std::vector<double> DDHGCalMixLayer::layerThick_
private

Definition at line 86 of file DDHGCalMixLayer.cc.

◆ layerThickTop_

std::vector<double> DDHGCalMixLayer::layerThickTop_
private

Definition at line 91 of file DDHGCalMixLayer.cc.

◆ layerType_

std::vector<int> DDHGCalMixLayer::layerType_
private

Definition at line 87 of file DDHGCalMixLayer.cc.

◆ layerTypes_

std::vector<int> DDHGCalMixLayer::layerTypes_
private

Definition at line 94 of file DDHGCalMixLayer.cc.

◆ layerTypeTop_

std::vector<int> DDHGCalMixLayer::layerTypeTop_
private

Definition at line 92 of file DDHGCalMixLayer.cc.

◆ materials_

std::vector<std::string> DDHGCalMixLayer::materials_
private

Definition at line 81 of file DDHGCalMixLayer.cc.

◆ materialTop_

std::vector<std::string> DDHGCalMixLayer::materialTop_
private

Definition at line 89 of file DDHGCalMixLayer.cc.

◆ names_

std::vector<std::string> DDHGCalMixLayer::names_
private

Definition at line 82 of file DDHGCalMixLayer.cc.

◆ nameSpace_

std::string DDHGCalMixLayer::nameSpace_
private

Definition at line 103 of file DDHGCalMixLayer.cc.

◆ namesTop_

std::vector<std::string> DDHGCalMixLayer::namesTop_
private

Definition at line 90 of file DDHGCalMixLayer.cc.

◆ orientationTypes_

int DDHGCalMixLayer::orientationTypes_
private

Definition at line 64 of file DDHGCalMixLayer.cc.

◆ partialTypes_

int DDHGCalMixLayer::partialTypes_
private

Definition at line 63 of file DDHGCalMixLayer.cc.

◆ phiBinsScint_

int DDHGCalMixLayer::phiBinsScint_
private

Definition at line 65 of file DDHGCalMixLayer.cc.

◆ rMaxFront_

std::vector<double> DDHGCalMixLayer::rMaxFront_
private

Definition at line 78 of file DDHGCalMixLayer.cc.

◆ rMinFront_

std::vector<double> DDHGCalMixLayer::rMinFront_
private

Definition at line 75 of file DDHGCalMixLayer.cc.

◆ sectors_

int DDHGCalMixLayer::sectors_
private

Definition at line 72 of file DDHGCalMixLayer.cc.

◆ sensitiveMode_

int DDHGCalMixLayer::sensitiveMode_
private

Definition at line 68 of file DDHGCalMixLayer.cc.

◆ slopeB_

std::vector<double> DDHGCalMixLayer::slopeB_
private

Definition at line 73 of file DDHGCalMixLayer.cc.

◆ slopeT_

std::vector<double> DDHGCalMixLayer::slopeT_
private

Definition at line 76 of file DDHGCalMixLayer.cc.

◆ thick_

std::vector<double> DDHGCalMixLayer::thick_
private

Definition at line 83 of file DDHGCalMixLayer.cc.

◆ tileIndex_

std::vector<int> DDHGCalMixLayer::tileIndex_
private

Definition at line 100 of file DDHGCalMixLayer.cc.

◆ tileLayerStart_

std::vector<int> DDHGCalMixLayer::tileLayerStart_
private

Definition at line 102 of file DDHGCalMixLayer.cc.

◆ tilePhis_

std::vector<int> DDHGCalMixLayer::tilePhis_
private

Definition at line 101 of file DDHGCalMixLayer.cc.

◆ tileRMax_

std::vector<double> DDHGCalMixLayer::tileRMax_
private

Definition at line 99 of file DDHGCalMixLayer.cc.

◆ tileRMin_

std::vector<double> DDHGCalMixLayer::tileRMin_
private

Definition at line 98 of file DDHGCalMixLayer.cc.

◆ tol1_

constexpr double DDHGCalMixLayer::tol1_ = 0.01
staticprivate

Definition at line 58 of file DDHGCalMixLayer.cc.

◆ tol2_

constexpr double DDHGCalMixLayer::tol2_ = 0.00001
staticprivate

Definition at line 59 of file DDHGCalMixLayer.cc.

◆ waferFull_

std::vector<std::string> DDHGCalMixLayer::waferFull_
private

Definition at line 79 of file DDHGCalMixLayer.cc.

◆ waferIndex_

std::vector<int> DDHGCalMixLayer::waferIndex_
private

Definition at line 95 of file DDHGCalMixLayer.cc.

◆ waferLayerStart_

std::vector<int> DDHGCalMixLayer::waferLayerStart_
private

Definition at line 97 of file DDHGCalMixLayer.cc.

◆ waferPart_

std::vector<std::string> DDHGCalMixLayer::waferPart_
private

Definition at line 80 of file DDHGCalMixLayer.cc.

◆ waferProperty_

std::vector<int> DDHGCalMixLayer::waferProperty_
private

Definition at line 96 of file DDHGCalMixLayer.cc.

◆ waferSepar_

double DDHGCalMixLayer::waferSepar_
private

Definition at line 71 of file DDHGCalMixLayer.cc.

◆ waferSize_

double DDHGCalMixLayer::waferSize_
private

Definition at line 70 of file DDHGCalMixLayer.cc.

◆ waferTypes_

int DDHGCalMixLayer::waferTypes_
private

Definition at line 61 of file DDHGCalMixLayer.cc.

◆ zFrontB_

std::vector<double> DDHGCalMixLayer::zFrontB_
private

Definition at line 74 of file DDHGCalMixLayer.cc.

◆ zFrontT_

std::vector<double> DDHGCalMixLayer::zFrontT_
private

Definition at line 77 of file DDHGCalMixLayer.cc.

◆ zMinBlock_

double DDHGCalMixLayer::zMinBlock_
private

Definition at line 69 of file DDHGCalMixLayer.cc.