diff --git a/CondTools/Geometry/plugins/BuildFile.xml b/CondTools/Geometry/plugins/BuildFile.xml
index 826ab89bacd32..d47dbefafb61d 100644
--- a/CondTools/Geometry/plugins/BuildFile.xml
+++ b/CondTools/Geometry/plugins/BuildFile.xml
@@ -2,6 +2,7 @@
 <use name="CondCore/DBOutputService"/>
 <use name="CondFormats/Common"/>
 <use name="CondFormats/GeometryObjects"/>
+<use name="DataFormats/Math"/>
 <use name="DetectorDescription/Core"/>
 <use name="DetectorDescription/DDCMS"/>
 <use name="FWCore/Framework"/>
diff --git a/CondTools/Geometry/plugins/PGeometricDetBuilder.cc b/CondTools/Geometry/plugins/PGeometricDetBuilder.cc
index 57b8f4adad759..2e9fae089ae4c 100644
--- a/CondTools/Geometry/plugins/PGeometricDetBuilder.cc
+++ b/CondTools/Geometry/plugins/PGeometricDetBuilder.cc
@@ -8,6 +8,7 @@
 #include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 #include "CondFormats/GeometryObjects/interface/PGeometricDet.h"
+#include "DataFormats/Math/interface/Rounding.h"
 #include "Geometry/Records/interface/IdealGeometryRecord.h"
 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
 #include "DetectorDescription/DDCMS/interface/DDCompactView.h"
