DDDefinitions2Objects.cc File Reference

#include "DD4hep/DetFactoryHelper.h"
#include "DD4hep/DetectorHelper.h"
#include "DD4hep/DD4hepUnits.h"
#include "DD4hep/GeoHandler.h"
#include "DD4hep/Printout.h"
#include "DD4hep/Plugins.h"
#include "DD4hep/detail/SegmentationsInterna.h"
#include "DD4hep/detail/DetectorInterna.h"
#include "DD4hep/detail/ObjectsInterna.h"
#include "DD4hep/MatrixHelpers.h"
#include "XML/Utilities.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"
#include "DataFormats/Math/interface/CMSUnits.h"
#include "DetectorDescription/DDCMS/interface/DDAlgoArguments.h"
#include "DetectorDescription/DDCMS/interface/DDNamespace.h"
#include "DetectorDescription/DDCMS/interface/DDParsingContext.h"
#include "DetectorDescription/DDCMS/interface/DDDetector.h"
#include "TGeoManager.h"
#include "TGeoMaterial.h"
#include <climits>
#include <iostream>
#include <iomanip>
#include <map>
#include <utility>
#include "tbb/concurrent_unordered_map.h"
#include "tbb/concurrent_vector.h"

Go to the source code of this file.

Namespaces
	dd4hep

Enumerations
enum	DDAxes {   DDAxes::x, DDAxes::y, DDAxes::z, DDAxes::rho,   DDAxes::radial3D, DDAxes::phi, DDAxes::undefined }

Functions
template<typename TYPE >
static void	convert_boolean (cms::DDParsingContext *context, xml_h element)
TGeoCombiTrans *	dd4hep::createPlacement (const Rotation3D &iRot, const Position &iTrans)
template<class InputIt , class ForwardIt , class BinOp >
void	for_each_token (InputIt first, InputIt last, ForwardIt s_first, ForwardIt s_last, BinOp binary_op)
static long	load_dddefinition (Detector &det, xml_h element)
	Converter for <DDDefinition> tags. More...

Enumeration Type Documentation

DDAxes

enum DDAxes

strong

Enumerator
x
y
z
rho
radial3D
phi
undefined

Definition at line 1539 of file DDDefinitions2Objects.cc.

{ x = 1, y = 2, z = 3, rho = 1, phi = 2, undefined };

Function Documentation

convert_boolean()

template<typename TYPE >

static void convert_boolean ( cms::DDParsingContext *  context, xml_h  element  )

static

Definition at line 1010 of file DDDefinitions2Objects.cc.

                                                                         {
  cms::DDNamespace ns(context);
  xml_dim_t e(element);
  string nam = e.nameStr();
  string solidName[2];
  Solid solids[2];
  Solid boolean;
  int cnt = 0;
  if (e.hasChild(DD_CMU(rSolid))) {
    for (xml_coll_t c(element, DD_CMU(rSolid)); cnt < 2 && c; ++c, ++cnt) {
      solidName[cnt] = c.attr<string>(_U(name));
      solids[cnt] = ns.solid(c.attr<string>(_U(name)));
    }
  } else {
    solidName[0] = e.attr<string>(DD_CMU(firstSolid));
    if ((solids[0] = ns.solid(e.attr<string>(DD_CMU(firstSolid)))).isValid())
      ++cnt;
    solidName[1] = e.attr<string>(DD_CMU(secondSolid));
    if ((solids[1] = ns.solid(e.attr<string>(DD_CMU(secondSolid)))).isValid())
      ++cnt;
  }
  if (cnt != 2) {
    except("DD4CMS", "+++ Failed to create boolean solid %s. Found only %d parts.", nam.c_str(), cnt);
  }
 
  printout(ns.context()->debug_placements ? ALWAYS : DEBUG,
           "DD4CMS",
           "+++ BooleanSolid: %s Left: %-32s Right: %-32s",
           nam.c_str(),
           ((solids[0].ptr() == nullptr) ? solidName[0].c_str() : solids[0]->GetName()),
           ((solids[1].ptr() == nullptr) ? solidName[1].c_str() : solids[1]->GetName()));
 
  if (solids[0].isValid() && solids[1].isValid()) {
    Transform3D trafo;
    Converter<DDLTransform3D>(*context->description, context, &trafo)(element);
    boolean = TYPE(solids[0], solids[1], trafo);
  } else {
    // Register it for later processing
    Transform3D trafo;
    Converter<DDLTransform3D>(*context->description, context, &trafo)(element);
    ns.context()->unresolvedShapes.emplace(nam,
                                           DDParsingContext::BooleanShape<TYPE>(solidName[0], solidName[1], trafo));
  }
  if (!boolean.isValid()) {
    // Delay processing the shape
    ns.context()->shapes.emplace(nam, dd4hep::Solid(nullptr));
  } else
    ns.addSolid(nam, boolean);
}

