DDDefinitions2Objects.cpp

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
//
// DDCMS is a detector description convention developed by the CMS experiment.
//
//==========================================================================

// Framework includes
#include "DD4hep/DetFactoryHelper.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 "DDCMS/DDCMS.h"

// Root/TGeo include files
#include "TGeoManager.h"
#include "TGeoMaterial.h"

// C/C++ include files
#include <climits>
#include <iostream>
#include <iomanip>
#include <set>
#include <map>

using namespace std;
using namespace dd4hep;
using namespace dd4hep::cms;

/// Namespace for the AIDA detector description toolkit
namespace dd4hep {

  namespace {

    static UInt_t unique_mat_id = 0xAFFEFEED;

    class include_constants;
    class include_load;
    class include_unload;
    class print_xml_doc;
    class constantssection;
    class constant;
    class resolve   {
    public:
      std::vector<xml::Document> includes;
      std::map<std::string,std::string>  unresolvedConst, allConst, originalConst;
    };

    class materialsection;
    class elementarymaterial;
    class compositematerial;
  
    class rotationsection;
    class rotation;
    class transform3d;

    class pospartsection;
    class pospart;

    class logicalpartsection;
    class logicalpart;

    class solidsection;
    class trapezoid;
    class polycone;
    class torus;
    class tubs;
    class box;
    class unionsolid;
    class intersectionsolid;
    class subtractionsolid;
    
    class algorithm;    

    class vissection;
    class vis_apply;
    class vis;
    class debug;
  }

  /// Converter instances implemented in this compilation unit
  template <> void Converter<debug>::operator()(xml_h element) const;
  template <> void Converter<print_xml_doc>::operator()(xml_h element) const;

  /// Converter for <ConstantsSection/> tags
  template <> void Converter<constantssection>::operator()(xml_h element) const;
  template <> void Converter<constant>::operator()(xml_h element) const;
  template <> void Converter<resolve>::operator()(xml_h element) const;

  /// Converter for <VisSection/> tags
  template <> void Converter<vissection>::operator()(xml_h element) const;
  template <> void Converter<vis_apply>::operator()(xml_h element) const;
  template <> void Converter<vis>::operator()(xml_h element) const;

  /// Converter for <MaterialSection/> tags
  template <> void Converter<materialsection>::operator()(xml_h element) const;
  template <> void Converter<elementarymaterial>::operator()(xml_h element) const;
  template <> void Converter<compositematerial>::operator()(xml_h element) const;

  /// Converter for <RotationSection/> tags
  template <> void Converter<rotationsection>::operator()(xml_h element) const;
  /// Converter for <Rotation/> tags
  template <> void Converter<rotation>::operator()(xml_h element) const;
  template <> void Converter<transform3d>::operator()(xml_h element) const;

  /// Generic converter for  <LogicalPartSection/> tags
  template <> void Converter<logicalpartsection>::operator()(xml_h element) const;
  template <> void Converter<logicalpart>::operator()(xml_h element) const;

  template <> void Converter<pospartsection>::operator()(xml_h element) const;
  /// Converter for <PosPart/> tags
  template <> void Converter<pospart>::operator()(xml_h element) const;

  /// Generic converter for solids: <SolidSection/> tags
  template <> void Converter<solidsection>::operator()(xml_h element) const;
  /// Converter for <UnionSolid/> tags
  template <> void Converter<unionsolid>::operator()(xml_h element) const;
  /// Converter for <SubtractionSolid/> tags
  template <> void Converter<subtractionsolid>::operator()(xml_h element) const;
  /// Converter for <IntersectionSolid/> tags
  template <> void Converter<intersectionsolid>::operator()(xml_h element) const;
  /// Converter for <Trapezoid/> tags
  template <> void Converter<trapezoid>::operator()(xml_h element) const;
  /// Converter for <Polycone/> tags
  template <> void Converter<polycone>::operator()(xml_h element) const;
  /// Converter for <Torus/> tags
  template <> void Converter<torus>::operator()(xml_h element) const;
  /// Converter for <Tubs/> tags
  template <> void Converter<tubs>::operator()(xml_h element) const;
  /// Converter for <Box/> tags
  template <> void Converter<box>::operator()(xml_h element) const;

  /// Converter for <Algorithm/> tags
  template <> void Converter<algorithm>::operator()(xml_h element) const;

  /// DD4hep specific: Load include file
  template <> void Converter<include_load>::operator()(xml_h element) const;
  /// DD4hep specific: Unload include file
  template <> void Converter<include_unload>::operator()(xml_h element) const;
  /// DD4hep specific: Process constants objects
  template <> void Converter<include_constants>::operator()(xml_h element) const;
}

/// Converter for <ConstantsSection/> tags
template <> void Converter<constantssection>::operator()(xml_h element) const  {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(Constant)).for_each(Converter<constant>(description,_ns.context,optional));
}

