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 "XML/Utilities.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"
#include "DataFormats/Math/interface/GeantUnits.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)
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

enum DDAxes

strong

Enumerator
x
y
z
rho
radial3D
phi
undefined

Definition at line 1137 of file DDDefinitions2Objects.cc.

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

Function Documentation

template<typename TYPE >

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

static

Definition at line 750 of file DDDefinitions2Objects.cc.

References cms::DDNamespace::addSolid(), cms::DDNamespace::attr(), EnergyCorrector::c, cms::DDNamespace::context(), DD_CMU, DEBUG, cms::DDParsingContext::debug_placements, cms::DDParsingContext::debug_shapes, hiPixelPairStep_cff::deltaPhi, cms::DDParsingContext::description, common_cff::doc, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, MillePedeFileConverter_cfg::e, HGCalGeometryMode::ExtrudedPolygon, alignmentValidation::fname, includes, interestingEgammaIsoDetIdsSequence_cff::innerRadius, M_PI, interestingEgammaIsoDetIdsSequence_cff::outerRadius, phi, HGCalGeometryMode::Polyhedra, EnergyCorrector::pt, alignCSCRings::r, TCMET_cfi::radius, hfnoseDigiStudy_cfi::rMax, hfnoseDigiStudy_cfi::rMin, Scenarios_cff::scale, cms::DDNamespace::solid(), theta(), x, y, and z.

                                                                         {
  cms::DDNamespace ns(context);
  xml_dim_t   e(element);
  string      nam = e.nameStr();
  Solid       solids[2];
  Solid       boolean;
  int cnt = 0;

  if( e.hasChild(DD_CMU(rSolid)) )  {   // Old version
    for(xml_coll_t c(element, DD_CMU(rSolid)); cnt<2 && c; ++c, ++cnt)
      solids[cnt] = ns.solid(c.attr<string>(_U(name)));
  }
  else  {
    if( (solids[0] = ns.solid(e.attr<string>(DD_CMU(firstSolid)))).isValid() ) ++cnt;
    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]->GetName(), 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);
  }
  if( !boolean.isValid() )
    except("DD4CMS","+++ FAILED to construct subtraction solid: %s",nam.c_str());
  ns.addSolid(nam,boolean);
}

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 1248 of file DDDefinitions2Objects.cc.

References cms::DDNamespace::attr(), cms::DDNamespace::context(), KineDebug3::count(), DD_CMU, DEBUG, cms::DDParsingContext::debug_algorithms, cms::DDParsingContext::debug_constants, cms::DDParsingContext::debug_includes, cms::DDParsingContext::debug_materials, cms::DDParsingContext::debug_namespaces, cms::DDParsingContext::debug_placements, cms::DDParsingContext::debug_rotations, cms::DDParsingContext::debug_shapes, cms::DDParsingContext::debug_specpars, cms::DDParsingContext::debug_visattr, cms::DDParsingContext::debug_volumes, cms::DDParsingContext::description, MillePedeFileConverter_cfg::e, dqm::qstatus::ERROR, plotBeamSpotDB::first, alignmentValidation::fname, mps_fire::i, training_settings::idx, gen::n, dataset::name, GetRecoTauVFromDQM_MC_cff::next, convertSQLitetoXML_cfg::output, alignCSCRings::r, cuy::rep, edm::second(), cms::DDNamespace::setContext(), and str.

{
  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 );
  }
}

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 1372 of file DDDefinitions2Objects.cc.

References cms::DDNamespace::addConstantNS(), cms::DDNamespace::addVolume(), DefaultClusterizer_cff::Algorithm, edmIntegrityCheck::d, DD_CMU, debug, common_cff::doc, dqm::qstatus::ERROR, cppFunctionSkipper::exception, alignmentValidation::fname, MessageLogger_cfi::INFO, and pyrootRender::root.

                                                            {
  cms::DDParsingContext context(&det);
  cms::DDNamespace ns(context);
  ns.addConstantNS("world_x", "5*m", "number");
  ns.addConstantNS("world_y", "5*m", "number");
  ns.addConstantNS("world_z", "5*m", "number");
  ns.addConstantNS("Air", "materials:Air", "string");
  ns.addConstantNS("Vacuum", "materials:Vacuum", "string");
  ns.addConstantNS("fm", "1e-12*m", "number");
  
  xml_elt_t dddef(element);
  string fname = xml::DocumentHandler::system_path(element);
  bool open_geometry  = dddef.hasChild(DD_CMU(open_geometry));
  bool close_geometry = dddef.hasChild(DD_CMU(close_geometry));

  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);
    // 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));
    }
    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));
    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) {
    det.endDocument();
  }
  printout(INFO,"DDDefinition","+++ Finished processing %s",fname.c_str());
  return 1;
}

Variable Documentation

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

Definition at line 52 of file DDDefinitions2Objects.cc.

tbb::concurrent_vector<xml::Document> includes

Definition at line 51 of file DDDefinitions2Objects.cc.

Referenced by convert_boolean(), and edm::MergeableRunProductMetadata::preWriteRun().

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

Definition at line 52 of file DDDefinitions2Objects.cc.

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

Definition at line 52 of file DDDefinitions2Objects.cc.