References cms::DDNamespace::addSolid(), HltBtagPostValidation_cff::c, cms::DDNamespace::context(), DD_CMU, DEBUG, cms::DDParsingContext::debug_placements, cms::DDParsingContext::description, MillePedeFileConverter_cfg::e, Skims_PA_cff::name, cms::DDParsingContext::shapes, cms::DDNamespace::solid(), runonSM::TYPE, and cms::DDParsingContext::unresolvedShapes.

for_each_token()

template<class InputIt , class ForwardIt , class BinOp >

void for_each_token	(	InputIt	first,
		InputIt	last,
		ForwardIt	s_first,
		ForwardIt	s_last,
		BinOp	binary_op
	)

Definition at line 1678 of file DDDefinitions2Objects.cc.

                                                                                                       {
  while (first != last) {
    const auto pos = std::find_first_of(first, last, s_first, s_last);
    binary_op(first, pos);
    if (pos == last)
      break;
    first = std::next(pos);
  }
}

References dqmdumpme::first, dqmdumpme::last, and GetRecoTauVFromDQM_MC_cff::next.

load_dddefinition()

static long load_dddefinition ( Detector &  det, xml_h  element  )

static

Converter for <DDDefinition> tags.

Unload all XML files after processing

This should be the end of all processing....close the geometry