/// Converter for <VisSection/> tags
template <> void Converter<vissection>::operator()(xml_h element) const  {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(vis)).for_each(Converter<vis>(description,_ns.context,optional));
}

/// Converter for <MaterialSection/> tags
template <> void Converter<materialsection>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(ElementaryMaterial)).for_each(Converter<elementarymaterial>(description,_ns.context,optional));
  xml_coll_t(element, _CMU(CompositeMaterial)).for_each(Converter<compositematerial>(description,_ns.context,optional));
}

template <> void Converter<rotationsection>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(Rotation)).for_each(Converter<rotation>(description,_ns.context,optional));
}

template <> void Converter<pospartsection>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(PosPart)).for_each(Converter<pospart>(description,_ns.context,optional));
}

/// Generic converter for  <LogicalPartSection/> tags
template <> void Converter<logicalpartsection>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>(), element);
  xml_coll_t(element, _CMU(LogicalPart)).for_each(Converter<logicalpart>(description,_ns.context,optional));
}

/// Generic converter for  <SolidSection/> tags
template <> void Converter<solidsection>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>(), element);
  for(xml_coll_t solid(element, _U(star)); solid; ++solid)   {
    string tag = solid.tag();
    if ( tag == "Box" )
      Converter<box>(description,_ns.context,optional)(solid);
    else if ( tag == "Polycone" )
      Converter<polycone>(description,_ns.context,optional)(solid);
    else if ( tag == "Tubs" )
      Converter<tubs>(description,_ns.context,optional)(solid);
    else if ( tag == "Torus" )
      Converter<torus>(description,_ns.context,optional)(solid);
    else if ( tag == "Trapezoid" )
      Converter<trapezoid>(description,_ns.context,optional)(solid);
    else if ( tag == "UnionSolid" )
      Converter<unionsolid>(description,_ns.context,optional)(solid);
    else if ( tag == "SubtractionSolid" )
      Converter<subtractionsolid>(description,_ns.context,optional)(solid);
    else if ( tag == "IntersectionSolid" )
      Converter<intersectionsolid>(description,_ns.context,optional)(solid);
    else  {
      string nam = xml_dim_t(solid).nameStr();
      printout(ERROR,"DDCMS","+++ Request to process unknown shape %s [%s]",
               nam.c_str(), tag.c_str());
    }
  }
}

/// Converter for <Constant/> tags
template <> void Converter<constant>::operator()(xml_h element) const  {
  Namespace _ns(_param<ParsingContext>());
  resolve*  res  = _option<resolve>();
  xml_dim_t constant = element;
  xml_dim_t par  = constant.parent();
  bool      eval = par.hasAttr(_U(eval)) ? par.attr<bool>(_U(eval)) : false;
  string    val  = constant.valueStr();
  string    nam  = constant.nameStr();
  string    real = _ns.prepend(nam);
  string    typ  = eval ? "number" : "string";
  size_t    idx  = val.find('[');
  
  if ( constant.hasAttr(_U(type)) )
    typ = constant.typeStr();

  if ( idx == string::npos || typ == "string" )  {
    try  {
      _ns.addConstant(nam, val, typ);
      res->allConst[real] = val;
      res->originalConst[real] = val;
    }
    catch(const exception& e)   {
      printout(INFO,"DDCMS","++ Unresolved constant: %s = %s [%s]. Try to resolve later. [%s]",
               real.c_str(), val.c_str(), typ.c_str(), e.what());
    }
    return;
  }
  // Setup the resolution mechanism in Converter<resolve>
  while ( idx != string::npos )  {
    ++idx;
    size_t idp = val.find(':',idx);
    size_t idq = val.find(']',idx);
    if ( idp == string::npos || idp > idq )
      val.insert(idx,_ns.name);
    else if ( idp != string::npos && idp < idq )
      val[idp] = '_';
    idx = val.find('[',idx);
  }
  while ( (idx=val.find(':')) != string::npos ) val[idx]='_';
  printout(_ns.context->debug_constants ? ALWAYS : DEBUG,
           "Constant","Unresolved: %s -> %s",real.c_str(),val.c_str());
  res->allConst[real] = val;
  res->originalConst[real] = val;
  res->unresolvedConst[real] = val;
}

/** Convert compact visualization attribute to Detector visualization attribute
 *
 *  <vis name="SiVertexBarrelModuleVis"
 *       alpha="1.0" r="1.0" g="0.75" b="0.76"
 *       drawingStyle="wireframe"
 *       showDaughters="false"
 *       visible="true"/>
 */
