DDHGCalGeom Namespace Reference

Functions
void	constructLayers (const cms::DDNamespace &ns, const std::vector< std::string > &wafers, const std::vector< std::string > &covers, const std::vector< int > &layerType, const std::vector< int > &layerSense, const std::vector< int > &maxModule, const std::vector< std::string > &names, const std::vector< std::string > &materials, std::vector< int > &copyNumber, const std::vector< double > &layerThick, const double &absorbW, const double &absorbH, const double &waferTot, const double &rMax, const double &rMaxFine, std::unordered_set< int > &copies, int firstLayer, int lastLayer, double zFront, double totalWidth, bool ignoreCenter, dd4hep::Volume &module)

Function Documentation

void DDHGCalGeom::constructLayers	(	const cms::DDNamespace &	ns,
		const std::vector< std::string > &	wafers,
		const std::vector< std::string > &	covers,
		const std::vector< int > &	layerType,
		const std::vector< int > &	layerSense,
		const std::vector< int > &	maxModule,
		const std::vector< std::string > &	names,
		const std::vector< std::string > &	materials,
		std::vector< int > &	copyNumber,
		const std::vector< double > &	layerThick,
		const double &	absorbW,
		const double &	absorbH,
		const double &	waferTot,
		const double &	rMax,
		const double &	rMaxFine,
		std::unordered_set< int > &	copies,
		int	firstLayer,
		int	lastLayer,
		double	zFront,
		double	totalWidth,
		bool	ignoreCenter,
		dd4hep::Volume &	module
	)

Definition at line 23 of file DDHGCalTBModuleX.cc.

References funct::abs(), cms::DDNamespace::addSolidNS(), cms::convert2mm(), filterCSVwithJSON::copy, PVValHelper::dx, PVValHelper::dy, cuy::ii, isotrackApplyRegressor::k, cms::DDNamespace::material(), SiStripPI::min, mergeVDriftHistosByStation::name, HGCalTypes::packTypeUV(), PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), diffTwoXMLs::r1, findQualityFiles::rr, cms::DDNamespace::solid(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), cond::impl::to_string(), tolerance, and cms::DDNamespace::volume().

