DDHGCalTBModuleX.cc File Reference

#include <unordered_set>
#include "DataFormats/Math/interface/angle_units.h"
#include "DD4hep/DetFactoryHelper.h"
#include "DetectorDescription/Core/interface/DDSplit.h"
#include "DetectorDescription/DDCMS/interface/DDPlugins.h"
#include "DetectorDescription/DDCMS/interface/DDutils.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "Geometry/HGCalCommonData/interface/HGCalTypes.h"

Go to the source code of this file.

Namespaces
	DDHGCalGeom

Functions
static long	algorithm (dd4hep::Detector &, cms::DDParsingContext &ctxt, xml_h e)
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)
	DD4HEP_OPEN_PLUGIN (dd4hep, ddcms_det_element_DDCMS_hgcal_DDHGCalTBModuleX)

Function Documentation

algorithm()

static long algorithm ( dd4hep::Detector &  , cms::DDParsingContext &  ctxt, xml_h  e  )

static

Definition at line 193 of file DDHGCalTBModuleX.cc.

References cms::DDNamespace::addSolidNS(), writedatasetfile::args, DDHGCalGeom::constructLayers(), cms::convert2mm(), DDSplit(), MillePedeFileConverter_cfg::e, dqmdumpme::first, mps_fire::i, versionedElectronIDProducer_cfi::idName, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, cms::DDNamespace::name(), names, class-composition::parent, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), photonAnalyzer_cfi::rMax, cms::s_executed, AlCaHLTBitMon_QueryRunRegistry::string, to_string(), cms::DDNamespace::volume(), and geometryCSVtoXML::zz.

                                                                             {
  cms::DDNamespace ns(ctxt, e, true);
  cms::DDAlgoArguments args(ctxt, e);

  const auto& wafers = args.value<std::vector<std::string> >("WaferName");  // Wafers
  const auto& covers = args.value<std::vector<std::string> >("CoverName");  // Insensitive layers of hexagonal size
  const auto& genMat = args.value<std::string>("GeneralMaterial");          // General material used for blocks
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: Material " << genMat << " with " << wafers.size() << " wafers";
  unsigned int i(0);
  for (auto wafer : wafers) {
    edm::LogVerbatim("HGCalGeom") << "Wafer[" << i << "] " << wafer;
    ++i;
  }
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << covers.size() << " covers";
  i = 0;
  for (auto cover : covers) {
    edm::LogVerbatim("HGCalGeom") << "Cover[" << i << "] " << cover;
    ++i;
  }
#endif
  const auto& materials = args.value<std::vector<std::string> >("MaterialNames");  // Material names in each layer
  const auto& names = args.value<std::vector<std::string> >("VolumeNames");        // Names of each layer
  const auto& layerThick = args.value<std::vector<double> >("Thickness");          // Thickness of the material
  std::vector<int> copyNumber;                                                     // Copy numbers (initiated to 1)
  copyNumber.resize(materials.size(), 1);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << materials.size() << " types of volumes";
  for (unsigned int i = 0; i < names.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << names[i] << " of thickness "
                                  << cms::convert2mm(layerThick[i]) << " filled with " << materials[i]
                                  << " first copy number " << copyNumber[i];
#endif
  const auto& blockThick = args.value<std::vector<double> >("BlockThick");   // Thickness of each section
  const auto& inOut = args.value<int>("InOut");                              // Number of inner+outer parts
  const auto& layerFrontIn = args.value<std::vector<int> >("LayerFrontIn");  // First layer index (inner) in block
  const auto& layerBackIn = args.value<std::vector<int> >("LayerBackIn");    // Last layer index (inner) in block
  std::vector<int> layerFrontOut;                                            // First layer index (outner) in block
  std::vector<int> layerBackOut;                                             // Last layer index (outner) in block
  if (inOut > 1) {
    layerFrontOut = args.value<std::vector<int> >("LayerFrontOut");
    layerBackOut = args.value<std::vector<int> >("LayerBackOut");
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << blockThick.size() << " blocks with in/out " << inOut;
  for (unsigned int i = 0; i < blockThick.size(); ++i) {
    if (inOut > 1)
      edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] of thickness " << cms::convert2mm(blockThick[i])
                                    << " with inner layers " << layerFrontIn[i] << ":" << layerBackIn[i]
                                    << " and outer layers " << layerFrontOut[i] << ":" << layerBackOut[i];
    else
      edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] of thickness " << cms::convert2mm(blockThick[i])
                                    << " with inner layers " << layerFrontIn[i] << ":" << layerBackIn[i];
  }
#endif
  const auto& layerType = args.value<std::vector<int> >("LayerType");    // Type of the layer
  const auto& layerSense = args.value<std::vector<int> >("LayerSense");  // Content of a layer
  const auto& maxModule = args.value<std::vector<int> >("MaxModule");    // Maximum # of row/column
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << layerType.size() << " layers";
  for (unsigned int i = 0; i < layerType.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Layer [" << i << "] with material type " << layerType[i] << " sensitive class "
                                  << layerSense[i] << " and " << maxModule[i] << " maximum row/columns";
#endif
  const auto& zMinBlock = args.value<double>("zMinBlock");  // Starting z-value of the block
  const auto& rMaxFine = args.value<double>("rMaxFine");    // Maximum r-value for fine wafer
  const auto& waferW = args.value<double>("waferW");        // Width of the wafer
  const auto& waferGap = args.value<double>("waferGap");    // Gap between 2 wafers
  const auto& absorbW = args.value<double>("absorberW");    // Width of the absorber
  const auto& absorbH = args.value<double>("absorberH");    // Height of the absorber
  const auto& rMax = args.value<double>("rMax");            // Maximum radial extent
  const auto& rMaxB = args.value<double>("rMaxB");          // Maximum radial extent of a block
  double waferTot = waferW + waferGap;
  std::string idName = DDSplit(args.parentName()).first;
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: zStart " << cms::convert2mm(zMinBlock) << " rFineCoarse "
                                << cms::convert2mm(rMaxFine) << " wafer width " << cms::convert2mm(waferW)
                                << " gap among wafers " << cms::convert2mm(waferGap) << " absorber width "
                                << cms::convert2mm(absorbW) << " absorber height " << cms::convert2mm(absorbH)
                                << " rMax " << cms::convert2mm(rMax) << ":" << cms::convert2mm(rMaxB);
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: NameSpace " << ns.name() << " Parent Name " << idName;
#endif
  std::unordered_set<int> copies;  // List of copy #'s
  copies.clear();

  dd4hep::Volume parent = ns.volume(args.parentName());
  double zi(zMinBlock);
  for (unsigned int i = 0; i < blockThick.size(); i++) {
    double zo = zi + blockThick[i];
    std::string name = idName + "Block" + std::to_string(i);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: Block " << i << ":" << name << " z " << cms::convert2mm(zi)
                                  << ":" << cms::convert2mm(zo) << " R " << cms::convert2mm(rMaxB) << " T "
                                  << cms::convert2mm(blockThick[i]);
#endif
    dd4hep::Material matter = ns.material(genMat);
    dd4hep::Solid solid = dd4hep::Tube(0, rMaxB, 0.5 * blockThick[i], 0.0, 2._pi);
    ns.addSolidNS(ns.prepend(name), solid);
    dd4hep::Volume glog = dd4hep::Volume(solid.name(), solid, matter);
    double zz = zi + 0.5 * blockThick[i];
    dd4hep::Position r1(0, 0, zz);
    parent.placeVolume(glog, i, r1);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: " << glog.name() << " number " << i << " positioned in "
                                  << args.parentName() << " at (0,0," << cms::convert2mm(zz) << ") with no rotation";
    edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: \t\tInside Block " << i << " Layers " << layerFrontIn[i] << ":"
                                  << layerBackIn[i] << " zFront " << -cms::convert2mm(0.5 * blockThick[i])
                                  << " thickness " << cms::convert2mm(blockThick[i]) << " ignore Center 0";
#endif
    DDHGCalGeom::constructLayers(ns,
                                 wafers,
                                 covers,
                                 layerType,
                                 layerSense,
                                 maxModule,
                                 names,
                                 materials,
                                 copyNumber,
                                 layerThick,
                                 absorbW,
                                 absorbH,
                                 waferTot,
                                 rMax,
                                 rMaxFine,
                                 copies,
                                 layerFrontIn[i],
                                 layerBackIn[i],
                                 -0.5 * blockThick[i],
                                 blockThick[i],
                                 false,
                                 glog);
    if (inOut > 1) {
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: \t\tInside Block " << i << " Layers " << layerFrontOut[i]
                                    << ":" << layerBackOut[i] << " zFront " << -cms::convert2mm(0.5 * blockThick[i])
                                    << " thickness " << cms::convert2mm(blockThick[i]) << " ignore Center 1";
#endif
      DDHGCalGeom::constructLayers(ns,
                                   wafers,
                                   covers,
                                   layerType,
                                   layerSense,
                                   maxModule,
                                   names,
                                   materials,
                                   copyNumber,
                                   layerThick,
                                   absorbW,
                                   absorbH,
                                   waferTot,
                                   rMax,
                                   rMaxFine,
                                   copies,
                                   layerFrontOut[i],
                                   layerBackOut[i],
                                   -0.5 * blockThick[i],
                                   blockThick[i],
                                   true,
                                   glog);
    }
    zi = zo;
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalTBModuleX: All blocks are placed in " << cms::convert2mm(zMinBlock) << ":"
                                << cms::convert2mm(zi) << " with " << copies.size() << " different wafer copy numbers";
#endif

  return cms::s_executed;
}

DD4HEP_OPEN_PLUGIN()

DD4HEP_OPEN_PLUGIN	(	dd4hep	,
		ddcms_det_element_DDCMS_hgcal_DDHGCalTBModuleX
	)

Definition at line 364 of file DDHGCalTBModuleX.cc.