template <> void Converter<vis>::operator()(xml_h e) const {
  Namespace _ns(_param<ParsingContext>());
  VisAttr attr(e.attr<string>(_U(name)));
  float red   = e.hasAttr(_U(r)) ? e.attr<float>(_U(r)) : 1.0f;
  float green = e.hasAttr(_U(g)) ? e.attr<float>(_U(g)) : 1.0f;
  float blue  = e.hasAttr(_U(b)) ? e.attr<float>(_U(b)) : 1.0f;

  printout(_ns.context->debug_visattr ? ALWAYS : DEBUG, "Compact",
           "++ Converting VisAttr  structure: %-16s. R=%.3f G=%.3f B=%.3f",
           attr.name(), red, green, blue);
  attr.setColor(red, green, blue);
  if (e.hasAttr(_U(alpha)))
    attr.setAlpha(e.attr<float>(_U(alpha)));
  if (e.hasAttr(_U(visible)))
    attr.setVisible(e.attr<bool>(_U(visible)));
  if (e.hasAttr(_U(lineStyle))) {
    string ls = e.attr<string>(_U(lineStyle));
    if (ls == "unbroken")
      attr.setLineStyle(VisAttr::SOLID);
    else if (ls == "broken")
      attr.setLineStyle(VisAttr::DASHED);
  }
  else {
    attr.setLineStyle(VisAttr::SOLID);
  }
  if (e.hasAttr(_U(drawingStyle))) {
    string ds = e.attr<string>(_U(drawingStyle));
    if (ds == "wireframe")
      attr.setDrawingStyle(VisAttr::WIREFRAME);
    else if (ds == "solid")
      attr.setDrawingStyle(VisAttr::SOLID);
  }
  else {
    attr.setDrawingStyle(VisAttr::SOLID);
  }
  if (e.hasAttr(_U(showDaughters)))
    attr.setShowDaughters(e.attr<bool>(_U(showDaughters)));
  else
    attr.setShowDaughters(true);
  description.addVisAttribute(attr);
}

/// Converter for <ElementaryMaterial/> tags
template <> void Converter<elementarymaterial>::operator()(xml_h element) const   {
  Namespace     _ns(_param<ParsingContext>());
  xml_dim_t     xmat(element);
  string        nam = _ns.prepend(xmat.nameStr());
  TGeoManager&  mgr = description.manager();
  TGeoMaterial* mat = mgr.GetMaterial(nam.c_str());
  if ( 0 == mat )   {
    const char* matname = nam.c_str();
    double density      = xmat.density();
    //double atomicWeight = xmat.attr<double>(_CMU(atomicWeight));
    double atomicNumber = xmat.attr<double>(_CMU(atomicNumber));
    TGeoElementTable* tab = mgr.GetElementTable();
    TGeoMixture*      mix = new TGeoMixture(nam.c_str(), 1, density);
    TGeoElement*      elt = tab->FindElement(xmat.nameStr().c_str());

    printout(_ns.context->debug_materials ? ALWAYS : DEBUG, "DDCMS",
             "+++ Converting material %-48s  Density: %.3f.",
             ('"'+nam+'"').c_str(), density);

    if ( !elt )  {
      printout(WARNING,"DDCMS",
               "+++ Converter<ElementaryMaterial> No element present with name:%s  [FAKE IT]",
               matname);
      int n = int(atomicNumber/2e0);
      if ( n < 2 ) n = 2;
      elt = new TGeoElement(xmat.nameStr().c_str(),"CMS element",n,atomicNumber);
      //return;
    }
    if ( elt->Z() == 0 )   {
      int n = int(atomicNumber/2e0);
      if ( n < 2 ) n = 2;
      elt = new TGeoElement((xmat.nameStr()+"-CMS").c_str(),"CMS element",n,atomicNumber);
    }
    mix->AddElement(elt, 1.0);
    mix->SetRadLen(0e0);
    /// Create medium from the material
    TGeoMedium* medium = mgr.GetMedium(matname);
    if (0 == medium) {
      --unique_mat_id;
      medium = new TGeoMedium(matname, unique_mat_id, mix);
      medium->SetTitle("material");
      medium->SetUniqueID(unique_mat_id);
    }
  }
}

/// Converter for <CompositeMaterial/> tags
template <> void Converter<compositematerial>::operator()(xml_h element) const   {
  Namespace     _ns(_param<ParsingContext>());
  xml_dim_t     xmat(element);
  string        nam = _ns.prepend(xmat.nameStr());
  TGeoManager&  mgr = description.manager();
  TGeoMaterial* mat = mgr.GetMaterial(nam.c_str());
  if ( 0 == mat )   {
    const char*  matname = nam.c_str();
    double       density = xmat.density();
    xml_coll_t   composites(xmat,_CMU(MaterialFraction));
    TGeoMixture* mix = new TGeoMixture(nam.c_str(), composites.size(), density);

    printout(_ns.context->debug_materials ? ALWAYS : DEBUG, "DDCMS",
             "++ Converting material %-48s  Density: %.3f.",
             ('"'+nam+'"').c_str(), density);
    
    for (composites.reset(); composites; ++composites)   {
      xml_dim_t xfrac(composites);
      xml_dim_t xfrac_mat(xfrac.child(_CMU(rMaterial)));
      double    fraction = xfrac.fraction();
      string    fracname = _ns.real_name(xfrac_mat.nameStr());

      TGeoMaterial* frac_mat = mgr.GetMaterial(fracname.c_str());
      if ( frac_mat )  {
        mix->AddElement(frac_mat, fraction);
        continue;
      }
      printout(WARNING,"DDCMS","+++ Composite material \"%s\" not present!",
               fracname.c_str());
    }
    mix->SetRadLen(0e0);
    /// Create medium from the material
    TGeoMedium* medium = mgr.GetMedium(matname);
    if (0 == medium) {
      --unique_mat_id;
      medium = new TGeoMedium(matname, unique_mat_id, mix);
      medium->SetTitle("material");
      medium->SetUniqueID(unique_mat_id);
    }
  }
}