Referenced by algorithm(), DDHGCalTBModule::execute(), DDHGCalModule::execute(), DDHGCalModuleAlgo::execute(), DDHGCalEEAlgo::execute(), DDHGCalHEFileAlgo::execute(), DDHGCalHEAlgo::execute(), DDHGCalEEFileAlgo::execute(), DDHGCalMixLayer::execute(), and DDHGCalSiliconModule::execute().

                                             {
    static constexpr double tolerance = 0.00001 * dd4hep::mm;
    static const double tan30deg = tan(30._deg);
    double zi(zFront), thickTot(0);
    for (int ly = firstLayer; ly <= lastLayer; ++ly) {
      int ii = layerType[ly];
      int copy = copyNumber[ii];
      double zz = zi + (0.5 * layerThick[ii]);
      double zo = zi + layerThick[ii];
      thickTot += layerThick[ii];

      std::string name = "HGCal" + names[ii] + std::to_string(copy);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << name << " Layer " << ly << ":" << ii << " Z "
                                    << cms::convert2mm(zi) << ":" << cms::convert2mm(zo) << " Thick "
                                    << cms::convert2mm(layerThick[ii]) << " Sense " << layerSense[ly];
#endif
      dd4hep::Material matter = ns.material(materials[ii]);
      dd4hep::Volume glog;
      if (layerSense[ly] == 0) {
        dd4hep::Solid solid = dd4hep::Box(absorbW, absorbH, 0.5 * layerThick[ii]);
        ns.addSolidNS(ns.prepend(name), solid);
        glog = dd4hep::Volume(solid.name(), solid, matter);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << solid.name() << " box of dimension "
                                      << cms::convert2mm(absorbW) << ":" << cms::convert2mm(absorbH) << ":"
                                      << cms::convert2mm(0.5 * layerThick[ii]);
#endif
        dd4hep::Position r1(0, 0, zz);
        module.placeVolume(glog, copy, r1);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << glog.name() << " number " << copy << " positioned in "
                                      << module.name() << " at (0,0," << cms::convert2mm(zz) << ") with no rotation";
#endif
      } else if (layerSense[ly] > 0) {
        double dx = 0.5 * waferTot;
        double dy = 3.0 * dx * tan30deg;
        double rr = 2.0 * dx * tan30deg;
        int ncol = (int)(2.0 * rMax / waferTot) + 1;
        int nrow = (int)(rMax / (waferTot * tan30deg)) + 1;
#ifdef EDM_ML_DEBUG
        int incm(0), inrm(0);
        edm::LogVerbatim("HGCalGeom") << module.name() << " Copy " << copy << " Type " << layerSense[ly] << " rout "
                                      << cms::convert2mm(rMax) << " Row " << nrow << " column " << ncol << " ncrMax "
                                      << maxModule[ly] << " Z " << cms::convert2mm(zz) << " Center " << ignoreCenter
                                      << " name " << name << " matter " << matter.name();
        int kount(0);
#endif
        if (maxModule[ly] >= 0) {
          nrow = std::min(nrow, maxModule[ly]);
          ncol = std::min(ncol, maxModule[ly]);
        }
        for (int nr = -nrow; nr <= nrow; ++nr) {
          int inr = std::abs(nr);
          for (int nc = -ncol; nc <= ncol; ++nc) {
            int inc = std::abs(nc);
            if ((inr % 2 == inc % 2) && (!ignoreCenter || nc != 0 || nr != 0)) {
              double xpos = nc * dx;
              double ypos = nr * dy;
              double xc[6], yc[6];
              xc[0] = xpos + dx;
              yc[0] = ypos - 0.5 * rr;
              xc[1] = xpos + dx;
              yc[1] = ypos + 0.5 * rr;
              xc[2] = xpos;
              yc[2] = ypos + rr;
              xc[3] = xpos - dx;
              yc[3] = ypos + 0.5 * rr;
              xc[4] = xpos + dx;
              yc[4] = ypos - 0.5 * rr;
              xc[5] = xpos;
              yc[5] = ypos - rr;
              bool cornerAll(true);
              for (int k = 0; k < 6; ++k) {
                double rpos = std::sqrt(xc[k] * xc[k] + yc[k] * yc[k]);
                if (rpos > rMax)
                  cornerAll = false;
              }
              if (cornerAll) {
                double rpos = std::sqrt(xpos * xpos + ypos * ypos);
                dd4hep::Position tran(xpos, ypos, zz);
                int copyx = HGCalTypes::packTypeUV(0, nc, nr);
                if (layerSense[ly] == 1) {
                  dd4hep::Solid solid = ns.solid(covers[0]);
                  std::string name0 = name + "M" + std::to_string(copyx);
                  name0 = ns.prepend(name0);
                  dd4hep::Volume glog1 = dd4hep::Volume(name0, solid, matter);
                  module.placeVolume(glog1, copy, tran);
#ifdef EDM_ML_DEBUG
                  edm::LogVerbatim("HGCalGeom")
                      << "DDHGCalTBModuleX: " << glog1.name() << " number " << copy << " positioned in "
                      << module.name() << " at (" << cms::convert2mm(xpos) << "," << cms::convert2mm(ypos) << ","
                      << cms::convert2mm(zz) << ") with no rotation";
#endif
                  dd4hep::Volume glog2 = (rpos < rMaxFine) ? ns.volume(wafers[0]) : ns.volume(wafers[1]);
                  glog1.placeVolume(glog2, copyx);
#ifdef EDM_ML_DEBUG
                  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << glog2.name() << " number " << copyx
                                                << " positioned in " << glog1.name() << " at (0,0,0) with no rotation";
#endif
                  if (layerSense[ly] == 1)
                    copies.insert(copy);
                } else {
                  dd4hep::Volume glog2 = ns.volume(covers[layerSense[ly] - 1]);
                  copyx += (copy * 1000000);
                  module.placeVolume(glog2, copyx, tran);
#ifdef EDM_ML_DEBUG
                  edm::LogVerbatim("HGCalGeom")
                      << "DDHGCalTBModuleX: " << glog2.name() << " number " << copyx << " positioned in "
                      << module.name() << " at (" << cms::convert2mm(xpos) << "," << cms::convert2mm(ypos) << ","
                      << cms::convert2mm(zz) << ") with no rotation";
#endif
                }
#ifdef EDM_ML_DEBUG
                if (inc > incm)
                  incm = inc;
                if (inr > inrm)
                  inrm = inr;
                kount++;
#endif
              }
            }
          }
        }
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: # of columns " << incm << " # of rows " << inrm << " and "
                                      << kount << " wafers for " << module.name();
#endif
      }
      ++copyNumber[ii];
      zi = zo;
    }  // End of loop over layers in a block

    if (fabs(thickTot - totalWidth) > tolerance) {
      if (thickTot > totalWidth) {
        edm::LogError("HGCalGeom") << "Thickness of the partition " << cms::convert2mm(totalWidth)
                                   << " is smaller than " << cms::convert2mm(thickTot)
                                   << ": total thickness of all its components in " << module.name() << " Layers "
                                   << firstLayer << ":" << lastLayer << ":" << ignoreCenter << "**** ERROR ****";
      } else {
        edm::LogWarning("HGCalGeom") << "Thickness of the partition " << cms::convert2mm(totalWidth)
                                     << " does not match with " << cms::convert2mm(thickTot) << " of the components in "
                                     << module.name() << " Layers " << firstLayer << ":" << lastLayer << ":"
                                     << ignoreCenter;
      }
    }
  }