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 <vector>
#include <unordered_map>
#include <utility>

Go to the source code of this file.

Namespaces
	dd4hep

Macros
#define	EDM_ML_DEBUG

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...

Macro Definition Documentation

EDM_ML_DEBUG

#define EDM_ML_DEBUG

Definition at line 32 of file DDDefinitions2Objects.cc.

Enumeration Type Documentation

DDAxes

enum DDAxes

strong

Enumerator
x
y
z
rho
radial3D
phi
undefined

Definition at line 1691 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 1044 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);
  }
 
#ifdef EDM_ML_DEBUG
 
  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()));
 
#endif
 
  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 1852 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 2052 of file DDDefinitions2Objects.cc.

                                                            {
  xml_elt_t dddef(element);
  if (dddef) {
    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");
 
    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;
      res.unresolvedConst.reserve(2000);
      res.originalConst.reserve(6000);
      print_doc((doc = dddef.document()).root());
      xml_coll_t(dddef, DD_CMU(ConstantsSection)).for_each(Converter<ConstantsSection>(det, &context, &res));
      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.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();) {
            std::vector<double> result;
            for (const auto& i : it->second) {
              result.emplace_back(dd4hep::_toDouble(i));
            }
            registry->insert({it->first, 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) {
        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);
 
      // Can not deal with reflections without closed geometry
      det.manager().CloseGeometry();
 
      det.endDocument();
    }
    printout(INFO, "DDDefinition", "+++ Finished processing %s", fname.c_str());
    return 1;
  }
  except("DDDefinition", "+++ FAILED to process unknown DOM tree [Invalid Handle]");
  return 0;
}

References cms::DDNamespace::addConstantNS(), cms::DDNamespace::addVolume(), HLT_FULL_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, 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, RunInfoPI::valid, and cms::DDNamespace::volume().

Variable Documentation

includes

std::vector<xml::Document> includes

Definition at line 54 of file DDDefinitions2Objects.cc.

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

originalConst

std::unordered_map<std::string, std::string> originalConst

Definition at line 56 of file DDDefinitions2Objects.cc.

unresolvedConst

std::unordered_map<std::string, std::string> unresolvedConst

Definition at line 55 of file DDDefinitions2Objects.cc.