/// Converter for <Rotation/> tags
template <> void Converter<rotation>::operator()(xml_h element) const  {
  ParsingContext* ctx = _param<ParsingContext>();
  Namespace _ns(ctx);
  xml_dim_t xrot(element);
  string    nam    = xrot.nameStr();
  double    thetaX = xrot.hasAttr(_CMU(thetaX)) ? _ns.attr<double>(xrot,_CMU(thetaX)) : 0e0;
  double    phiX   = xrot.hasAttr(_CMU(phiX))   ? _ns.attr<double>(xrot,_CMU(phiX))   : 0e0;
  double    thetaY = xrot.hasAttr(_CMU(thetaY)) ? _ns.attr<double>(xrot,_CMU(thetaY)) : 0e0;
  double    phiY   = xrot.hasAttr(_CMU(phiY))   ? _ns.attr<double>(xrot,_CMU(phiY))   : 0e0;
  double    thetaZ = xrot.hasAttr(_CMU(thetaZ)) ? _ns.attr<double>(xrot,_CMU(thetaZ)) : 0e0;
  double    phiZ   = xrot.hasAttr(_CMU(phiZ))   ? _ns.attr<double>(xrot,_CMU(phiZ))   : 0e0;
  Rotation3D rot = make_rotation3D(thetaX, phiX, thetaY, phiY, thetaZ, phiZ);
  printout(ctx->debug_rotations ? ALWAYS : DEBUG,
           "DDCMS","+++ Adding rotation: %-32s: (theta/phi)[rad] X: %6.3f %6.3f Y: %6.3f %6.3f Z: %6.3f %6.3f",
           _ns.prepend(nam).c_str(),thetaX,phiX,thetaY,phiY,thetaZ,phiZ);
  _ns.addRotation(nam, rot);
}

/// Converter for <Logicalpart/> tags
template <> void Converter<logicalpart>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string    sol = e.child(_CMU(rSolid)).attr<string>(_U(name));
  string    mat = e.child(_CMU(rMaterial)).attr<string>(_U(name));
  _ns.addVolume(Volume(e.nameStr(), _ns.solid(sol), _ns.material(mat)));
}

/// Helper converter
template <> void Converter<transform3d>::operator()(xml_h element) const {
  Namespace    _ns(_param<ParsingContext>());
  Transform3D* tr = _option<Transform3D>();
  xml_dim_t   e(element);
  xml_dim_t   translation = e.child(_CMU(Translation),false);
  xml_dim_t   rotation    = e.child(_CMU(Rotation),false);
  xml_dim_t   refRotation = e.child(_CMU(rRotation),false);
  Position    pos;
  Rotation3D  rot;

  if ( translation.ptr() )   {
    double x = _ns.attr<double>(translation,_U(x));
    double y = _ns.attr<double>(translation,_U(y));
    double z = _ns.attr<double>(translation,_U(z));
    pos = Position(x,y,z);
  }
  if ( rotation.ptr() )   {
    double x = _ns.attr<double>(rotation,_U(x));
    double y = _ns.attr<double>(rotation,_U(y));
    double z = _ns.attr<double>(rotation,_U(z));
    rot = RotationZYX(z,y,x);
  }
  else if ( refRotation.ptr() )   {
    rot = _ns.rotation(refRotation.nameStr());
  }
  *tr = Transform3D(rot,pos);
}

/// Converter for <PosPart/> tags
template <> void Converter<pospart>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t   e(element);
  int         copy        = e.attr<int>(_CMU(copyNumber));
  string      parent_nam  = _ns.attr<string>(e.child(_CMU(rParent)),_U(name));
  string      child_nam   = _ns.attr<string>(e.child(_CMU(rChild)),_U(name));
  Volume      parent      = _ns.volume(parent_nam);
  Volume      child       = _ns.volume(child_nam, false);
  
  printout(_ns.context->debug_placements ? ALWAYS : DEBUG, "DDCMS",
           "+++ %s Parent: %-24s [%s] Child: %-32s [%s] copy:%d",
           e.tag().c_str(),
           parent_nam.c_str(), parent.isValid() ? "VALID" : "INVALID",
           child_nam.c_str(),  child.isValid()  ? "VALID" : "INVALID",
           copy);
  PlacedVolume pv;
  if ( child.isValid() )   {
    Transform3D trafo;
    Converter<transform3d>(description,param,&trafo)(element);
    pv = parent.placeVolume(child,trafo);
  }
  if ( !pv.isValid() )   {
    printout(ERROR,"DDCMS","+++ Placement FAILED! Parent:%s Child:%s Valid:%s",
             parent.name(), child_nam.c_str(), yes_no(child.isValid()));
  }
}

