#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/Exception.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>

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

static void	placeAssembly (Volume parentPtr, const string &parentName, Volume childPtr, const string &childName, int copy, const Transform3D &transform, cms::DDNamespace &ns)

Enumeration Type Documentation

enum DDAxes

strong

Enumerator
x
y
z
rho
radial3D
phi
undefined

Definition at line 1798 of file DDDefinitions2Objects.cc.

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

HLT_FULL_cff.rho

tuple rho

Definition: HLT_FULL_cff.py:66594

PVValHelper::phi

Definition: PVValidationHelpers.h:69

detailsBasic3DVector::z

float float float z

Definition: extBasic3DVector.h:14

detailsBasic3DVector::y

float float y

Definition: extBasic3DVector.h:14

DDAxes::undefined

x

float x

Definition: beamSpotDipStandalone.cc:55

Function Documentation

template<typename TYPE >

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

static

Definition at line 1129 of file DDDefinitions2Objects.cc.

References cms::DDNamespace::addSolid(), c, visDQMUpload::context, cms::DDNamespace::context(), DD_CMU, DEBUG, cms::DDParsingContext::debug_placements, cms::DDParsingContext::description, alignCSCRings::e, dqm::qstatus::ERROR, sistrip::SpyUtilities::isValid(), cms::DDParsingContext::shapes, cms::DDNamespace::solid(), runonSM::TYPE, and cms::DDParsingContext::unresolvedShapes.

                                                                          {
   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 (solids[0].isValid() == false) {
       printout(ERROR, "DD4CMS", "++ Solid not defined yet: %s", solidName[0].c_str());
     }
     if (solids[1].isValid() == false) {
       printout(ERROR, "DD4CMS", "++ Solid not defined yet: %s", solidName[1].c_str());
     }
     printout(ERROR, "DD4CMS", "++ Re-order XML files to prevent references to undefined solids");
   }
   if (!boolean.isValid()) {
     // Delay processing the shape
     ns.context()->shapes.emplace(nam, dd4hep::Solid(nullptr));
   } else
     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 1958 of file DDDefinitions2Objects.cc.

References GetRecoTauVFromDQM_MC_cff::next.

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

References visDQMUpload::context, ztail::d, DD_CMU, debug, dqm::qstatus::ERROR, cppFunctionSkipper::exception, mps_fire::i, dtDQMClient_cfg::INFO, mergeVDriftHistosByStation::name, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and gpuVertexFinder::wv.

                                                             {
   xml_elt_t dddef(element);
   if (dddef) {
     cms::DDParsingContext& context = *det.extension<DDParsingContext>();
     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");
 
     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));
       }
       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;
 }

static void placeAssembly	(	Volume *	parentPtr,
		const string &	parentName,
		Volume *	childPtr,
		const string &	childName,
		int	copy,
		const Transform3D &	transform,
		cms::DDNamespace &	ns
	)

static

Definition at line 867 of file DDDefinitions2Objects.cc.

References cms::DDNamespace::assembly(), cms::DDNamespace::context(), filterCSVwithJSON::copy, DEBUG, cms::DDParsingContext::debug_placements, geometryDiff::epsilon, dqm::qstatus::ERROR, dqmiodumpmetadata::n, MetAnalyzer::pv(), and HcalDetIdTransform::transform().

                                               {
 #ifdef EDM_ML_DEBUG
 
   printout(ns.context()->debug_placements ? ALWAYS : DEBUG,
            "DD4CMS",
            "+++ Parent vol: %-24s Child: %-32s, copy:%d",
            parentName.c_str(),
            childName.c_str(),
            copy);
 
 #endif
 
   TGeoShape* shape = (*childPtr)->GetShape();
   // Need to fix the daughter's BBox of assemblies, if the BBox was not calculated....
   if (shape->IsA() == TGeoShapeAssembly::Class()) {
     TGeoShapeAssembly* as = (TGeoShapeAssembly*)shape;
     if (std::fabs(as->GetDX()) < numeric_limits<double>::epsilon() &&
         std::fabs(as->GetDY()) < numeric_limits<double>::epsilon() &&
         std::fabs(as->GetDZ()) < numeric_limits<double>::epsilon()) {
       as->NeedsBBoxRecompute();
       as->ComputeBBox();
     }
   }
   TGeoNode* n;
   TString nam_id = TString::Format("%s_%d", (*childPtr)->GetName(), copy);
   n = static_cast<TGeoNode*>((*parentPtr)->GetNode(nam_id));
   if (n != nullptr) {
     printout(ERROR, "PlacedVolume", "++ Attempt to add already existing node %s", (const char*)nam_id);
     return;
   }
 
   PlacedVolume pv;
   if ((*childPtr)->IsAssembly()) {
     pv = parentPtr->placeVolume(ns.assembly(childName), copy, transform);
   } else {
     pv = parentPtr->placeVolume(*childPtr, copy, transform);
   }
 
   if (!pv.isValid()) {
     printout(ERROR, "DD4CMS", "+++ Placement FAILED! Parent:%s Child:%s", parentName.c_str(), childName.c_str());
   }
 }

Variable Documentation

std::vector<xml::Document> includes

Definition at line 55 of file DDDefinitions2Objects.cc.

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

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

Definition at line 57 of file DDDefinitions2Objects.cc.

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

Definition at line 56 of file DDDefinitions2Objects.cc.

Namespaces

Enumerations

Functions

Enumeration Type Documentation

Function Documentation

Variable Documentation