Definition at line 1855 of file DDDefinitions2Objects.cc.

                                                            {
  cms::DDParsingContext context(&det);
  cms::DDNamespace ns(context);
  ns.addConstantNS("world_x", "101*m", "number");
  ns.addConstantNS("world_y", "101*m", "number");
  ns.addConstantNS("world_z", "450*m", "number");
  ns.addConstantNS("Air", "materials:Air", "string");
  ns.addConstantNS("Vacuum", "materials:Vacuum", "string");
  ns.addConstantNS("fm", "1e-12*m", "number");
  ns.addConstantNS("mum", "1e-6*m", "number");
 
  xml_elt_t dddef(element);
  string fname = xml::DocumentHandler::system_path(element);
  bool open_geometry = dddef.hasChild(DD_CMU(open_geometry)) ? dddef.child(DD_CMU(open_geometry)) : true;
  bool close_geometry = dddef.hasChild(DD_CMU(close_geometry)) ? dddef.hasChild(DD_CMU(close_geometry)) : true;
 
  xml_coll_t(dddef, _U(debug)).for_each(Converter<debug>(det, &context));
 
  // Here we define the order how XML elements are processed.
  // Be aware of dependencies. This can only defined once.
  // At the end it is a limitation of DOM....
  printout(INFO, "DD4CMS", "+++ Processing the CMS detector description %s", fname.c_str());
 
  xml::Document doc;
  Converter<print_xml_doc> print_doc(det, &context);
  try {
    DDRegistry res;
    print_doc((doc = dddef.document()).root());
    xml_coll_t(dddef, DD_CMU(DisabledAlgo)).for_each(Converter<disabled_algo>(det, &context, &res));
    xml_coll_t(dddef, DD_CMU(ConstantsSection)).for_each(Converter<ConstantsSection>(det, &context, &res));
    xml_coll_t(dddef, DD_CMU(VisSection)).for_each(Converter<vissection>(det, &context));
    xml_coll_t(dddef, DD_CMU(RotationSection)).for_each(Converter<RotationSection>(det, &context));
    xml_coll_t(dddef, DD_CMU(MaterialSection)).for_each(Converter<MaterialSection>(det, &context));
 
    xml_coll_t(dddef, DD_CMU(IncludeSection)).for_each(DD_CMU(Include), Converter<include_load>(det, &context, &res));
 
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      Converter<include_constants>(det, &context, &res)((doc = d).root());
    }
    // Before we continue, we have to resolve all constants NOW!
    Converter<DDRegistry>(det, &context, &res)(dddef);
    {
      DDVectorsMap* registry = context.description.load()->extension<DDVectorsMap>();
 
      printout(context.debug_constants ? ALWAYS : DEBUG,
               "DD4CMS",
               "+++ RESOLVING %ld Vectors.....",
               context.unresolvedVectors.size());
 
      while (!context.unresolvedVectors.empty()) {
        for (auto it = context.unresolvedVectors.begin(); it != context.unresolvedVectors.end();) {
          auto const& name = it->first;
          tbb::concurrent_vector<double> result;
          for (const auto& i : it->second) {
            result.emplace_back(dd4hep::_toDouble(i));
          }
          registry->insert({name, result});
          // All components are resolved
          it = context.unresolvedVectors.erase(it);
        }
      }
    }
    // Now we can process the include files one by one.....
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(MaterialSection)).for_each(Converter<MaterialSection>(det, &context));
    }
    {
      printout(context.debug_materials ? ALWAYS : DEBUG,
               "DD4CMS",
               "+++ RESOLVING %ld unknown material constituents.....",
               context.unresolvedMaterials.size());
 
      // Resolve referenced materials (if any)
 
      while (!context.unresolvedMaterials.empty()) {
        for (auto it = context.unresolvedMaterials.begin(); it != context.unresolvedMaterials.end();) {
          auto const& name = it->first;
          std::vector<bool> valid;
 
          printout(context.debug_materials ? ALWAYS : DEBUG,
                   "DD4CMS",
                   "+++ [%06ld] ----------  %s",
                   context.unresolvedMaterials.size(),
                   name.c_str());
 
          auto mat = ns.material(name);
          for (auto& mit : it->second) {
            printout(context.debug_materials ? ALWAYS : DEBUG,
                     "DD4CMS",
                     "+++           component  %-48s Fraction: %.6f",
                     mit.name.c_str(),
                     mit.fraction);
            auto fmat = ns.material(mit.name);
            if (nullptr != fmat.ptr()) {
              if (mat.ptr()->GetMaterial()->IsMixture()) {
                valid.emplace_back(true);
                static_cast<TGeoMixture*>(mat.ptr()->GetMaterial())->AddElement(fmat.ptr()->GetMaterial(), mit.fraction);
              }
            }
          }
          // All components are resolved
          if (valid.size() == it->second.size())
            it = context.unresolvedMaterials.erase(it);
          else
            ++it;
        }
        // Do it again if there are unresolved
        // materials left after this pass
      }
    }
    if (open_geometry) {
      context.geo_inited = true;
      det.init();
      ns.addVolume(det.worldVolume());
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(RotationSection)).for_each(Converter<RotationSection>(det, &context));
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(SolidSection)).for_each(Converter<SolidSection>(det, &context));
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(LogicalPartSection)).for_each(Converter<LogicalPartSection>(det, &context));
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(Algorithm)).for_each(Converter<DDLAlgorithm>(det, &context));
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(PosPartSection)).for_each(Converter<PosPartSection>(det, &context));
    }
    for (xml::Document d : res.includes) {
      print_doc((doc = d).root());
      xml_coll_t(d.root(), DD_CMU(SpecParSection)).for_each(Converter<SpecParSection>(det, &context));
    }
 
    for (xml::Document d : res.includes)
      Converter<include_unload>(det, &context, &res)(d.root());
 
    print_doc((doc = dddef.document()).root());
    // Now process the actual geometry items
    xml_coll_t(dddef, DD_CMU(SolidSection)).for_each(Converter<SolidSection>(det, &context));
    {
      // Before we continue, we have to resolve all shapes NOW!
      // Note: This only happens in a legacy DB payloads where
      // boolean shapes can be defined before thier
      // component shapes
 
      while (!context.unresolvedShapes.empty()) {
        for (auto it = context.unresolvedShapes.begin(); it != context.unresolvedShapes.end();) {
          auto const& name = it->first;
          auto const& aname = std::visit([](auto&& arg) -> std::string { return arg.firstSolidName; }, it->second);
          auto const& bname = std::visit([](auto&& arg) -> std::string { return arg.secondSolidName; }, it->second);
 
          auto const& ait = context.shapes.find(aname);
          if (ait->second.isValid()) {
            auto const& bit = context.shapes.find(bname);
            if (bit->second.isValid()) {
              dd4hep::Solid shape = std::visit(
                  [&ait, &bit](auto&& arg) -> dd4hep::Solid { return arg.make(ait->second, bit->second); }, it->second);
              context.shapes[name] = shape;
              it = context.unresolvedShapes.erase(it);
            } else
              ++it;
          } else
            ++it;
        }
      }
    }
    xml_coll_t(dddef, DD_CMU(LogicalPartSection)).for_each(Converter<LogicalPartSection>(det, &context));
    xml_coll_t(dddef, DD_CMU(Algorithm)).for_each(Converter<DDLAlgorithm>(det, &context));
    xml_coll_t(dddef, DD_CMU(PosPartSection)).for_each(Converter<PosPartSection>(det, &context));
    xml_coll_t(dddef, DD_CMU(SpecParSection)).for_each(Converter<SpecParSection>(det, &context));
  } catch (const exception& e) {
    printout(ERROR, "DD4CMS", "Exception while processing xml source:%s", doc.uri().c_str());
    printout(ERROR, "DD4CMS", "----> %s", e.what());
    throw;
  }
 
  if (close_geometry) {
    Volume wv = det.worldVolume();
    Volume geomv = ns.volume("cms:OCMS", false);
    if (geomv.isValid())
      wv.placeVolume(geomv, 1);
    Volume mfv = ns.volume("cmsMagneticField:MAGF", false);
    if (mfv.isValid())
      wv.placeVolume(mfv, 1);
    Volume mfv1 = ns.volume("MagneticFieldVolumes:MAGF", false);
    if (mfv1.isValid())
      wv.placeVolume(mfv1, 1);
 
    det.endDocument();
  }
  printout(INFO, "DDDefinition", "+++ Finished processing %s", fname.c_str());
  return 1;
}