template <typename TYPE>
static void convert_boolean(ParsingContext* ctx, xml_h element)   {
  Namespace   _ns(ctx);
  xml_dim_t   e(element);
  string      nam = e.nameStr();
  Solid       solids[2];
  Solid       boolean;
  int cnt=0;

  for(xml_coll_t c(element, _CMU(rSolid)); cnt<2 && c; ++c, ++cnt)
    solids[cnt] = _ns.solid(c.attr<string>(_U(name)));

  if ( cnt != 2 )   {
    except("DDCMS","+++ Failed to create blooean solid %s. Found only %d parts.",nam.c_str(), cnt);
  }
  printout(_ns.context->debug_placements ? ALWAYS : DEBUG, "DDCMS",
           "+++ SubtractionSolid: %s Left: %-32s Right: %-32s",
           nam.c_str(), solids[0]->GetName(), solids[1]->GetName());

  if ( solids[0].isValid() && solids[1].isValid() )  {
    Transform3D trafo;
    Converter<transform3d>(*ctx->description,ctx,&trafo)(element);
    boolean = TYPE(solids[0],solids[1],trafo);
  }
  if ( !boolean.isValid() )
    except("DDCMS","+++ FAILED to construct subtraction solid: %s",nam.c_str());
  _ns.addSolid(nam,boolean);
}

/// Converter for <SubtractionSolid/> tags
template <> void Converter<unionsolid>::operator()(xml_h element) const   {
  convert_boolean<UnionSolid>(_param<ParsingContext>(),element);
}

/// Converter for <SubtractionSolid/> tags
template <> void Converter<subtractionsolid>::operator()(xml_h element) const   {
  convert_boolean<SubtractionSolid>(_param<ParsingContext>(),element);
}

/// Converter for <SubtractionSolid/> tags
template <> void Converter<intersectionsolid>::operator()(xml_h element) const   {
  convert_boolean<IntersectionSolid>(_param<ParsingContext>(),element);
}

/// Converter for <Polycone/> tags
template <> void Converter<polycone>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string nam      = e.nameStr();
  double startPhi = _ns.attr<double>(e,_CMU(startPhi));
  double deltaPhi = _ns.attr<double>(e,_CMU(deltaPhi));
  vector<double> z, rmin, rmax;
  
  for(xml_coll_t zplane(element, _CMU(ZSection)); zplane; ++zplane)   {
    rmin.push_back(_ns.attr<double>(zplane,_CMU(rMin)));
    rmax.push_back(_ns.attr<double>(zplane,_CMU(rMax)));
    z.push_back(_ns.attr<double>(zplane,_CMU(z)));
  }
  printout(_ns.context->debug_shapes ? ALWAYS : DEBUG, "DDCMS",
           "+   Polycone: startPhi=%10.3f [rad] deltaPhi=%10.3f [rad]  %4ld z-planes",
           startPhi, deltaPhi, z.size());
  _ns.addSolid(nam, Polycone(startPhi,deltaPhi,rmin,rmax,z));
}

/// Converter for <Torus/> tags
template <> void Converter<torus>::operator()(xml_h element) const   {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string nam      = e.nameStr();
  double r        = _ns.attr<double>(e,_CMU(torusRadius));
  double rinner   = _ns.attr<double>(e,_CMU(innerRadius));
  double router   = _ns.attr<double>(e,_CMU(outerRadius));
  double startPhi = _ns.attr<double>(e,_CMU(startPhi));
  double deltaPhi = _ns.attr<double>(e,_CMU(deltaPhi));
  printout(_ns.context->debug_shapes ? ALWAYS : DEBUG, "DDCMS",
           "+   Torus:    r=%10.3f [cm] r_inner=%10.3f [cm] r_outer=%10.3f [cm]"
           " startPhi=%10.3f [rad] deltaPhi=%10.3f [rad]",
           r, rinner, router, startPhi, deltaPhi);
  _ns.addSolid(nam, Torus(r, rinner, router, startPhi, deltaPhi));
}