@@ -136,20 +137,24 @@ void PGeometricDetBuilder::putOne(const GeometricDet* gd, PGeometricDet* pgd, in
   item._name = gd->name();
   item._ns = std::string();
   item._level = lev;
-  item._x = tran.X();
-  item._y = tran.Y();
-  item._z = tran.Z();
+  using cms_rounding::roundIfNear0;
+  const double tol = 1.e-10;
+  // Round very small calculated values to 0 to avoid discrepancies
+  // between +0 and -0 in comparisons.
+  item._x = roundIfNear0(tran.X(), tol);
+  item._y = roundIfNear0(tran.Y(), tol);
+  item._z = roundIfNear0(tran.Z(), tol);
   item._phi = gd->phi();
   item._rho = gd->rho();
-  item._a11 = x.X();
-  item._a12 = y.X();
-  item._a13 = z.X();
-  item._a21 = x.Y();
-  item._a22 = y.Y();
-  item._a23 = z.Y();
-  item._a31 = x.Z();
-  item._a32 = y.Z();
-  item._a33 = z.Z();
+  item._a11 = roundIfNear0(x.X(), tol);
+  item._a12 = roundIfNear0(y.X(), tol);
+  item._a13 = roundIfNear0(z.X(), tol);
+  item._a21 = roundIfNear0(x.Y(), tol);
+  item._a22 = roundIfNear0(y.Y(), tol);
+  item._a23 = roundIfNear0(z.Y(), tol);
+  item._a31 = roundIfNear0(x.Z(), tol);
+  item._a32 = roundIfNear0(y.Z(), tol);
+  item._a33 = roundIfNear0(z.Z(), tol);
   item._shape = static_cast<int>(gd->shape_dd4hep());
   item._type = gd->type();
   if (gd->shape_dd4hep() == cms::DDSolidShape::ddbox) {
diff --git a/CondTools/Geometry/test/writehelpers/createExtended2021DD4hepPayloads.sh b/CondTools/Geometry/test/writehelpers/createExtended2021DD4hepPayloads.sh
new file mode 100755
index 0000000000000..18a02b05a2da5
--- /dev/null
+++ b/CondTools/Geometry/test/writehelpers/createExtended2021DD4hepPayloads.sh
@@ -0,0 +1,93 @@
+#!/bin/sh
+
+
+if [ $# -ne 1 ]
+then
+  echo Error: createExtended2021Payloads.sh requires exactly one argument which is the tag
+  exit 1
+fi
+mytag=$1
+echo ${mytag}
+
+# Set the tag in all the scripts and the metadata text files
+sed -i {s/TagXX/${mytag}/g} *.py
+compgen -G "*.txt" > /dev/null && sed -i {s/TagXX/${mytag}/g} *.txt
+sed -i {s/TagXX/${mytag}/g} splitExtended2021Database.sh
+
+# First read in the little XML files and create the
+# large XML file for the Phase1_R30F12_HCal Ideal scenario.
+# Input cff                                             Output file
+# GeometryExtended2021_cff                       geSingleBigFile.xml
+cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# Now convert the content of the large XML file into
+# a "blob" and write it to the database.
+# Also reads in the little XML files again and fills
+# the DDCompactView. From the DDCompactView the
+# reco parts of the database are also filled.
+cmsRun geometryExtended2021DD4hep_writer.py
+
+# Now put the other scenarios into the database.
+# Input the many XML files referenced by the cff file and
+# output a single big XML file.
+# This is repeated several times below.  The sed commands
+# serve to give the following sequence of input and output
+# files
+#
+# Input cff                    Output file
+# GeometryIdeal_cff            giSingleBigFile.xml
+#
+# sed -i '{s/Extended2021/Extended2021ZeroMaterial/g}' geometryExtended2021DD4hep_xmlwriter.py
+# sed -i '{s/\/ge/\/gez/g}' geometryExtended2021DD4hep_xmlwriter.py
+# cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# sed -i '{s/Extended2021ZeroMaterial/Extended2021FlatMinus05Percent/g}' geometryExtended2021DD4hep_xmlwriter.py
+# sed -i '{s/\/gez/\/geFM05/g}' geometryExtended2021DD4hep_xmlwriter.py
+# cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# sed -i '{s/Extended2021FlatMinus05Percent/Extended2021FlatMinus10Percent/g}' geometryExtended2021DD4hep_xmlwriter.py
+# sed -i '{s/\/geFM05/\/geFM10/g}' geometryExtended2021DD4hep_xmlwriter.py
+# cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# sed -i '{s/Extended2021FlatMinus10Percent/Extended2021FlatPlus05Percent/g}' geometryExtended2021DD4hep_xmlwriter.py
+# sed -i '{s/\/geFM10/\/geFP05/g}' geometryExtended2021DD4hep_xmlwriter.py
+# cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# sed -i '{s/Extended2021FlatPlus05Percent/Extended2021FlatPlus10Percent/g}' geometryExtended2021DD4hep_xmlwriter.py
+# sed -i '{s/\/geFP05/\/geFP10/g}' geometryExtended2021DD4hep_xmlwriter.py
+# cmsRun geometryExtended2021DD4hep_xmlwriter.py
+
+# Read the one big XML file and output a record to the
+# database with the an identifying tag
+# This is repeated several times below.  The sed commands
+# serve to give the following sequence of input file and output
+# tag
+#
+# Input file                Output tag
+# gezSingleBigFile.xml      XMLFILE_Geometry_${mytag}_Extended2021ZeroMaterial_mc
+#
+# sed -i '{s/Extended/Extended2021ZeroMaterial/g}' xmlgeometrywriter.py
+# sed -i '{s/\/ge/\/gez/g}' xmlgeometrywriter.py
+# cmsRun xmlgeometrywriter.py
+
+# sed -i '{s/Extended2021ZeroMaterial/Extended2021FlatMinus05Percent/g}' xmlgeometrywriter.py
+# sed -i '{s/\/gez/\/geFM05/g}' xmlgeometrywriter.py
+# cmsRun xmlgeometrywriter.py
+
+# sed -i '{s/Extended2021FlatMinus05Percent/Extended2021FlatMinus10Percent/g}' xmlgeometrywriter.py
+# sed -i '{s/\/geFM05/\/geFM10/g}' xmlgeometrywriter.py
+# cmsRun xmlgeometrywriter.py
+
+# sed -i '{s/Extended2021FlatMinus10Percent/Extended2021FlatPlus05Percent/g}' xmlgeometrywriter.py
+# sed -i '{s/\/geFM10/\/geFP05/g}' xmlgeometrywriter.py
+# cmsRun xmlgeometrywriter.py
+
+# sed -i '{s/Extended2021FlatPlus05Percent/Extended2021FlatPlus10Percent/g}' xmlgeometrywriter.py
+# sed -i '{s/\/geFP05/\/geFP10/g}' xmlgeometrywriter.py
+# cmsRun xmlgeometrywriter.py
+
+# All the database objects were written into one database
+# (myfile.db) in the steps above.  Extract the different
+# pieces into separate database files.  These are the payloads
+# that get uploaded to the dropbox.  There is one for each tag
+./splitExtended2021Database.sh
diff --git a/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_writer.py b/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_writer.py
new file mode 100644
index 0000000000000..554423ee90704
--- /dev/null
+++ b/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_writer.py
@@ -0,0 +1,80 @@
+import FWCore.ParameterSet.Config as cms
+from Configuration.Eras.Era_Run3_dd4hep_cff import Run3_dd4hep
+
+process = cms.Process("GeometryWriter", Run3_dd4hep)
+
+from Configuration.ProcessModifiers.dd4hep_cff import dd4hep
+
+process.load('CondCore.CondDB.CondDB_cfi')
+
+process.load('Configuration.Geometry.GeometryDD4hepExtended2021_cff')
+process.load('Geometry.CaloEventSetup.CaloGeometryDBWriter_cfi')
+process.load('CondTools.Geometry.HcalParametersWriter_cff')
+process.load("Geometry.MuonNumbering.muonGeometryConstants_cff")
+
+process.CaloGeometryBuilder = cms.ESProducer("CaloGeometryBuilder",
+    SelectedCalos = cms.vstring(
+        'HCAL',
+        'ZDC',
+        'EcalBarrel',
+        'EcalEndcap',
+        'EcalPreshower',
+        'TOWER'
+    )
+)
+
+process.source = cms.Source("EmptyIOVSource",
+                            lastValue = cms.uint64(1),
+                            timetype = cms.string('runnumber'),
+                            firstValue = cms.uint64(1),
+                            interval = cms.uint64(1)
+                            )
+
+# This reads the big XML file and the only way to fill the
+# nonreco part of the database is to read this file.
+process.XMLGeometryWriter = cms.EDAnalyzer("XMLGeometryBuilder",
+                                           XMLFileName = cms.untracked.string("./geSingleBigFile.xml"),
+                                           ZIP = cms.untracked.bool(True)
+                                           )
+
+process.TrackerGeometryWriter = cms.EDAnalyzer("PGeometricDetBuilder",fromDD4hep=cms.bool(True))
+process.TrackerParametersWriter = cms.EDAnalyzer("PTrackerParametersDBBuilder",fromDD4hep=cms.bool(True))
+
+process.CaloGeometryWriter = cms.EDAnalyzer("PCaloGeometryBuilder",fromDD4Hep = cms.untracked.bool(True))
+
+process.CSCGeometryWriter = cms.EDAnalyzer("CSCRecoIdealDBLoader",fromDD4Hep = cms.untracked.bool(True))
+
+process.DTGeometryWriter = cms.EDAnalyzer("DTRecoIdealDBLoader",fromDD4Hep = cms.untracked.bool(True))
+
+process.RPCGeometryWriter = cms.EDAnalyzer("RPCRecoIdealDBLoader",fromDD4Hep = cms.untracked.bool(True))
+
+process.GEMGeometryWriter = cms.EDAnalyzer("GEMRecoIdealDBLoader",fromDD4Hep = cms.untracked.bool(True))
+
+process.CondDB.timetype = cms.untracked.string('runnumber')
+process.CondDB.connect = cms.string('sqlite_file:myfile.db')
+process.PoolDBOutputService = cms.Service("PoolDBOutputService",
+                                          process.CondDB,
+                                          toPut = cms.VPSet(cms.PSet(record = cms.string('GeometryFileRcd'),tag = cms.string('XMLFILE_Geometry_TagXX_Extended2021_mc')),
+                                                            cms.PSet(record = cms.string('IdealGeometryRecord'),tag = cms.string('TKRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PTrackerParametersRcd'),tag = cms.string('TKParameters_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PEcalBarrelRcd'),   tag = cms.string('EBRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PEcalEndcapRcd'),   tag = cms.string('EERECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PEcalPreshowerRcd'),tag = cms.string('EPRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PHcalRcd'),         tag = cms.string('HCALRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('HcalParametersRcd'), tag = cms.string('HCALParameters_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PCaloTowerRcd'),    tag = cms.string('CTRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PZdcRcd'),          tag = cms.string('ZDCRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('PCastorRcd'),       tag = cms.string('CASTORRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('CSCRecoGeometryRcd'),tag = cms.string('CSCRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('CSCRecoDigiParametersRcd'),tag = cms.string('CSCRECODIGI_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('DTRecoGeometryRcd'),tag = cms.string('DTRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('RPCRecoGeometryRcd'),tag = cms.string('RPCRECO_Geometry_TagXX')),
+                                                            cms.PSet(record = cms.string('GEMRecoGeometryRcd'),tag = cms.string('GEMRECO_Geometry_TagXX'))
+                                                        )
+                                    )
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(1)
+    )
+
+process.p1 = cms.Path(process.XMLGeometryWriter+process.TrackerGeometryWriter+process.TrackerParametersWriter+process.CaloGeometryWriter+process.HcalParametersWriter+process.CSCGeometryWriter+process.DTGeometryWriter+process.RPCGeometryWriter+process.GEMGeometryWriter)
diff --git a/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_xmlwriter.py b/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_xmlwriter.py
new file mode 100644
index 0000000000000..23100a9d6aa84
--- /dev/null
+++ b/CondTools/Geometry/test/writehelpers/geometryExtended2021DD4hep_xmlwriter.py
@@ -0,0 +1,31 @@
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("GeometryXMLWriter")
+
+process.source = cms.Source("EmptyIOVSource",
+                            lastValue = cms.uint64(1),
+                            timetype = cms.string('runnumber'),
+                            firstValue = cms.uint64(1),
+                            interval = cms.uint64(1)
+                            )
+
+process.DDDetectorESProducer = cms.ESSource("DDDetectorESProducer",
+                                            confGeomXMLFiles = cms.FileInPath('Geometry/CMSCommonData/data/dd4hep/cmsExtendedGeometry2021.xml'),
+                                            appendToDataLabel = cms.string('make-payload')
+                                           )
+
+process.DDCompactViewESProducer = cms.ESProducer("DDCompactViewESProducer",
+                                                  appendToDataLabel = cms.string('make-payload')
+                                                )
+
+process.BigXMLWriter = cms.EDAnalyzer("OutputDD4hepToDDL",
+                              fileName = cms.untracked.string("./geSingleBigFile.xml")
+                              )
+
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(1)
+    )
+
+process.p1 = cms.Path(process.BigXMLWriter)
+
diff --git a/DetectorDescription/DDCMS/interface/DDDetector.h b/DetectorDescription/DDCMS/interface/DDDetector.h
index 8d6f49e8ed543..b1b8ec26125c7 100644
--- a/DetectorDescription/DDCMS/interface/DDDetector.h
+++ b/DetectorDescription/DDCMS/interface/DDDetector.h
@@ -2,7 +2,6 @@
 #define DetectorDescription_DDCMS_DDDetector_h
 
 #include "DetectorDescription/DDCMS/interface/DDVectorRegistry.h"
-#include "DetectorDescription/DDCMS/interface/DDParsingContext.h"
 #include <DD4hep/Detector.h>
 #include <DD4hep/SpecParRegistry.h>
 #include <string>
@@ -12,7 +11,7 @@ class TGeoManager;
 namespace cms {
   class DDDetector {
   public:
-    explicit DDDetector(const std::string&, const std::string&, bool bigXML = false, bool makePayload = false);
+    explicit DDDetector(const std::string&, const std::string&, bool bigXML = false);
     DDDetector() = delete;
 
     cms::DDVectorsMap const& vectors() const { return m_vectors; }
@@ -35,8 +34,6 @@ namespace cms {
 
     dd4hep::Detector const* description() const { return m_description; }
 
-    DDParsingContext* m_context;
-
   private:
     void process(const std::string&);
     void processXML(const std::string&);
diff --git a/DetectorDescription/DDCMS/interface/DDNamespace.h b/DetectorDescription/DDCMS/interface/DDNamespace.h
index 8dadbefa6bf36..97c0c887dde3e 100644
--- a/DetectorDescription/DDCMS/interface/DDNamespace.h
+++ b/DetectorDescription/DDCMS/interface/DDNamespace.h
@@ -62,12 +62,11 @@ namespace cms {
     dd4hep::Solid addSolid(const std::string& name, dd4hep::Solid solid) const;
     dd4hep::Solid addSolidNS(const std::string& name, dd4hep::Solid solid) const;
 
-    dd4hep::Assembly assembly(const std::string& name) const;
+    dd4hep::Assembly assembly(const std::string& name, bool exception = true) const;
     dd4hep::Assembly addAssembly(dd4hep::Assembly asmb, bool addSolid = true) const;
     dd4hep::Assembly addAssemblySolid(dd4hep::Assembly assembly) const;
 
     dd4hep::Volume volume(const std::string& name, bool exc = true) const;
-    dd4hep::Volume* getVolPtr(const std::string& name) const;
     dd4hep::Volume addVolume(dd4hep::Volume vol) const;
     dd4hep::Volume addVolumeNS(dd4hep::Volume vol) const;
 
diff --git a/DetectorDescription/DDCMS/interface/DDParsingContext.h b/DetectorDescription/DDCMS/interface/DDParsingContext.h
index ca95d16507f8b..135571f0fa425 100644
--- a/DetectorDescription/DDCMS/interface/DDParsingContext.h
+++ b/DetectorDescription/DDCMS/interface/DDParsingContext.h
@@ -20,7 +20,6 @@ namespace cms {
       rotations.reserve(3000);
       shapes.reserve(4000);
       volumes.reserve(3000);
-      volPtrs.reserve(3000);
       unresolvedMaterials.reserve(300);
       unresolvedVectors.reserve(300);
       unresolvedShapes.reserve(1000);
@@ -82,7 +81,6 @@ namespace cms {
     std::unordered_map<std::string, std::string> rotRevMap;
     std::unordered_map<std::string, dd4hep::Solid> shapes;
     std::unordered_map<std::string, dd4hep::Volume> volumes;
-    std::unordered_map<std::string, dd4hep::Volume*> volPtrs;
     std::vector<std::string> namespaces;
 
     std::unordered_map<std::string, std::vector<CompositeMaterial>> unresolvedMaterials;
diff --git a/DetectorDescription/DDCMS/plugins/DDDetectorESProducer.cc b/DetectorDescription/DDCMS/plugins/DDDetectorESProducer.cc
index 9fff129717e2c..103d46920153f 100644
--- a/DetectorDescription/DDCMS/plugins/DDDetectorESProducer.cc
+++ b/DetectorDescription/DDCMS/plugins/DDDetectorESProducer.cc
@@ -59,7 +59,6 @@ class DDDetectorESProducer : public ESProducer, public EventSetupRecordIntervalF
   const string confGeomXMLFiles_;
   const string rootDDName_;
   const string label_;
-  const bool makePayload_;
   edm::ESGetToken<FileBlob, MFGeometryFileRcd> mfToken_;
   edm::ESGetToken<FileBlob, GeometryFileRcd> geomToken_;
 };
@@ -69,8 +68,7 @@ DDDetectorESProducer::DDDetectorESProducer(const ParameterSet& iConfig)
       appendToDataLabel_(iConfig.getParameter<string>("appendToDataLabel")),
       confGeomXMLFiles_(fromDB_ ? "none" : iConfig.getParameter<FileInPath>("confGeomXMLFiles").fullPath()),
       rootDDName_(iConfig.getParameter<string>("rootDDName")),
-      label_(iConfig.getParameter<string>("label")),
-      makePayload_(iConfig.getParameter<bool>("makePayload")) {
+      label_(iConfig.getParameter<string>("label")) {
   usesResources({edm::ESSharedResourceNames::kDD4Hep});
   if (rootDDName_ == "MagneticFieldVolumes:MAGF" || rootDDName_ == "cmsMagneticField:MAGF") {
     auto c = setWhatProduced(this,
@@ -98,14 +96,12 @@ void DDDetectorESProducer::fillDescriptions(ConfigurationDescriptions& descripti
   desc.add<string>("rootDDName", "cms:OCMS");
   desc.add<string>("label", "");
   desc.add<bool>("fromDB", false);
-  desc.add<bool>("makePayload", false);
   descriptions.add("DDDetectorESProducer", desc);
 
   edm::ParameterSetDescription descDB;
   descDB.add<string>("rootDDName", "cms:OCMS");
   descDB.add<string>("label", "Extended");
   descDB.add<bool>("fromDB", true);
-  descDB.add<bool>("makePayload", false);
   descriptions.add("DDDetectorESProducerFromDB", descDB);
 }
 
@@ -135,13 +131,13 @@ DDDetectorESProducer::ReturnType DDDetectorESProducer::produceGeom(const IdealGe
 
     return make_unique<cms::DDDetector>(label_, string(tb->begin(), tb->end()), true);
   } else {
-    return make_unique<DDDetector>(appendToDataLabel_, confGeomXMLFiles_, false, makePayload_);
+    return make_unique<DDDetector>(appendToDataLabel_, confGeomXMLFiles_, false);
   }
 }
 
 DDDetectorESProducer::ReturnType DDDetectorESProducer::produce() {
   LogVerbatim("Geometry") << "DDDetectorESProducer::Produce " << appendToDataLabel_;
-  return make_unique<DDDetector>(appendToDataLabel_, confGeomXMLFiles_, false, makePayload_);
+  return make_unique<DDDetector>(appendToDataLabel_, confGeomXMLFiles_, false);
 }
 
 DEFINE_FWK_EVENTSETUP_SOURCE(DDDetectorESProducer);
diff --git a/DetectorDescription/DDCMS/plugins/dd4hep/DDDefinitions2Objects.cc b/DetectorDescription/DDCMS/plugins/dd4hep/DDDefinitions2Objects.cc
index fa3403c9b3923..08d81af2650c1 100644
--- a/DetectorDescription/DDCMS/plugins/dd4hep/DDDefinitions2Objects.cc
+++ b/DetectorDescription/DDCMS/plugins/dd4hep/DDDefinitions2Objects.cc
@@ -931,8 +931,8 @@ void Converter<DDLPosPart>::operator()(xml_h element) const {
 
   Volume parent = ns.volume(parentName, false);
   Volume child = ns.volume(childName, false);
-  Volume* parentPtr = ns.getVolPtr(parentName);
-  Volume* childPtr = ns.getVolPtr(childName);
+  Assembly parAsmb = ns.assembly(parentName, false);
+  Assembly childAsmb = ns.assembly(childName, false);
 
 #ifdef EDM_ML_DEBUG
 
@@ -948,25 +948,26 @@ void Converter<DDLPosPart>::operator()(xml_h element) const {
 
 #endif
 
-  if (!parent.isValid() && strchr(parentName.c_str(), NAMESPACE_SEP) == nullptr)
+  if (!parent.isValid() && !parAsmb.isValid() && strchr(parentName.c_str(), NAMESPACE_SEP) == nullptr) {
     parentName = ns.prepend(parentName);
-  parent = ns.volume(parentName, false);
-  if (parentPtr == nullptr)
-    parentPtr = ns.getVolPtr(parentName);
-  if (!parent.isValid() && parentPtr == nullptr)
-    throw runtime_error("Unknown volume identifier:" + parentName);
+    parAsmb = ns.assembly(parentName, false);
+    if (!parAsmb.isValid())
+      parent = ns.volume(parentName);
+  }
 
-  if (!child.isValid() && strchr(childName.c_str(), NAMESPACE_SEP) == nullptr)
+  if (!child.isValid() && !childAsmb.isValid() && strchr(childName.c_str(), NAMESPACE_SEP) == nullptr) {
     childName = ns.prepend(childName);
-  child = ns.volume(childName, false);
-  if (childPtr == nullptr)
-    childPtr = ns.getVolPtr(childName);
-  if (childPtr != nullptr && parentPtr != nullptr && ((*parentPtr)->IsAssembly() || (*childPtr)->IsAssembly())) {
+    child = ns.volume(childName, false);
+    childAsmb = ns.assembly(childName, false);
+  }
+  if (parAsmb.isValid() || childAsmb.isValid()) {
     printout(ns.context()->debug_placements ? ALWAYS : DEBUG,
              "DD4CMS",
              "***** Placing assembly parent %s, child %s",
              parentName.c_str(),
              childName.c_str());
+    Volume* parentPtr = parAsmb.isValid() ? &parAsmb : &parent;
+    Volume* childPtr = childAsmb.isValid() ? &childAsmb : &child;
     placeAssembly(parentPtr, parentName, childPtr, childName, copy, transform, ns);
     return;
   }
@@ -1716,7 +1717,6 @@ void Converter<DDLAssembly>::operator()(xml_h element) const {
       ns.context()->debug_shapes ? ALWAYS : DEBUG, "DD4CMS", "+   Assembly: Adding solid -> Assembly: %s", nam.c_str());
 #endif
 
-  ns.addSolid(nam, Box(nam, 1, 1, 1));  // Add a dummy solid to allow assembly to be treated like other volumes
   ns.addAssemblySolid(nam);
 }
 
@@ -1863,9 +1863,6 @@ void Converter<DDLDivision>::operator()(xml_h element) const {
     Volume child = parent.divide(childName, static_cast<int>(axesmap.at(axis)), numCopies, startInDeg, widthInDeg);
 
     ns.context()->volumes[childName] = child;
-    // ns.context()->volPtrs[childName] = &(ns.context()->volumes[childName]);
-    // TGeoVolumeMulti objects not needed in volPtrs list, and they cause
-    // crash when IsAssembly() method is called on them.
 
 #ifdef EDM_ML_DEBUG
 
@@ -1901,7 +1898,6 @@ void Converter<DDLDivision>::operator()(xml_h element) const {
     Volume child = parent.divide(childName, static_cast<int>(axesmap.at(axis)), nReplicas, -dy + offset + width, width);
 
     ns.context()->volumes[childName] = child;
-    // ns.context()->volPtrs[childName] = &(ns.context()->volumes[childName]);
 
 #ifdef EDM_ML_DEBUG
 
diff --git a/DetectorDescription/DDCMS/src/DDDetector.cc b/DetectorDescription/DDCMS/src/DDDetector.cc
index 159f081d868cf..a64cb73da092b 100644
--- a/DetectorDescription/DDCMS/src/DDDetector.cc
+++ b/DetectorDescription/DDCMS/src/DDDetector.cc
@@ -1,4 +1,5 @@
 #include "DetectorDescription/DDCMS/interface/DDDetector.h"
+#include "DetectorDescription/DDCMS/interface/DDParsingContext.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include <DD4hep/Detector.h>
 #include <DD4hep/DetectorTools.h>
@@ -10,18 +11,23 @@
 
 namespace cms {
 
-  DDDetector::DDDetector(const std::string& tag, const std::string& fileName, bool bigXML, bool makePayload)
-      : m_tag(tag) {
+  DDDetector::DDDetector(const std::string& tag, const std::string& fileName, bool bigXML) : m_tag(tag) {
     //We do not want to use any previously created TGeoManager but we do want to reset after we are done.
     auto oldGeoManager = gGeoManager;
     gGeoManager = nullptr;
     auto resetManager = [oldGeoManager](TGeoManager*) { gGeoManager = oldGeoManager; };
     std::unique_ptr<TGeoManager, decltype(resetManager)> sentry(oldGeoManager, resetManager);
 
-    m_description = &dd4hep::Detector::getInstance(tag);
+    std::string tagStr(m_tag);
+    bool makePayload = false;
+    if (tagStr == "make-payload") {
+      makePayload = true;
+      tagStr = "";
+    }
+    m_description = &dd4hep::Detector::getInstance(tagStr);
     m_description->addExtension<cms::DDVectorsMap>(&m_vectors);
-    m_context = new cms::DDParsingContext(*m_description, makePayload);
-    m_description->addExtension<cms::DDParsingContext>(m_context);
+    auto parsingContext = new cms::DDParsingContext(*m_description, makePayload);  // Removed at end of constructor
+    m_description->addExtension<cms::DDParsingContext>(parsingContext);
     m_description->addExtension<dd4hep::PartSelectionMap>(&m_partsels);
     m_description->addExtension<dd4hep::SpecParRegistry>(&m_specpars);
     m_description->setStdConditions("NTP");
diff --git a/DetectorDescription/DDCMS/src/DDFilteredView.cc b/DetectorDescription/DDCMS/src/DDFilteredView.cc
index dcb2a0938f1ba..d656338ca47bb 100644
--- a/DetectorDescription/DDCMS/src/DDFilteredView.cc
+++ b/DetectorDescription/DDCMS/src/DDFilteredView.cc
@@ -553,7 +553,7 @@ const std::vector<double> DDFilteredView::parameters() const {
 const cms::DDSolidShape DDFilteredView::shape() const {
   assert(node_);
   if ((volume().volume())->IsAssembly()) {
-    return (cms::DDSolidShape::ddbox);  // Return dummy box
+    return (cms::DDSolidShape::ddbox);  // Needs to be box to match DDFilteredView::solid()
   }
   return cms::dd::value(cms::DDSolidShapeMap, std::string(node_->GetVolume()->GetShape()->GetTitle()));
 }
@@ -865,6 +865,7 @@ std::string_view DDFilteredView::fullName() const {
 dd4hep::Solid DDFilteredView::solid() const {
   if ((volume().volume())->IsAssembly()) {
     std::string solName(name());
+    // Valid solid is needed, use a dummy box
     return (dd4hep::Box(solName, 1., 1., 1.));
   }
   return (volume().volume().solid());
diff --git a/DetectorDescription/DDCMS/src/DDNamespace.cc b/DetectorDescription/DDCMS/src/DDNamespace.cc
index a780974126d20..e71aab1b3429c 100644
--- a/DetectorDescription/DDCMS/src/DDNamespace.cc
+++ b/DetectorDescription/DDCMS/src/DDNamespace.cc
@@ -182,7 +182,6 @@ dd4hep::Volume DDNamespace::addVolumeNS(dd4hep::Volume vol) const {
   dd4hep::Material m = vol.material();
   vol->SetName(n.c_str());
   m_context->volumes[n] = vol;
-  m_context->volPtrs[n] = &(m_context->volumes[n]);
   const char* solidName = "Invalid solid";
   if (s.isValid())         // Protect against seg fault
     solidName = s.name();  // If Solid is not valid, s.name() will seg fault.
@@ -201,7 +200,6 @@ dd4hep::Volume DDNamespace::addVolume(dd4hep::Volume vol) const {
   dd4hep::Solid s = vol.solid();
   dd4hep::Material m = vol.material();
   m_context->volumes[n] = vol;
-  m_context->volPtrs[n] = &(m_context->volumes[n]);
   const char* solidName = "Invalid solid";
   if (s.isValid())         // Protect against seg fault
     solidName = s.name();  // If Solid is not valid, s.name() will seg fault.
@@ -219,7 +217,6 @@ dd4hep::Volume DDNamespace::addVolume(dd4hep::Volume vol) const {
 dd4hep::Assembly DDNamespace::addAssembly(dd4hep::Assembly assembly, bool addSolid) const {
   string n = assembly.name();
   m_context->assemblies[n] = assembly;
-  m_context->volPtrs[n] = &(m_context->assemblies[n]);
   if (addSolid) {  // In algorithms, Assembly solids are not added separately, so add it here
     m_context->assemblySolids.emplace(n);
   }
@@ -236,7 +233,7 @@ dd4hep::Assembly DDNamespace::addAssemblySolid(dd4hep::Assembly assembly) const
   return assembly;
 }
 
-dd4hep::Assembly DDNamespace::assembly(const std::string& name) const {
+dd4hep::Assembly DDNamespace::assembly(const std::string& name, bool exception) const {
   auto i = m_context->assemblies.find(name);
   if (i != m_context->assemblies.end()) {
     return (*i).second;
@@ -246,7 +243,11 @@ dd4hep::Assembly DDNamespace::assembly(const std::string& name) const {
     if (i != m_context->assemblies.end())
       return (*i).second;
   }
-  throw runtime_error("Unknown assembly identifier:" + name);
+  if (exception) {
+    throw runtime_error("Unknown assembly identifier: " + name);
+  }
+  dd4hep::Volume nullVol(nullptr);
+  return nullVol;
 }
 
 dd4hep::Volume DDNamespace::volume(const string& name, bool exc) const {
@@ -265,19 +266,6 @@ dd4hep::Volume DDNamespace::volume(const string& name, bool exc) const {
   return nullptr;
 }
 
-dd4hep::Volume* DDNamespace::getVolPtr(const string& name) const {
-  auto i = m_context->volPtrs.find(name);
-  if (i != m_context->volPtrs.end()) {
-    return (*i).second;
-  }
-  if (name.front() == NAMESPACE_SEP) {
-    i = m_context->volPtrs.find(name.substr(1, name.size()));
-    if (i != m_context->volPtrs.end())
-      return (*i).second;
-  }
-  return nullptr;
-}
-
 dd4hep::Solid DDNamespace::addSolidNS(const string& name, dd4hep::Solid solid) const {
   dd4hep::printout(m_context->debug_shapes ? dd4hep::ALWAYS : dd4hep::DEBUG,
                    "DD4CMS",
diff --git a/DetectorDescription/OfflineDBLoader/BuildFile.xml b/DetectorDescription/OfflineDBLoader/BuildFile.xml
index d4a2371c79865..c8b7837494e42 100644
--- a/DetectorDescription/OfflineDBLoader/BuildFile.xml
+++ b/DetectorDescription/OfflineDBLoader/BuildFile.xml
@@ -1,4 +1,9 @@
 <use name="DetectorDescription/Core"/>
+<use name="DetectorDescription/DDCMS"/>
+<use name="dd4hep"/>
+<use name="dd4hep-core"/>
+<use name="rootmath"/>
+<use name="rootgeom"/>
 <export>
   <lib name="1"/>
 </export>
diff --git a/DetectorDescription/OfflineDBLoader/interface/DDCoreToDDXMLOutput.h b/DetectorDescription/OfflineDBLoader/interface/DDCoreToDDXMLOutput.h
index 7913a690b3200..69c6ebf2ea5ac 100644
--- a/DetectorDescription/OfflineDBLoader/interface/DDCoreToDDXMLOutput.h
+++ b/DetectorDescription/OfflineDBLoader/interface/DDCoreToDDXMLOutput.h
@@ -14,15 +14,20 @@
 #include "DetectorDescription/Core/interface/DDTransform.h"
 #include "DetectorDescription/Core/interface/DDsvalues.h"
 
+#include "DetectorDescription/DDCMS/interface/DDParsingContext.h"
+
+#include "DD4hep/SpecParRegistry.h"
+
+#include "TGeoMaterial.h"
+
 class DDPartSelection;
 class DDRotation;
 struct DDPosData;
 
 /** @class DDCoreToDDXMLOutput DDCoreToDDXMLOutput.h
  *
- *  @author:  Michael Case               Initial Version
- *  @version: 0.0
- *  @date:    17.10.08
+ *  @author:  Michael Case  Revison for DD4hep
+ *  @version: 1.0
  * 
  *  Description:
  *       The idea is to store one large XML file containing the XML elements
@@ -34,26 +39,42 @@ struct DDPosData;
 
 struct DDCoreToDDXMLOutput {
   void solid(const DDSolid& solid, std::ostream& xos);
+  void solid(const dd4hep::Solid& solid, const cms::DDParsingContext& context, std::ostream& xos);
 
+  void element(const TGeoMaterial* element, std::ostream& xos);
   void material(const DDMaterial& material, std::ostream& xos);
+  void material(
+      const std::pair<std::string, std::pair<double, std::vector<cms::DDParsingContext::CompositeMaterial>>>& material,
+      std::ostream& xos);
 
   void rotation(const DDRotation& rotation, std::ostream& xos, const std::string& rotn = "");
+  void rotation(const dd4hep::Rotation3D& rotation,
+                std::ostream& xos,
+                const cms::DDParsingContext& context,
+                const std::string& rotn);
 
   void logicalPart(const DDLogicalPart& lp, std::ostream& xos);
+  void logicalPart(const std::string& asName, std::ostream& xos);
+  void logicalPart(const TGeoVolume& lp, std::ostream& xos);
 
   void position(const DDLogicalPart& parent,
                 const DDLogicalPart& child,
-                DDPosData* edgeToChild
-                //		   , PIdealGeometry& geom
-                ,
+                DDPosData* edgeToChild,
                 int& rotNameSeed,
                 std::ostream& xos);
+  void position(const TGeoVolume& parent,
+                const TGeoNode& child,
+                const std::string& childName,
+                cms::DDParsingContext& context,
+                std::ostream& xos);
+  //
   // left in for now as legacy...
   void specpar(const DDSpecifics& sp, std::ostream& xos);
-  void specpar(const std::pair<DDsvalues_type, std::set<const DDPartSelection*> >& pssv, std::ostream& xos);
+  void specpar(const std::pair<DDsvalues_type, std::set<const DDPartSelection*>>& pssv, std::ostream& xos);
+  void specpar(const std::string& name, const dd4hep::SpecPar& specPar, std::ostream& xos);
 
+  static std::string trimShapeName(const std::string& solidName);
   std::string ns_;  // default namespace
-  double tol_;
 };
 
 #endif
diff --git a/DetectorDescription/OfflineDBLoader/plugins/OutputDD4hepToDDL.cc b/DetectorDescription/OfflineDBLoader/plugins/OutputDD4hepToDDL.cc
new file mode 100644
index 0000000000000..caa71771f1f6b
--- /dev/null
+++ b/DetectorDescription/OfflineDBLoader/plugins/OutputDD4hepToDDL.cc
@@ -0,0 +1,190 @@
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/ESTransientHandle.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "DataFormats/Math/interface/angle_units.h"
+#include "DetectorDescription/OfflineDBLoader/interface/DDCoreToDDXMLOutput.h"
+#include "DetectorDescription/DDCMS/interface/DDAlgoArguments.h"
+#include "DetectorDescription/DDCMS/interface/DDCompactView.h"
+#include "DetectorDescription/DDCMS/interface/DDFilteredView.h"
+#include "DetectorDescription/DDCMS/interface/DDSolidShapes.h"
+#include "Geometry/Records/interface/IdealGeometryRecord.h"
+
+#include "TGeoManager.h"
+
+#include <cstddef>
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+class OutputDD4hepToDDL : public edm::one::EDAnalyzer<edm::one::WatchRuns> {
+public:
+  explicit OutputDD4hepToDDL(const edm::ParameterSet &iConfig);
+  ~OutputDD4hepToDDL() override;
+
+  void beginJob() override {}
+  void beginRun(edm::Run const &iEvent, edm::EventSetup const &) override;
+  void analyze(edm::Event const &iEvent, edm::EventSetup const &) override {}
+  void endRun(edm::Run const &iEvent, edm::EventSetup const &) override {}
+  void endJob() override {}
+
+private:
+  edm::ESGetToken<cms::DDCompactView, IdealGeometryRecord> cpvTokendd4hep_;
+  std::string m_fname;
+  std::ostream *m_xos;
+};
+
+OutputDD4hepToDDL::OutputDD4hepToDDL(const edm::ParameterSet &iConfig)
+    : cpvTokendd4hep_(esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", "make-payload"))), m_fname() {
+  m_fname = iConfig.getUntrackedParameter<std::string>("fileName");
+  if (m_fname.empty()) {
+    m_xos = &std::cout;
+  } else {
+    m_xos = new std::ofstream(m_fname.c_str());
+  }
+  (*m_xos) << "<?xml version=\"1.0\"?>" << std::endl;
+  (*m_xos) << "<DDDefinition>" << std::endl;
+}
+
+OutputDD4hepToDDL::~OutputDD4hepToDDL() {
+  (*m_xos) << "</DDDefinition>" << std::endl;
+  (*m_xos) << std::endl;
+  m_xos->flush();
+}
+
+void OutputDD4hepToDDL::beginRun(const edm::Run &, edm::EventSetup const &es) {
+  std::cout << "OutputDD4hepToDDL::beginRun" << std::endl;
+
+  edm::ESTransientHandle<cms::DDCompactView> cpv = es.getTransientHandle(cpvTokendd4hep_);
+
+  const cms::DDDetector *det = cpv->detector();
+  const dd4hep::Detector &detector = *det->description();
+  const dd4hep::SpecParRegistry &specStore = det->specpars();
+
+  DDCoreToDDXMLOutput out;
+
+  std::string rn = m_fname;
+  size_t foundLastDot = rn.find_last_of('.');
+  size_t foundLastSlash = rn.find_last_of('/');
+  if (foundLastSlash > foundLastDot && foundLastSlash != std::string::npos) {
+    std::cout << "What? last . before last / in path for filename... this should die..." << std::endl;
+  }
+  std::string ns_("none");
+  if (foundLastDot != std::string::npos && foundLastSlash != std::string::npos) {
+    ns_ = rn.substr(foundLastSlash, foundLastDot);
+  } else if (foundLastDot != std::string::npos) {
+    ns_ = rn.substr(0, foundLastDot);
+  } else {
+    std::cout << "What? no file name? Attempt at namespace =\"" << ns_ << "\" filename was " << m_fname << std::endl;
+  }
+  std::cout << "m_fname = " << m_fname << " namespace = " << ns_ << std::endl;
+
+  (*m_xos) << std::fixed << std::setprecision(5);  // Precison to 1e-5 mm
+  cms::DDParsingContext *const parsingContext = detector.extension<cms::DDParsingContext>();
+
+  {
+    // Add rotation for reference and to ease validation
+    using namespace angle_units::operators;
+    cms::DDNamespace nameSpace(*parsingContext);
+    dd4hep::Rotation3D rotation(1., 0., 0., 0., 1., 0., 0., 0., -1.);
+    rotation = rotation * dd4hep::RotationY(1._pi);
+    nameSpace.addRotation("ebalgo:reflZRotY", rotation);
+  }
+
+  (*m_xos) << "<PosPartSection label=\"" << ns_ << "\">" << std::endl;
+  const TGeoManager &mgr = detector.manager();
+  for (const auto &&iter : *mgr.GetListOfVolumes()) {
+    auto *vol = dynamic_cast<TGeoVolume *>(iter);
+    int numDaughters = vol->GetNdaughters();
+    if (numDaughters > 0) {
+      auto nodeArray = vol->GetNodes();
+      for (int index = 0; index < numDaughters; ++index) {
+        auto *node = dynamic_cast<TGeoNode *>((*nodeArray)[index]);
+        auto *childVol = node->GetVolume();
+        out.position(*vol, *node, childVol->GetName(), *parsingContext, *m_xos);
+      }
+    }
+  }
+  (*m_xos) << "</PosPartSection>" << std::endl;
+
+  (*m_xos) << "<MaterialSection label=\"" << ns_ << "\">" << std::endl;
+  for (const auto &&iter : *mgr.GetListOfMaterials()) {
+    out.element(dynamic_cast<const TGeoMaterial *>(iter), *m_xos);
+  }
+  // Output composite materials
+  for (const auto &it : parsingContext->allCompMaterials) {
+    out.material(it, *m_xos);
+  }
+  (*m_xos) << "</MaterialSection>" << std::endl;
+  (*m_xos) << "<RotationSection label=\"" << ns_ << "\">" << std::endl;
+  (*m_xos) << std::fixed << std::setprecision(10);  // Rounds angles to integer values w/o loss of accuracy
+  // rotRevMap has the unique rotations
+  for (const auto &rotPair : parsingContext->rotRevMap) {
+    out.rotation(parsingContext->rotations[rotPair.second], *m_xos, *parsingContext, rotPair.second);
+  }
+  (*m_xos) << "</RotationSection>" << std::endl;
+
+  (*m_xos) << std::fixed << std::setprecision(5);
+  (*m_xos) << "<SolidSection label=\"" << ns_ << "\">" << std::endl;
+  for (const auto &&iter : *mgr.GetListOfShapes()) {
+    auto *shape = dynamic_cast<TGeoShape *>(iter);
+    if (shape->IsValid()) {
+      dd4hep::Solid solid(shape);
+      if (strlen(shape->GetTitle()) > 1) {
+        out.solid(solid, *parsingContext, *m_xos);
+      } else {
+        std::string name(DDCoreToDDXMLOutput::trimShapeName(shape->GetName()));
+        if (name != "Box" && name != "Tubs") {  // Skip solids with degenerate names
+          if (dd4hep::isA<dd4hep::Tube>(solid)) {
+            shape->SetTitle("Tube");
+            out.solid(solid, *parsingContext, *m_xos);
+          } else if (dd4hep::isA<dd4hep::Box>(solid)) {
+            shape->SetTitle("Box");
+            out.solid(solid, *parsingContext, *m_xos);
+          } else if (dd4hep::isA<dd4hep::Trd1>(solid)) {
+            shape->SetTitle("Trd1");
+            out.solid(solid, *parsingContext, *m_xos);
+          } else
+            std::cout << "Division solid not a box, trd1, or tube = " << solid.name() << std::endl;
+        }
+      }
+    }
+  }
+  for (const auto &asmEntry : parsingContext->assemblySolids) {
+    (*m_xos) << "<Assembly name=\"" << asmEntry << "\"/>" << std::endl;
+  }
+  (*m_xos) << "</SolidSection>" << std::endl;
+
+  (*m_xos) << "<LogicalPartSection label=\"" << ns_ << "\">" << std::endl;
+  for (const auto &&iter : *mgr.GetListOfVolumes()) {
+    auto *vol = dynamic_cast<TGeoVolume *>(iter);
+    // Skip unused logical parts and assemblies, which are listed separately
+    if (vol->GetRefCount() > 0 && vol->IsAssembly() == false) {
+      out.logicalPart(*vol, *m_xos);
+    }
+  }
+  for (const auto &asEntry : parsingContext->assemblies) {
+    out.logicalPart(asEntry.first, *m_xos);
+  }
+  (*m_xos) << "</LogicalPartSection>" << std::endl;
+
+  (*m_xos) << std::fixed << std::setprecision(10);  // Some Tracker values specified to 1e-9
+  (*m_xos) << "<SpecParSection label=\"" << ns_ << "\">" << std::endl;
+  for (const auto &specPar : specStore.specpars) {
+    out.specpar(specPar.first, specPar.second, *m_xos);
+  }
+  (*m_xos) << "</SpecParSection>" << std::endl;
+}
+
+DEFINE_FWK_MODULE(OutputDD4hepToDDL);
diff --git a/DetectorDescription/OfflineDBLoader/src/DDCoreToDDXMLOutput.cc b/DetectorDescription/OfflineDBLoader/src/DDCoreToDDXMLOutput.cc
index b823cff17c05e..f99be33e89f6c 100644
--- a/DetectorDescription/OfflineDBLoader/src/DDCoreToDDXMLOutput.cc
+++ b/DetectorDescription/OfflineDBLoader/src/DDCoreToDDXMLOutput.cc
@@ -11,18 +11,316 @@
 #include "DetectorDescription/Core/interface/DDTransform.h"
 #include "DetectorDescription/Core/interface/DDValue.h"
 #include "DetectorDescription/Core/interface/DDValuePair.h"
+
+#include "DetectorDescription/DDCMS/interface/DDSolidShapes.h"
+#include "DetectorDescription/DDCMS/interface/DDNamespace.h"
+
 #include "DataFormats/Math/interface/GeantUnits.h"
+#include "DataFormats/Math/interface/Rounding.h"
 #include "FWCore/Utilities/interface/Exception.h"
 #include "Math/GenVector/Cartesian3D.h"
 #include "Math/GenVector/DisplacementVector3D.h"
 #include "Math/GenVector/Rotation3D.h"
 
+#include "DD4hep/Filter.h"
+#include "DD4hep/Shapes.h"
+
+#include "TGeoMedium.h"
+
 #include <cstddef>
 #include <iomanip>
 #include <vector>
 
 using namespace geant_units::operators;
 
+template <class NumType>
+static inline constexpr NumType convertGPerCcToMgPerCc(NumType gPerCc)  // g/cm^3 -> mg/cm^3
+{
+  return (gPerCc * 1000.);
+}
+
+namespace cms::rotation_utils {
+  /* For debugging 
+  static double determinant(const dd4hep::Rotation3D &rot) {
+    double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+    rot.GetComponents(xx, xy, xz, yx, yy, yz, zx, zy, zz); 
+    double term1 = xx * (yy * zz - yz * zy);
+    double term2 = yx * (xy * zz - xz * zy);
+    double term3 = zx * (xy * yz - yy * xz);
+    return (term1 - term2 + term3);
+  }
+  */
+
+  static const std::string identityHash("1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000");
+
+  static void addRotWithNewName(cms::DDNamespace& ns, std::string& name, const dd4hep::Rotation3D& rot) {
+    const dd4hep::Rotation3D& rot2 = rot;
+    name = name + "_DdNoNa";  // Name used by old DD to indicate an unnamed rotation
+    ns.addRotation(name, rot2);
+  }
+
+  static void addRotWithNewName(cms::DDNamespace& ns, std::string& name, const Double_t* rot) {
+    using namespace cms_rounding;
+    dd4hep::Rotation3D rot2(roundIfNear0(rot[0]),
+                            roundIfNear0(rot[1]),
+                            roundIfNear0(rot[2]),
+                            roundIfNear0(rot[3]),
+                            roundIfNear0(rot[4]),
+                            roundIfNear0(rot[5]),
+                            roundIfNear0(rot[6]),
+                            roundIfNear0(rot[7]),
+                            roundIfNear0(rot[8]));
+    addRotWithNewName(ns, name, rot2);
+  }
+
+  template <typename T>
+  static const std::string& rotName(const T& rot, const cms::DDParsingContext& context) {
+    std::string hashVal = rotHash(rot);
+    auto rotNameIter = context.rotRevMap.find(hashVal);
+    if (rotNameIter != context.rotRevMap.end()) {
+      return (rotNameIter->second);
+    }
+    static const std::string nullStr{"NULL"};
+    return (nullStr);
+  }
+
+}  // namespace cms::rotation_utils
+
+std::string DDCoreToDDXMLOutput::trimShapeName(const std::string& solidName) {
+  size_t trimPt = solidName.find("_shape_0x");
+  if (trimPt != std::string::npos)
+    return (solidName.substr(0, trimPt));
+  return (solidName);
+}
+
+void DDCoreToDDXMLOutput::solid(const dd4hep::Solid& solid, const cms::DDParsingContext& context, std::ostream& xos) {
+  cms::DDSolidShape shape = cms::dd::value(cms::DDSolidShapeMap, std::string(solid.title()));
+  switch (shape) {
+    case cms::DDSolidShape::ddunion:
+    case cms::DDSolidShape::ddsubtraction:
+    case cms::DDSolidShape::ddintersection: {
+      dd4hep::BooleanSolid rs(solid);
+      if (shape == cms::DDSolidShape::ddunion) {
+        xos << "<UnionSolid ";
+      } else if (shape == cms::DDSolidShape::ddsubtraction) {
+        xos << "<SubtractionSolid ";
+      } else if (shape == cms::DDSolidShape::ddintersection) {
+        xos << "<IntersectionSolid ";
+      }
+      xos << "name=\"" << trimShapeName(solid.name()) << "\">" << std::endl;
+      xos << "<rSolid name=\"" << trimShapeName(rs.leftShape().name()) << "\"/>" << std::endl;
+      xos << "<rSolid name=\"" << trimShapeName(rs.rightShape().name()) << "\"/>" << std::endl;
+      const Double_t* trans = rs.rightMatrix()->GetTranslation();
+      xos << "<Translation x=\"" << trans[0] << "*mm\"";
+      xos << " y=\"" << trans[1] << "*mm\"";
+      xos << " z=\"" << trans[2] << "*mm\"";
+      xos << "/>" << std::endl;
+      std::string rotNameStr = cms::rotation_utils::rotName(rs.rightMatrix()->GetRotationMatrix(), context);
+      xos << "<rRotation name=\"" << rotNameStr << "\"/>" << std::endl;
+      if (shape == cms::DDSolidShape::ddunion) {
+        xos << "</UnionSolid>" << std::endl;
+      } else if (shape == cms::DDSolidShape::ddsubtraction) {
+        xos << "</SubtractionSolid>" << std::endl;
+      } else if (shape == cms::DDSolidShape::ddintersection) {
+        xos << "</IntersectionSolid>" << std::endl;
+      }
+      break;
+    }
+    case cms::DDSolidShape::ddbox: {
+      dd4hep::Box rs(solid);
+      xos << "<Box name=\"" << trimShapeName(rs.name()) << "\""
+          << " dx=\"" << rs.x() << "*mm\""
+          << " dy=\"" << rs.y() << "*mm\""
+          << " dz=\"" << rs.z() << "*mm\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtubs: {
+      dd4hep::Tube rs(solid);
+      double startPhi = convertRadToDeg(rs.startPhi());
+      if (startPhi > 180. && startPhi <= 360.)
+        startPhi -= 360.;
+      // Convert large positive angles to small negative ones
+      // to match how they are usually defined
+
+      xos << "<Tubs name=\"" << trimShapeName(rs.name()) << "\""
+          << " rMin=\"" << rs.rMin() << "*mm\""
+          << " rMax=\"" << rs.rMax() << "*mm\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " startPhi=\"" << startPhi << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.endPhi() - rs.startPhi()) << "*deg\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtrd1: {
+      dd4hep::Trd1 rs(solid);
+      xos << "<Trd1 name=\"" << trimShapeName(rs.name()) << "\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " dy1=\"" << rs.dY() << "*mm\""
+          << " dy2=\"" << rs.dY() << "*mm\""
+          << " dx1=\"" << rs.dX1() << "*mm\""
+          << " dx2=\"" << rs.dX2() << "*mm\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtrd2: {
+      dd4hep::Trd2 rs(solid);
+      xos << "<Trd1 name=\"" << trimShapeName(rs.name()) << "\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " dy1=\"" << rs.dY1() << "*mm\""
+          << " dy2=\"" << rs.dY2() << "*mm\""
+          << " dx1=\"" << rs.dX1() << "*mm\""
+          << " dx2=\"" << rs.dX2() << "*mm\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtrap: {
+      dd4hep::Trap rs(solid);
+      xos << "<Trapezoid name=\"" << trimShapeName(rs.name()) << "\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " theta=\"" << convertRadToDeg(rs.theta()) << "*deg\""
+          << " phi=\"" << convertRadToDeg(rs.phi()) << "*deg\""
+          << " h1=\"" << rs.high1() << "*mm\""
+          << " bl1=\"" << rs.bottomLow1() << "*mm\""
+          << " tl1=\"" << rs.topLow1() << "*mm\""
+          << " alp1=\"" << convertRadToDeg(rs.alpha1()) << "*deg\""
+          << " h2=\"" << rs.high2() << "*mm\""
+          << " bl2=\"" << rs.bottomLow2() << "*mm\""
+          << " tl2=\"" << rs.topLow2() << "*mm\""
+          << " alp2=\"" << convertRadToDeg(rs.alpha2()) << "*deg\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddcons: {
+      dd4hep::ConeSegment rs(solid);
+      double startPhi = convertRadToDeg(rs.startPhi());
+      if (startPhi > 180. && startPhi <= 360.)
+        startPhi -= 360.;
+      // Convert large positive angles to small negative ones
+      // to match how they are usually defined
+      //
+      xos << "<Cone name=\"" << trimShapeName(rs.name()) << "\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " rMin1=\"" << rs.rMin1() << "*mm\""
+          << " rMax1=\"" << rs.rMax1() << "*mm\""
+          << " rMin2=\"" << rs.rMin2() << "*mm\""
+          << " rMax2=\"" << rs.rMax2() << "*mm\""
+          << " startPhi=\"" << startPhi << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.endPhi() - rs.startPhi()) << "*deg\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddpolycone: {
+      //   <Polycone name="OCMS" startPhi="0*deg" deltaPhi="360*deg" >
+      //    <ZSection z="-[CMSZ1]"  rMin="[Rmin]"  rMax="[CMSR2]" />
+      //    <ZSection z="-[HallZ]"  rMin="[Rmin]"  rMax="[CMSR2]" />
+      //    <ZSection z="-[HallZ]"  rMin="[Rmin]"  rMax="[HallR]" />
+      //    <ZSection z="[HallZ]"   rMin="[Rmin]"  rMax="[HallR]" />
+      //    <ZSection z="[HallZ]"   rMin="[Rmin]"  rMax="[CMSR2]" />
+      //    <ZSection z="[CMSZ1]"   rMin="[Rmin]"  rMax="[CMSR2]" />
+      dd4hep::Polycone rs(solid);
+      xos << "<Polycone name=\"" << trimShapeName(rs.name()) << "\""
+          << " startPhi=\"" << convertRadToDeg(rs.startPhi()) << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.deltaPhi()) << "*deg\">" << std::endl;
+      const std::vector<double>& zV(rs.zPlaneZ());
+      const std::vector<double>& rMinV(rs.zPlaneRmin());
+      const std::vector<double>& rMaxV(rs.zPlaneRmax());
+      for (size_t i = 0; i < zV.size(); ++i) {
+        xos << "<ZSection z=\"" << zV[i] << "*mm\""
+            << " rMin=\"" << rMinV[i] << "*mm\""
+            << " rMax=\"" << rMaxV[i] << "*mm\"/>" << std::endl;
+      }
+      xos << "</Polycone>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddpolyhedra: {
+      dd4hep::Polyhedra rs(solid);
+      xos << "<Polyhedra name=\"" << trimShapeName(rs.name()) << "\""
+          << " numSide=\"" << rs.numEdges() << "\""
+          << " startPhi=\"" << convertRadToDeg(rs.startPhi()) << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.deltaPhi()) << "*deg\">" << std::endl;
+      const std::vector<double>& zV(rs.zPlaneZ());
+      const std::vector<double>& rMinV(rs.zPlaneRmin());
+      const std::vector<double>& rMaxV(rs.zPlaneRmax());
+      for (size_t i = 0; i < zV.size(); ++i) {
+        xos << "<ZSection z=\"" << zV[i] << "*mm\""
+            << " rMin=\"" << rMinV[i] << "*mm\""
+            << " rMax=\"" << rMaxV[i] << "*mm\"/>" << std::endl;
+      }
+      xos << "</Polyhedra>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtrunctubs: {
+      dd4hep::TruncatedTube rs(solid);
+      xos << "<TruncTubs name=\"" << trimShapeName(rs.name()) << "\""
+          << " zHalf=\"" << rs.dZ() << "*mm\""
+          << " rMin=\"" << rs.rMin() << "*mm\""
+          << " rMax=\"" << rs.rMax() << "*mm\""
+          << " startPhi=\"" << convertRadToDeg(rs.startPhi()) << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.deltaPhi()) << "*deg\""
+          << " cutAtStart=\"" << rs.cutAtStart() << "*mm\""
+          << " cutAtDelta=\"" << rs.cutAtDelta() << "*mm\""
+          << " cutInside=\"" << (rs.cutInside() ? "true" : "false") << "\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddtorus: {
+      dd4hep::Torus rs(solid);
+      xos << "<Torus name=\"" << trimShapeName(rs.name()) << "\""
+          << " innerRadius=\"" << rs.rMin() << "*mm\""
+          << " outerRadius=\"" << rs.rMax() << "*mm\""
+          << " torusRadius=\"" << rs.r() << "*mm\""
+          << " startPhi=\"" << convertRadToDeg(rs.startPhi()) << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.deltaPhi()) << "*deg\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddellipticaltube: {
+      dd4hep::EllipticalTube rs(solid);
+      xos << "<EllipticalTube name=\"" << trimShapeName(rs.name()) << "\""
+          << " xSemiAxis=\"" << rs.a() << "*mm\""
+          << " ySemiAxis=\"" << rs.b() << "*mm\""
+          << " zHeight=\"" << rs.dZ() << "*mm\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddcuttubs: {
+      dd4hep::CutTube rs(solid);
+      const std::vector<double>& pLowNorm(rs.lowNormal());
+      const std::vector<double>& pHighNorm(rs.highNormal());
+
+      xos << "<CutTubs name=\"" << trimShapeName(solid.name()) << "\""
+          << " dz=\"" << rs.dZ() << "*mm\""
+          << " rMin=\"" << rs.rMin() << "*mm\""
+          << " rMax=\"" << rs.rMax() << "*mm\""
+          << " startPhi=\"" << convertRadToDeg(rs.startPhi()) << "*deg\""
+          << " deltaPhi=\"" << convertRadToDeg(rs.endPhi() - rs.startPhi()) << "*deg\""
+          << " lx=\"" << pLowNorm[0] << "\""
+          << " ly=\"" << pLowNorm[1] << "\""
+          << " lz=\"" << pLowNorm[2] << "\""
+          << " tx=\"" << pHighNorm[0] << "\""
+          << " ty=\"" << pHighNorm[1] << "\""
+          << " tz=\"" << pHighNorm[2] << "\"/>" << std::endl;
+      break;
+    }
+    case cms::DDSolidShape::ddextrudedpolygon: {
+      dd4hep::ExtrudedPolygon rs(solid);
+      std::vector<double> x = rs.x();
+      std::vector<double> y = rs.y();
+      std::vector<double> z = rs.z();
+      std::vector<double> zx = rs.zx();
+      std::vector<double> zy = rs.zy();
+      std::vector<double> zs = rs.zscale();
+
+      xos << "<ExtrudedPolygon name=\"" << trimShapeName(rs.name()) << "\"";
+      for (unsigned int i = 0; i < x.size(); ++i)
+        xos << " <XYPoint x=\"" << x[i] << "*mm\" y=\"" << y[i] << "*mm\"/>\n";
+      for (unsigned int k = 0; k < z.size(); ++k)
+        xos << " <ZXYSection z=\"" << z[k] << "*mm\" x=\"" << zx[k] << "*mm\" y=\"" << zy[k] << "*mm scale=" << zs[k]
+            << "*mm\"/>\n";
+      xos << "</ExtrudedPolygon>\n";
+      break;
+    }
+    case cms::DDSolidShape::dd_not_init:
+    default:
+      throw cms::Exception("DDException")
+          << "DDCoreToDDXMLOutput::solid " << solid.name() << ", shape ID = " << static_cast<int>(shape)
+          << ", solid title = " << solid.title();
+      break;
+  }
+}
+
 void DDCoreToDDXMLOutput::solid(const DDSolid& solid, std::ostream& xos) {
   switch (solid.shape()) {
     case DDSolidShape::ddunion:
@@ -279,8 +577,6 @@ void DDCoreToDDXMLOutput::solid(const DDSolid& solid, std::ostream& xos) {
       xos << "</ExtrudedPolygon>\n";
       break;
     }
-      //       return new PSolid( pstrs(solid.toString()), solid.parameters()
-      // 			 , solid.shape(), pstrs(""), pstrs(""), pstrs("") );
     case DDSolidShape::dd_not_init:
     default:
       throw cms::Exception("DDException")
@@ -314,10 +610,61 @@ void DDCoreToDDXMLOutput::material(const DDMaterial& material, std::ostream& xos
   }
 }
 
+void DDCoreToDDXMLOutput::material(
+    const std::pair<std::string, std::pair<double, std::vector<cms::DDParsingContext::CompositeMaterial>>>& material,
+    std::ostream& xos) {
+  xos << "<CompositeMaterial name=\"" << material.first << "\""
+      << " density=\"" << std::scientific << std::setprecision(5) << convertGPerCcToMgPerCc(material.second.first)
+      << "*mg/cm3\""
+      << " method=\"mixture by weight\">" << std::endl;
+
+  auto compIter = material.second.second.begin();
+  for (; compIter != material.second.second.end(); ++compIter) {
+    xos << "<MaterialFraction fraction=\"" << std::fixed << std::setprecision(9) << compIter->fraction << "\">"
+        << std::endl;
+    xos << "<rMaterial name=\"" << compIter->name << "\"/>" << std::endl;
+    xos << "</MaterialFraction>" << std::endl;
+  }
+  xos << "</CompositeMaterial>" << std::endl;
+}
+
+void DDCoreToDDXMLOutput::element(const TGeoMaterial* material, std::ostream& xos) {
+  int noc = material->GetNelements();
+  if (noc == 1) {
+    TGeoElement* elem = material->GetElement();
+    std::string nameLowerCase(elem->GetTitle());
+    // Leave first letter capitalized
+    for (size_t index = 1; index < nameLowerCase.size(); ++index) {
+      nameLowerCase[index] = tolower(nameLowerCase[index]);
+    }
+    std::string trimName(dd4hep::dd::noNamespace(material->GetName()));
+
+    // Element title contains element name in all uppercase.
+    // Convert to lowercase and check that material name matches element name.
+    // Hydrogen is used for vacuum materials. Phosphorus is called "Phosphor"
+    // Boron is a special case because there are two isotopes defined: "Bor 10" and "Bor 11".
+    if (trimName == nameLowerCase || nameLowerCase == "Hydrogen" || nameLowerCase == "Phosphorus" ||
+        (nameLowerCase == "Boron" && trimName.compare(0, 3, "Bor") == 0)) {
+      xos << "<ElementaryMaterial name=\"" << material->GetName() << "\""
+          << " density=\"" << std::scientific << std::setprecision(5) << convertGPerCcToMgPerCc(material->GetDensity())
+          << "*mg/cm3\""
+          << " atomicWeight=\"" << std::fixed << material->GetA() << "*g/mole\"" << std::setprecision(0) << std::fixed
+          << " atomicNumber=\"" << material->GetZ() << "\"/>" << std::endl;
+    }
+  }
+}
+
 void DDCoreToDDXMLOutput::rotation(const DDRotation& rotation, std::ostream& xos, const std::string& rotn) {
   double tol = 1.0e-3;  // Geant4 compatible
   DD3Vector x, y, z;
   rotation.rotation().GetComponents(x, y, z);
+  double a, b, c;
+  x.GetCoordinates(a, b, c);
+  x.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
+  y.GetCoordinates(a, b, c);
+  y.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
+  z.GetCoordinates(a, b, c);
+  z.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
   double check = (x.Cross(y)).Dot(z);  // in case of a LEFT-handed orthogonal system
                                        // this must be -1
   bool reflection((1. - check) > tol);
@@ -337,13 +684,46 @@ void DDCoreToDDXMLOutput::rotation(const DDRotation& rotation, std::ostream& xos
   } else {
     xos << "<ReflectionRotation ";
   }
+  using namespace cms_rounding;
   xos << "name=\"" << rotName << "\""
-      << " phiX=\"" << convertRadToDeg(x.phi()) << "*deg\""
-      << " thetaX=\"" << convertRadToDeg(x.theta()) << "*deg\""
-      << " phiY=\"" << convertRadToDeg(y.phi()) << "*deg\""
-      << " thetaY=\"" << convertRadToDeg(y.theta()) << "*deg\""
-      << " phiZ=\"" << convertRadToDeg(z.phi()) << "*deg\""
-      << " thetaZ=\"" << convertRadToDeg(z.theta()) << "*deg\"/>" << std::endl;
+      << " phiX=\"" << roundIfNear0(convertRadToDeg(x.phi()), 4.e-4) << "*deg\""
+      << " thetaX=\"" << roundIfNear0(convertRadToDeg(x.theta()), 4.e-4) << "*deg\""
+      << " phiY=\"" << roundIfNear0(convertRadToDeg(y.phi()), 4.e-4) << "*deg\""
+      << " thetaY=\"" << roundIfNear0(convertRadToDeg(y.theta()), 4.e-4) << "*deg\""
+      << " phiZ=\"" << roundIfNear0(convertRadToDeg(z.phi()), 4.e-4) << "*deg\""
+      << " thetaZ=\"" << roundIfNear0(convertRadToDeg(z.theta()), 4.e-4) << "*deg\"/>" << std::endl;
+}
+
+void DDCoreToDDXMLOutput::rotation(const dd4hep::Rotation3D& rotation,
+                                   std::ostream& xos,
+                                   const cms::DDParsingContext& context,
+                                   const std::string& rotn) {
+  double tol = 1.0e-3;  // Geant4 compatible
+  ROOT::Math::XYZVector x, y, z;
+  rotation.GetComponents(x, y, z);
+  double a, b, c;
+  x.GetCoordinates(a, b, c);
+  x.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
+  y.GetCoordinates(a, b, c);
+  y.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
+  z.GetCoordinates(a, b, c);
+  z.SetCoordinates(cms_rounding::roundIfNear0(a), cms_rounding::roundIfNear0(b), cms_rounding::roundIfNear0(c));
+  double check = (x.Cross(y)).Dot(z);  // in case of a LEFT-handed orthogonal system
+                                       // this must be -1
+  bool reflection((1. - check) > tol);
+  if (!reflection) {
+    xos << "<Rotation ";
+  } else {
+    xos << "<ReflectionRotation ";
+  }
+  using namespace cms_rounding;
+  xos << "name=\"" << rotn << "\""
+      << " phiX=\"" << roundIfNear0(convertRadToDeg(x.phi()), 4.e-4) << "*deg\""
+      << " thetaX=\"" << roundIfNear0(convertRadToDeg(x.theta()), 4.e-4) << "*deg\""
+      << " phiY=\"" << roundIfNear0(convertRadToDeg(y.phi()), 4.e-4) << "*deg\""
+      << " thetaY=\"" << roundIfNear0(convertRadToDeg(y.theta()), 4.e-4) << "*deg\""
+      << " phiZ=\"" << roundIfNear0(convertRadToDeg(z.phi()), 4.e-4) << "*deg\""
+      << " thetaZ=\"" << roundIfNear0(convertRadToDeg(z.theta()), 4.e-4) << "*deg\"/>" << std::endl;
 }
 
 void DDCoreToDDXMLOutput::logicalPart(const DDLogicalPart& lp, std::ostream& xos) {
@@ -353,6 +733,58 @@ void DDCoreToDDXMLOutput::logicalPart(const DDLogicalPart& lp, std::ostream& xos
   xos << "</LogicalPart>" << std::endl;
 }
 
+void DDCoreToDDXMLOutput::logicalPart(const std::string& asName, std::ostream& xos) {
+  xos << "<LogicalPart name=\"" << asName << "\">" << std::endl;
+  xos << "<rSolid name=\"" << asName << "\"/>" << std::endl;
+  xos << "<rMaterial name=\"materials:Air\"/>" << std::endl;
+  xos << "</LogicalPart>" << std::endl;
+}
+
+void DDCoreToDDXMLOutput::logicalPart(const TGeoVolume& lp, std::ostream& xos) {
+  xos << "<LogicalPart name=\"" << lp.GetName() << "\">" << std::endl;
+  auto solid = lp.GetShape();
+  if (solid != nullptr) {
+    xos << "<rSolid name=\"" << trimShapeName(solid->GetName()) << "\"/>" << std::endl;
+  }
+  auto material = lp.GetMaterial();
+  if (material != nullptr) {
+    xos << "<rMaterial name=\"" << material->GetName() << "\"/>" << std::endl;
+  }
+  xos << "</LogicalPart>" << std::endl;
+}
+
+void DDCoreToDDXMLOutput::position(const TGeoVolume& parent,
+                                   const TGeoNode& child,
+                                   const std::string& childVolName,
+                                   cms::DDParsingContext& context,
+                                   std::ostream& xos) {
+  xos << "<PosPart copyNumber=\"" << child.GetNumber() << "\">" << std::endl;
+  xos << "<rParent name=\"" << parent.GetName() << "\"/>" << std::endl;
+  xos << "<rChild name=\"" << childVolName << "\"/>" << std::endl;
+
+  const auto matrix = child.GetMatrix();
+  if (matrix != nullptr && !matrix->IsIdentity()) {
+    auto rot = matrix->GetRotationMatrix();
+    if (cms::rotation_utils::rotHash(rot) != cms::rotation_utils::identityHash) {
+      std::string rotNameStr = cms::rotation_utils::rotName(rot, context);
+      if (rotNameStr == "NULL") {
+        rotNameStr = child.GetName();  // Phys vol name
+        rotNameStr += parent.GetName();
+        cms::DDNamespace nameSpace(context);
+        cms::rotation_utils::addRotWithNewName(nameSpace, rotNameStr, rot);
+      }
+      xos << "<rRotation name=\"" << rotNameStr << "\"/>" << std::endl;
+    }
+  }
+  auto trans = matrix->GetTranslation();
+  using namespace cms_rounding;
+  xos << "<Translation x=\"" << roundIfNear0(trans[0]) << "*mm\"";
+  xos << " y=\"" << roundIfNear0(trans[1]) << "*mm\"";
+  xos << " z=\"" << roundIfNear0(trans[2]) << "*mm\"";
+  xos << "/>" << std::endl;
+  xos << "</PosPart>" << std::endl;
+}
+
 void DDCoreToDDXMLOutput::position(const DDLogicalPart& parent,
                                    const DDLogicalPart& child,
                                    DDPosData* edgeToChild,
@@ -371,9 +803,10 @@ void DDCoreToDDXMLOutput::position(const DDLogicalPart& parent,
       xos << "<rRotation name=\"" << rotName << "\"/>" << std::endl;
     }
   }  // else let default Rotation matrix be created?
-  xos << "<Translation x=\"" << edgeToChild->translation().x() << "*mm\""
-      << " y=\"" << edgeToChild->translation().y() << "*mm\""
-      << " z=\"" << edgeToChild->translation().z() << "*mm\"/>" << std::endl;
+  using namespace cms_rounding;
+  xos << "<Translation x=\"" << roundIfNear0(edgeToChild->translation().x()) << "*mm\""
+      << " y=\"" << roundIfNear0(edgeToChild->translation().y()) << "*mm\""
+      << " z=\"" << roundIfNear0(edgeToChild->translation().z()) << "*mm\"/>" << std::endl;
   xos << "</PosPart>" << std::endl;
 }
 
@@ -409,7 +842,31 @@ void DDCoreToDDXMLOutput::specpar(const DDSpecifics& sp, std::ostream& xos) {
   xos << "</SpecPar>" << std::endl;
 }
 
-void DDCoreToDDXMLOutput::specpar(const std::pair<DDsvalues_type, std::set<const DDPartSelection*> >& pssv,
+void DDCoreToDDXMLOutput::specpar(const std::string& name, const dd4hep::SpecPar& specPar, std::ostream& xos) {
+  xos << "<SpecPar name=\"" << name << "\" eval=\"false\">" << std::endl;
+
+  for (const auto& psit : specPar.paths) {
+    xos << "<PartSelector path=\"" << psit << "\"/>" << std::endl;
+  }
+
+  for (const auto& vit : specPar.spars) {
+    for (const auto& sit : vit.second) {
+      xos << "<Parameter name=\"" << vit.first << "\""
+          << " value=\"" << sit << "\""
+          << " eval=\"false\"/>" << std::endl;
+    }
+  }
+  for (const auto& vit : specPar.numpars) {
+    for (const auto& sit : vit.second) {
+      xos << "<Parameter name=\"" << vit.first << "\""
+          << " value=\"" << sit << "\""
+          << " eval=\"true\"/>" << std::endl;
+    }
+  }
+  xos << "</SpecPar>" << std::endl;
+}
+
+void DDCoreToDDXMLOutput::specpar(const std::pair<DDsvalues_type, std::set<const DDPartSelection*>>& pssv,
                                   std::ostream& xos) {
   static const std::string madeName("specparname");
   static int numspecpars(0);
diff --git a/Geometry/EcalAlgo/python/EcalBarrelGeometryDBWriter_cfi.py b/Geometry/EcalAlgo/python/EcalBarrelGeometryDBWriter_cfi.py
index b0ec4e18b636e..717ac55135074 100644
--- a/Geometry/EcalAlgo/python/EcalBarrelGeometryDBWriter_cfi.py
+++ b/Geometry/EcalAlgo/python/EcalBarrelGeometryDBWriter_cfi.py
@@ -1,12 +1,19 @@
 import FWCore.ParameterSet.Config as cms
 
-EcalBarrelGeometryEP = cms.ESProducer( "EcalBarrelGeometryEP",
-                                       applyAlignment = cms.bool(False),
-                                       appendToDataLabel = cms.string("_master")
-                                       )
+EcalBarrelGeometryEP = cms.ESProducer("EcalBarrelGeometryEP",
+                                      applyAlignment = cms.bool(False),
+                                      appendToDataLabel = cms.string("_master")
+)
 
-EcalBarrelGeometryToDBEP = cms.ESProducer( "EcalBarrelGeometryToDBEP",
-                                           applyAlignment = cms.bool(False),
-                                           appendToDataLabel = cms.string("_toDB")
-                                           )
+_EcalBarrelGeometryEP_dd4hep = cms.ESProducer("EcalBarrelGeometryEPdd4hep",
+                                              applyAlignment = cms.bool(False),
+                                              appendToDataLabel = cms.string("_master")
+)
 
+from Configuration.ProcessModifiers.dd4hep_cff import dd4hep
+dd4hep.toReplaceWith(EcalBarrelGeometryEP, _EcalBarrelGeometryEP_dd4hep)
+
+EcalBarrelGeometryToDBEP = cms.ESProducer("EcalBarrelGeometryToDBEP",
+                                          applyAlignment = cms.bool(False),
+                                          appendToDataLabel = cms.string("_toDB")
+)
diff --git a/Geometry/EcalAlgo/python/EcalEndcapGeometryDBWriter_cfi.py b/Geometry/EcalAlgo/python/EcalEndcapGeometryDBWriter_cfi.py
index 5cfe7f46c1840..13efc7afb3bc3 100644
--- a/Geometry/EcalAlgo/python/EcalEndcapGeometryDBWriter_cfi.py
+++ b/Geometry/EcalAlgo/python/EcalEndcapGeometryDBWriter_cfi.py
@@ -1,11 +1,19 @@
 import FWCore.ParameterSet.Config as cms
 
-EcalEndcapGeometryEP = cms.ESProducer( "EcalEndcapGeometryEP",
-                                       applyAlignment = cms.bool(False),
-                                       appendToDataLabel = cms.string("_master")
-                                       )
-
-EcalEndcapGeometryToDBEP = cms.ESProducer( "EcalEndcapGeometryToDBEP",
-                                           applyAlignment = cms.bool(False),
-                                           appendToDataLabel = cms.string("_toDB")
-                                           )
+EcalEndcapGeometryEP = cms.ESProducer("EcalEndcapGeometryEP",
+                                      applyAlignment = cms.bool(False),
+                                      appendToDataLabel = cms.string("_master")
+)
+
+_EcalEndcapGeometryEP_dd4hep = cms.ESProducer("EcalEndcapGeometryEPdd4hep",
+                                              applyAlignment = cms.bool(False),
+                                              appendToDataLabel = cms.string("_master")
+)
+
+from Configuration.ProcessModifiers.dd4hep_cff import dd4hep
+dd4hep.toReplaceWith(EcalEndcapGeometryEP, _EcalEndcapGeometryEP_dd4hep)
+
+EcalEndcapGeometryToDBEP = cms.ESProducer("EcalEndcapGeometryToDBEP",
+                                          applyAlignment = cms.bool(False),
+                                          appendToDataLabel = cms.string("_toDB")
+)
diff --git a/Geometry/EcalAlgo/python/EcalPreshowerGeometryDBWriter_cfi.py b/Geometry/EcalAlgo/python/EcalPreshowerGeometryDBWriter_cfi.py
index 69671392e5a7f..e61115fb9ee77 100644
--- a/Geometry/EcalAlgo/python/EcalPreshowerGeometryDBWriter_cfi.py
+++ b/Geometry/EcalAlgo/python/EcalPreshowerGeometryDBWriter_cfi.py
@@ -1,11 +1,19 @@
 import FWCore.ParameterSet.Config as cms
 
-EcalPreshowerGeometryEP = cms.ESProducer( "EcalPreshowerGeometryEP",
-                                          applyAlignment = cms.bool(False),
-                                          appendToDataLabel = cms.string("_master")
-                                          )
-
-EcalPreshowerGeometryToDBEP = cms.ESProducer( "EcalPreshowerGeometryToDBEP",
-                                              applyAlignment = cms.bool(False),
-                                              appendToDataLabel = cms.string("_toDB")
-                                              )
+EcalPreshowerGeometryEP = cms.ESProducer("EcalPreshowerGeometryEP",
+                                         applyAlignment = cms.bool(False),
+                                         appendToDataLabel = cms.string("_master")
+)
+
+_EcalPreshowerGeometryEP_dd4hep = cms.ESProducer("EcalPreshowerGeometryEPdd4hep",
+                                                 applyAlignment = cms.bool(False),
+                                                 appendToDataLabel = cms.string("_master")
+)
+
+from Configuration.ProcessModifiers.dd4hep_cff import dd4hep
+dd4hep.toReplaceWith(EcalPreshowerGeometryEP, _EcalPreshowerGeometryEP_dd4hep)
+
+EcalPreshowerGeometryToDBEP = cms.ESProducer("EcalPreshowerGeometryToDBEP",
+                                             applyAlignment = cms.bool(False),
+                                             appendToDataLabel = cms.string("_toDB")
+)
diff --git a/Geometry/TrackerGeometryBuilder/test/ModuleInfo.cc b/Geometry/TrackerGeometryBuilder/test/ModuleInfo.cc
index 10666e15df9a2..33522e0ef4fb9 100644
--- a/Geometry/TrackerGeometryBuilder/test/ModuleInfo.cc
+++ b/Geometry/TrackerGeometryBuilder/test/ModuleInfo.cc
@@ -91,6 +91,8 @@ void ModuleInfo::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup
   std::ofstream Output("ModuleInfo.log", std::ios::out);
   // TEC output as Martin Weber's
   std::ofstream TECOutput("TECLayout_CMSSW.dat", std::ios::out);
+  TECOutput << std::fixed << std::setprecision(4);
+
   // Numbering Scheme
   std::ofstream NumberingOutput("ModuleNumbering.dat", std::ios::out);
 
diff --git a/Geometry/TrackerNumberingBuilder/src/GeometricDet.cc b/Geometry/TrackerNumberingBuilder/src/GeometricDet.cc
index 5d6fd88573eb8..e5fb8dba2b45f 100644
--- a/Geometry/TrackerNumberingBuilder/src/GeometricDet.cc
+++ b/Geometry/TrackerNumberingBuilder/src/GeometricDet.cc
@@ -1,6 +1,8 @@
 #include <DD4hep/DD4hepUnits.h>
 
+#include "DataFormats/Math/interface/deltaPhi.h"
 #include "DataFormats/Math/interface/GeantUnits.h"
+#include "DataFormats/Math/interface/Rounding.h"
 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
 #include "Geometry/TrackerNumberingBuilder/interface/TrackerShapeToBounds.h"
 #include "DetectorDescription/Core/interface/DDFilteredView.h"
@@ -112,6 +114,12 @@ GeometricDet::GeometricDet(cms::DDFilteredView* fv, GeometricEnumType type)
       shape_(fv->shape()),
       params_(computeLegacyShapeParameters(shape_, fv->solid())),
       isFromDD4hep_(true) {
+  using namespace angle_units::operators;
+  if (almostEqual(phi_, -1._pi, 10)) {
+    phi_ = 1._pi;
+    // Standardize phi values of |pi| to be always +pi instead of sometimes -pi.
+  }
+
   // Only look for sensor-related info on sensor volumes!
   if (type_ == DetUnit) {
     // IT sensors only (NB: hence could add a branch here, but not a critical part on perf)
@@ -316,11 +324,18 @@ std::vector<double> GeometricDet::computeLegacyShapeParameters(const cms::DDSoli
   // Tub
   else if (mySolidShape == cms::DDSolidShape::ddtubs) {
     const dd4hep::Tube& myTube = dd4hep::Tube(mySolid);
+    double phi1 = static_cast<double>(angle_units::operators::convertDegToRad(myTube->GetPhi1()));
+    phi1 = cms_rounding::roundIfNear0(phi1);
+    if (phi1 != 0.0) {
+      using namespace angle0to2pi;
+      phi1 = make0To2pi(phi1) - 2._pi;
+      // Turn positive angle to negative
+    }
     myOldDDShapeParameters = {
         (myTube->GetDz()) / dd4hep::mm,
         (myTube->GetRmin()) / dd4hep::mm,
         (myTube->GetRmax()) / dd4hep::mm,
-        static_cast<double>(fmod(angle_units::operators::convertDegToRad(myTube->GetPhi1()), 2. * M_PI) - 2. * M_PI),
+        phi1,
         static_cast<double>(angle_units::operators::convertDegToRad(myTube->GetPhi2() - myTube->GetPhi1()))};
   }