References cms::DDNamespace::addConstantNS(), cms::DDNamespace::addVolume(), HLT_2018_cff::Algorithm, ztail::d, DD_CMU, debug, DEBUG, cms::DDParsingContext::debug_constants, cms::DDParsingContext::debug_materials, cms::DDParsingContext::description, common_cff::doc, MillePedeFileConverter_cfg::e, dqm::qstatus::ERROR, cppFunctionSkipper::exception, alignmentValidation::fname, cms::DDParsingContext::geo_inited, mps_fire::i, unpackBuffers-CaloStage2::INFO, cms::DDNamespace::material(), Skims_PA_cff::name, mps_fire::result, cms::DDParsingContext::shapes, AlCaHLTBitMon_QueryRunRegistry::string, cms::DDParsingContext::unresolvedMaterials, cms::DDParsingContext::unresolvedShapes, cms::DDParsingContext::unresolvedVectors, validateGeometry_cfg::valid, and cms::DDNamespace::volume().

Variable Documentation

allConst

tbb::concurrent_unordered_map<std::string, std::string> allConst

Definition at line 54 of file DDDefinitions2Objects.cc.

includes

tbb::concurrent_vector<xml::Document> includes

Definition at line 53 of file DDDefinitions2Objects.cc.

Referenced by edm::MergeableRunProductMetadata::preWriteRun().

originalConst

tbb::concurrent_unordered_map<std::string, std::string> originalConst

Definition at line 54 of file DDDefinitions2Objects.cc.

unresolvedConst

tbb::concurrent_unordered_map<std::string, std::string> unresolvedConst

Definition at line 54 of file DDDefinitions2Objects.cc.