/// Converter for <Trapezoid/> tags
template <> void Converter<trapezoid>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string nam      = e.nameStr();
  double dz       = _ns.attr<double>(e,_U(dz));
  double alp1     = _ns.attr<double>(e,_CMU(alp1));
  double bl1      = _ns.attr<double>(e,_CMU(bl1));
  double tl1      = _ns.attr<double>(e,_CMU(tl1));
  double h1       = _ns.attr<double>(e,_CMU(h1));
  double alp2     = _ns.attr<double>(e,_CMU(alp2));
  double bl2      = _ns.attr<double>(e,_CMU(bl2));
  double tl2      = _ns.attr<double>(e,_CMU(tl2));
  double h2       = _ns.attr<double>(e,_CMU(h2));
  double phi      = _ns.attr<double>(e,_U(phi));
  double theta    = _ns.attr<double>(e,_U(theta));
  printout(_ns.context->debug_shapes ? ALWAYS : DEBUG, "DDCMS",
           "+   Trapezoid:  dz=%10.3f [cm] alp1:%.3f bl1=%.3f tl1=%.3f alp2=%.3f bl2=%.3f tl2=%.3f h2=%.3f phi=%.3f theta=%.3f",
           dz, alp1, bl1, tl1, h1, alp2, bl2, tl2, h2, phi, theta);
  _ns.addSolid(nam, Trap(dz, theta, phi, h1, bl1, tl1, alp1, h2, bl2, tl2, alp2));
}

/// Converter for <Tubs/> tags
template <> void Converter<tubs>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string nam      = e.nameStr();
  double dz       = _ns.attr<double>(e,_CMU(dz));
  double rmin     = _ns.attr<double>(e,_CMU(rMin));
  double rmax     = _ns.attr<double>(e,_CMU(rMax));
  double startPhi = _ns.attr<double>(e,_CMU(startPhi));
  double deltaPhi = _ns.attr<double>(e,_CMU(deltaPhi));
  printout(_ns.context->debug_shapes ? ALWAYS : DEBUG, "DDCMS",
           "+   Tubs:     dz=%10.3f [cm] rmin=%10.3f [cm] rmax=%10.3f [cm]"
           " startPhi=%10.3f [rad] deltaPhi=%10.3f [rad]", dz, rmin, rmax, startPhi, deltaPhi);
  _ns.addSolid(nam, Tube(rmin,rmax,dz,startPhi,deltaPhi));
}

/// Converter for <Box/> tags
template <> void Converter<box>::operator()(xml_h element) const {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string nam = e.nameStr();
  double dx  = _ns.attr<double>(e,_CMU(dx));
  double dy  = _ns.attr<double>(e,_CMU(dy));
  double dz  = _ns.attr<double>(e,_CMU(dz));
  printout(_ns.context->debug_shapes ? ALWAYS : DEBUG, "DDCMS",
           "+   Box:      dx=%10.3f [cm] dy=%10.3f [cm] dz=%10.3f [cm]", dx, dy, dz);
  _ns.addSolid(nam, Box(dx,dy,dz));
}

/// DD4hep specific Converter for <Include/> tags: process only the constants
template <> void Converter<include_load>::operator()(xml_h element) const   {
  xml::Document doc = xml::DocumentHandler().load(element, element.attr_value(_U(ref)));
  string fname = xml::DocumentHandler::system_path(doc.root());
  printout(_param<ParsingContext>()->debug_includes ? ALWAYS : DEBUG,
           "DDCMS","+++ Processing the CMS detector description %s",fname.c_str());
  _option<resolve>()->includes.push_back(doc);
}

/// DD4hep specific Converter for <Include/> tags: process only the constants
template <> void Converter<include_unload>::operator()(xml_h element) const   {
  string fname = xml::DocumentHandler::system_path(element);
  xml::DocumentHolder(xml_elt_t(element).document()).assign(0);
  printout(_param<ParsingContext>()->debug_includes ? ALWAYS : DEBUG,
           "DDCMS","+++ Finished processing %s",fname.c_str());
}

/// DD4hep specific Converter for <Include/> tags: process only the constants
template <> void Converter<include_constants>::operator()(xml_h element) const   {
  xml_coll_t(element, _CMU(ConstantsSection)).for_each(Converter<constantssection>(description,param,optional));
}

/// Converter for <Algorithm/> tags
template <> void Converter<algorithm>::operator()(xml_h element) const  {
  Namespace _ns(_param<ParsingContext>());
  xml_dim_t e(element);
  string name = e.nameStr();
  try {
    SensitiveDetector sd;
    Segmentation      seg;
    string type = _ns.real_name(e.nameStr());

    // SensitiveDetector and Segmentation currently are undefined. Let's keep it like this
    // until we found something better.....
    printout(_ns.context->debug_algorithms ? ALWAYS : DEBUG,
             "DDCMS","+++ Start executing algorithm %s....",type.c_str());
    long ret = PluginService::Create<long>(type, &description, _ns.context, &element, &sd);
    if ( ret == 1 )    {
      printout(_ns.context->debug_algorithms ? ALWAYS : DEBUG,
               "DDCMS", "+++ Executed algorithm: %08lX = %s", ret, name.c_str());
      return;      
    }
#if 0
    DetElement det(PluginService::Create<NamedObject*>(type, &description, _ns.context, &element, &sd));
    if (det.isValid())    {
      // setChildTitles(make_pair(name, det));
      if ( sd.isValid() )  {
        det->flag |= DetElement::Object::HAVE_SENSITIVE_DETECTOR;
      }
      if ( seg.isValid() )  {
        seg->sensitive = sd;
        seg->detector  = det;
      }
    }
    if (!det.isValid()) {
      PluginDebug dbg;
      PluginService::Create<NamedObject*>(type, &description, _ns.context, &element, &sd);
      except("DDCMS","Failed to execute subdetector creation plugin. " + dbg.missingFactory(type));
    }
    description.addDetector(det);
#endif
    ///description.addDetector(det);
    printout(ERROR, "DDCMS", "++ FAILED  NOT ADDING SUBDETECTOR %08lX = %s",ret, name.c_str());
    return;
  }
  catch (const exception& exc) {
    printout(ERROR, "DDCMS", "++ FAILED    to convert subdetector: %s: %s", name.c_str(), exc.what());
    terminate();
  }
  catch (...) {
    printout(ERROR, "DDCMS", "++ FAILED    to convert subdetector: %s: %s", name.c_str(), "UNKNONW Exception");
    terminate();
  }
}

template <> void Converter<debug>::operator()(xml_h dbg) const {
  Namespace _ns(_param<ParsingContext>());
  if ( dbg.hasChild(_CMU(debug_constants)) )  _ns.context->debug_constants  = true;
  if ( dbg.hasChild(_CMU(debug_materials)) )  _ns.context->debug_materials  = true;
  if ( dbg.hasChild(_CMU(debug_rotations)) )  _ns.context->debug_rotations  = true;
  if ( dbg.hasChild(_CMU(debug_shapes)) )     _ns.context->debug_shapes     = true;
  if ( dbg.hasChild(_CMU(debug_volumes)) )    _ns.context->debug_volumes    = true;
  if ( dbg.hasChild(_CMU(debug_placements)) ) _ns.context->debug_placements = true;
  if ( dbg.hasChild(_CMU(debug_namespaces)) ) _ns.context->debug_namespaces = true;
  if ( dbg.hasChild(_CMU(debug_includes))   ) _ns.context->debug_includes   = true;
  if ( dbg.hasChild(_CMU(debug_algorithms)) ) _ns.context->debug_algorithms = true;
}

template <> void Converter<vis_apply>::operator()(xml_h /* dddefinition */) const {
  struct VisPatcher: public detail::GeoScan {
    Detector& detector;
    VisPatcher(Detector& d) : detail::GeoScan(d.world()), detector(d)  {    }
    void patch()   const  {
      printout(INFO,"Detector","+++ Applying DD4hep visualization attributes....");
      for (auto i = m_data->rbegin(); i != m_data->rend(); ++i) {
        for( const TGeoNode* n : (*i).second )  {
          Volume  vol(n->GetVolume());
          VisAttr vis = detector.visAttributes(vol.name());
          printout(DEBUG,"Vis","+++ %s  vis-attrs:%s",vol.name(), yes_no(vis.isValid()));
          vol.setVisAttributes(vis);
        }
      }
    }
  };
  VisPatcher(description).patch();
}

template <> void Converter<resolve>::operator()(xml_h /* element */) const {
  ParsingContext* ctx = _param<ParsingContext>();
  resolve*        res = _option<resolve>();
  Namespace       _ns(ctx);
  int count = 0;

  printout(ctx->debug_constants ? ALWAYS : DEBUG,
           "DDCMS","+++ RESOLVING %ld unknown constants.....",res->unresolvedConst.size());
  while ( !res->unresolvedConst.empty() )   {
    for(auto i=res->unresolvedConst.begin(); i!=res->unresolvedConst.end(); ++i )   {
      const string& n = (*i).first;
      string  rep;
      string& v   = (*i).second;
      size_t idx, idq;
      for(idx=v.find('[',0); idx != string::npos; idx = v.find('[',idx+1) )   {
        idq = v.find(']',idx+1);
        rep = v.substr(idx+1,idq-idx-1);
        auto r = res->allConst.find(rep);
        if ( r != res->allConst.end() )  {
          rep = "("+(*r).second+")";
          v.replace(idx,idq-idx+1,rep);
        }
      }
      if ( v.find(']') == string::npos )  {
        if ( v.find("-+") != string::npos || v.find("+-") != string::npos )   {
          while ( (idx=v.find("-+")) != string::npos )
            v.replace(idx,2,"-");
          while ( (idx=v.find("+-")) != string::npos )
            v.replace(idx,2,"-");
        }
        printout(ctx->debug_constants ? ALWAYS : DEBUG,
                 "DDCMS","+++ [%06ld] ----------  %-40s = %s",
                 res->unresolvedConst.size()-1,n.c_str(),res->originalConst[n].c_str());
        _ns.addConstantNS(n, v, "number");
        res->unresolvedConst.erase(i);
        break;
      }
    }
    if ( ++count > 1000 ) break;
  }
  if ( !res->unresolvedConst.empty() )   {
    for(const auto& e : res->unresolvedConst )
      printout(ERROR,"DDCMS","+++ Unresolved constant: %-40s = %s.",e.first.c_str(), e.second.c_str());
    except("DDCMS","++ FAILED to resolve %ld constant entries:",res->unresolvedConst.size());
  }
  res->unresolvedConst.clear();
  res->originalConst.clear();
  res->allConst.clear();
}

template <> void Converter<print_xml_doc>::operator()(xml_h element) const {
  string fname = xml::DocumentHandler::system_path(element);
  printout(_param<ParsingContext>()->debug_includes ? ALWAYS : DEBUG,
           "DDCMS","+++ Processing data from file:%s",fname.c_str());
}

/// Converter for <DDDefinition/> tags
static long load_dddefinition(Detector& det, xml_h element) {
  static ParsingContext ctxt(&det);
  Namespace _ns(ctxt);
  xml_elt_t dddef(element);
  string fname = xml::DocumentHandler::system_path(element);
  bool open_geometry  = dddef.hasChild(_CMU(open_geometry));
  bool close_geometry = dddef.hasChild(_CMU(close_geometry));

  xml_coll_t(dddef, _U(debug)).for_each(Converter<debug>(det,&ctxt));

  // 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,"DDCMS","+++ Processing the CMS detector description %s",fname.c_str());

  xml::Document doc;
  Converter<print_xml_doc> print_doc(det,&ctxt);
  try  {
    resolve res;
    print_doc((doc=dddef.document()).root());
    xml_coll_t(dddef, _CMU(ConstantsSection)).for_each(Converter<constantssection>(det,&ctxt,&res));
    xml_coll_t(dddef, _CMU(VisSection)).for_each(Converter<vissection>(det,&ctxt));
    xml_coll_t(dddef, _CMU(RotationSection)).for_each(Converter<rotationsection>(det,&ctxt));
    xml_coll_t(dddef, _CMU(MaterialSection)).for_each(Converter<materialsection>(det,&ctxt));

    xml_coll_t(dddef, _CMU(IncludeSection)).for_each(_CMU(Include), Converter<include_load>(det,&ctxt,&res));

    for(xml::Document d : res.includes ) Converter<include_constants>(det,&ctxt,&res)((doc=d).root());
    // Before we continue, we have to resolve all constants NOW!
    Converter<resolve>(det,&ctxt,&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(),_CMU(MaterialSection)).for_each(Converter<materialsection>(det,&ctxt));
    }
    if ( open_geometry )  {
      ctxt.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(),_CMU(RotationSection)).for_each(Converter<rotationsection>(det,&ctxt));
    }
    for(xml::Document d : res.includes )  {
      print_doc((doc=d).root());
      xml_coll_t(d.root(), _CMU(SolidSection)).for_each(Converter<solidsection>(det,&ctxt));
    }
    for(xml::Document d : res.includes )  {
      print_doc((doc=d).root());
      xml_coll_t(d.root(), _CMU(LogicalPartSection)).for_each(Converter<logicalpartsection>(det,&ctxt));
    }
    for(xml::Document d : res.includes )  {
      print_doc((doc=d).root());
      xml_coll_t(d.root(), _CMU(Algorithm)).for_each(Converter<algorithm>(det,&ctxt));
    }
    for(xml::Document d : res.includes )  {
      print_doc((doc=d).root());
      xml_coll_t(d.root(), _CMU(PosPartSection)).for_each(Converter<pospartsection>(det,&ctxt));
    }

    /// Unload all XML files after processing
    for(xml::Document d : res.includes ) Converter<include_unload>(det,&ctxt,&res)(d.root());

    print_doc((doc=dddef.document()).root());
    // Now process the actual geometry items
    xml_coll_t(dddef, _CMU(SolidSection)).for_each(Converter<solidsection>(det,&ctxt));
    xml_coll_t(dddef, _CMU(LogicalPartSection)).for_each(Converter<logicalpartsection>(det,&ctxt));
    xml_coll_t(dddef, _CMU(Algorithm)).for_each(Converter<algorithm>(det,&ctxt));
    xml_coll_t(dddef, _CMU(PosPartSection)).for_each(Converter<pospartsection>(det,&ctxt));

  }
  catch(const exception& e)   {
    printout(ERROR,"DDCMS","Exception while processing xml source:%s",doc.uri().c_str());
    printout(ERROR,"DDCMS","----> %s", e.what());
    throw;
  }

  /// This should be the end of all processing....close the geometry
  if ( close_geometry )  {
    Converter<vis_apply> cnv(det,&ctxt);
    cnv(dddef);
    det.endDocument();
  }
  printout(INFO,"DDDefinition","+++ Finished processing %s",fname.c_str());
  return 1;
}

// Now declare the factory entry for the plugin mechanism
DECLARE_XML_DOC_READER(DDDefinition,load_dddefinition)