@@ -406,6 +406,11 @@ Each ``<dagmc_universe>`` element can have the following attributes or sub-eleme
 
     *Default*: None
 
+  :length_multiplier:
+    Coordinate scaling factor applied when loading a DAGMC geometry model.
+
+    *Default*: 1.0
+
   :cell:
     Zero or more ``<cell>`` sub-elements may appear to override properties of
     individual DAGMC volumes. Each ``<cell>`` element supports the following
 
@@ -104,14 +104,15 @@ class DAGUniverse : public Universe {
   //! \param[in] filename Name of the DAGMC file
   //! \param[in] auto_geom_ids Whether or not to automatically assign cell and
   //! surface IDs \param[in] auto_mat_ids Whether or not to automatically assign
-  //! material IDs
+  //! material IDs \param[in] length_multiplier Multiplicative factor applied to
+  //! geometry coordinates
   explicit DAGUniverse(const std::string& filename, bool auto_geom_ids = false,
-    bool auto_mat_ids = false);
+    bool auto_mat_ids = false, double length_multiplier = 1.0);
 
   //! Alternative DAGMC universe constructor for external DAGMC instance
   explicit DAGUniverse(std::shared_ptr<moab::DagMC> external_dagmc_ptr,
     const std::string& filename = "", bool auto_geom_ids = false,
-    bool auto_mat_ids = false);
+    bool auto_mat_ids = false, double length_multiplier = 1.0);
 
   //! Initialize the DAGMC accel. data structures, indices, material
   //! assignments, etc.
@@ -209,6 +210,8 @@ class DAGUniverse : public Universe {
                              //!< universe
   bool adjust_material_ids_; //!< Indicates whether or not to automatically
                              //!< generate new material IDs for the universe
+  double length_multiplier_ {
+    1.0}; //!< Multiplicative factor applied to geometry coordinates
   bool has_graveyard_; //!< Indicates if the DAGMC geometry has a "graveyard"
                        //!< volume
 };
 
@@ -1,5 +1,5 @@
 from collections.abc import Iterable, Mapping
-from numbers import Integral
+from numbers import Integral, Real
 
 import h5py
 import lxml.etree as ET
@@ -36,6 +36,8 @@ class DAGMCUniverse(openmc.UniverseBase):
     auto_mat_ids : bool
         Set IDs automatically on initialization (True)  or report overlaps in ID
         space between OpenMC and UWUW materials (False)
+    length_multiplier : float
+        Coordinate scaling factor applied when loading a DAGMC geometry model.
     Attributes
     ----------
     id : int
@@ -50,6 +52,8 @@ class DAGMCUniverse(openmc.UniverseBase):
     auto_mat_ids : bool
         Set IDs automatically on initialization (True)  or report overlaps in ID
         space between OpenMC and UWUW materials (False)
+    length_multiplier : float
+        Coordinate scaling factor applied when loading a DAGMC geometry model.
     bounding_box : openmc.BoundingBox
         Lower-left and upper-right coordinates of an axis-aligned bounding box
         of the universe.
@@ -79,23 +83,30 @@ def __init__(self,
                  universe_id=None,
                  name='',
                  auto_geom_ids=False,
-                 auto_mat_ids=False):
+                 auto_mat_ids=False,
+                 length_multiplier: float = 1.0):
         super().__init__(universe_id, name)
         # Initialize class attributes
         self.filename = filename
         self.auto_geom_ids = auto_geom_ids
         self.auto_mat_ids = auto_mat_ids
+        self.length_multiplier = length_multiplier
 
     def __repr__(self):
         string = super().__repr__()
         string += '{: <16}=\t{}\n'.format('\tGeom', 'DAGMC')
         string += '{: <16}=\t{}\n'.format('\tFile', self.filename)
+        if self.length_multiplier != 1.0:
+            string += '{: <16}=\t{}\n'.format(
+                '\tLength multiplier', self.length_multiplier
+            )
         return string
 
     @property
     def bounding_box(self):
         with h5py.File(self.filename) as dagmc_file:
             coords = dagmc_file['tstt']['nodes']['coordinates'][()]
+            coords *= self.length_multiplier
             lower_left_corner = coords.min(axis=0)
             upper_right_corner = coords.max(axis=0)
             return openmc.BoundingBox(lower_left_corner, upper_right_corner)
@@ -175,6 +186,16 @@ def auto_mat_ids(self, val):
         cv.check_type('DAGMC automatic material ids', val, bool)
         self._auto_mat_ids = val
 
+    @property
+    def length_multiplier(self):
+        return self._length_multiplier
+
+    @length_multiplier.setter
+    def length_multiplier(self, length_multiplier):
+        cv.check_type('DAGMC universe length multiplier', length_multiplier, Real)
+        cv.check_greater_than('DAGMC universe length multiplier', length_multiplier, 0.0)
+        self._length_multiplier = length_multiplier
+
     @property
     def material_names(self):
         material_tags_ascii = []
@@ -254,6 +275,8 @@ def create_xml_subelement(self, xml_element, memo=None):
             dagmc_element.set('auto_geom_ids', 'true')
         if self.auto_mat_ids:
             dagmc_element.set('auto_mat_ids', 'true')
+        if self.length_multiplier != 1.0:
+            dagmc_element.set('length_multiplier', str(self.length_multiplier))
         dagmc_element.set('filename', str(self.filename))
         if self.cells:
             for cell in self.cells.values():
@@ -374,8 +397,9 @@ def from_hdf5(cls, group):
         id = int(group.name.split('/')[-1].lstrip('universe '))
         fname = group['filename'][()].decode()
         name = group['name'][()].decode() if 'name' in group else None
+        length_multiplier = float(group.attrs.get('length_multiplier', 1.0))
 
-        out = cls(fname, universe_id=id, name=name)
+        out = cls(fname, universe_id=id, name=name, length_multiplier=length_multiplier)
 
         out.auto_geom_ids = bool(group.attrs['auto_geom_ids'])
         out.auto_mat_ids = bool(group.attrs['auto_mat_ids'])
@@ -402,8 +426,9 @@ def from_xml_element(cls, elem, mats=None):
         """
         id = int(get_text(elem, 'id'))
         fname = get_text(elem, 'filename')
+        length_multiplier = float(get_text(elem, 'length_multiplier', 1.0))
 
-        out = cls(fname, universe_id=id)
+        out = cls(fname, universe_id=id, length_multiplier=length_multiplier)
 
         name = get_text(elem, 'name')
         if name is not None:
@@ -467,7 +492,7 @@ def _partial_deepcopy(self):
         its cells, as they are copied within the clone function. This should
         only to be used within the openmc.UniverseBase.clone() context.
         """
-        clone = openmc.DAGMCUniverse(name=self.name, filename=self.filename)
+        clone = openmc.DAGMCUniverse(name=self.name, filename=self.filename, length_multiplier=self.length_multiplier)
         clone.volume = self.volume
         clone.auto_geom_ids = self.auto_geom_ids
         clone.auto_mat_ids = self.auto_mat_ids
 
@@ -1,5 +1,6 @@
 #include "openmc/dagmc.h"
 
+#include <array>
 #include <cassert>
 
 #include "openmc/constants.h"
@@ -80,6 +81,10 @@ DAGUniverse::DAGUniverse(pugi::xml_node node)
     adjust_material_ids_ = get_node_value_bool(node, "auto_mat_ids");
   }
 
+  if (check_for_node(node, "length_multiplier")) {
+    length_multiplier_ = std::stod(get_node_value(node, "length_multiplier"));
+  }
+
   // Get material assignment overrides from nested DAGMC cell elements.
   if (node.child("cell")) {
     for (pugi::xml_node cell_node : node.children("cell")) {
@@ -153,19 +158,21 @@ DAGUniverse::DAGUniverse(pugi::xml_node node)
   initialize(material_overrides, temperature_overrides, density_overrides);
 }
 
-DAGUniverse::DAGUniverse(
-  const std::string& filename, bool auto_geom_ids, bool auto_mat_ids)
+DAGUniverse::DAGUniverse(const std::string& filename, bool auto_geom_ids,
+  bool auto_mat_ids, double length_multiplier)
   : filename_(filename), adjust_geometry_ids_(auto_geom_ids),
-    adjust_material_ids_(auto_mat_ids)
+    adjust_material_ids_(auto_mat_ids), length_multiplier_(length_multiplier)
 {
   set_id();
   initialize();
 }
 
 DAGUniverse::DAGUniverse(std::shared_ptr<moab::DagMC> dagmc_ptr,
-  const std::string& filename, bool auto_geom_ids, bool auto_mat_ids)
+  const std::string& filename, bool auto_geom_ids, bool auto_mat_ids,
+  double length_multiplier)
   : dagmc_instance_(dagmc_ptr), filename_(filename),
-    adjust_geometry_ids_(auto_geom_ids), adjust_material_ids_(auto_mat_ids)
+    adjust_geometry_ids_(auto_geom_ids), adjust_material_ids_(auto_mat_ids),
+    length_multiplier_(length_multiplier)
 {
   MaterialOverrides material_overrides;
   TemperatureOverrides temperature_overrides;
@@ -225,6 +232,28 @@ void DAGUniverse::init_dagmc()
   moab::ErrorCode rval = dagmc_instance_->load_file(filename_.c_str());
   MB_CHK_ERR_CONT(rval);
 
+  if (length_multiplier_ != 1.0) {
+    moab::Range verts;
+    rval =
+      dagmc_instance_->moab_instance()->get_entities_by_dimension(0, 0, verts);
+    MB_CHK_ERR_CONT(rval);
+
+    for (auto vert : verts) {
+      std::array<double, 3> coord;
+      rval =
+        dagmc_instance_->moab_instance()->get_coords(&vert, 1, coord.data());
+      MB_CHK_ERR_CONT(rval);
+
+      for (auto& c : coord) {
+        c *= length_multiplier_;
+      }
+
+      rval =
+        dagmc_instance_->moab_instance()->set_coords(&vert, 1, coord.data());
+      MB_CHK_ERR_CONT(rval);
+    }
+  }
+
   // initialize acceleration data structures
   rval = dagmc_instance_->init_OBBTree();
   MB_CHK_ERR_CONT(rval);
@@ -579,6 +608,7 @@ void DAGUniverse::to_hdf5(hid_t universes_group) const
     group, "auto_geom_ids", static_cast<int>(adjust_geometry_ids_));
   write_attribute(
     group, "auto_mat_ids", static_cast<int>(adjust_material_ids_));
+  write_attribute(group, "length_multiplier", length_multiplier_);
 
   close_group(group);
 }
 
@@ -5,6 +5,7 @@
 import pytest
 import openmc
 import openmc.lib
+import h5py
 from openmc.utility_funcs import change_directory
 
 pytestmark = pytest.mark.skipif(
@@ -258,6 +259,86 @@ def test_dagmc_xml_reject_region_override():
         openmc.DAGMCUniverse.from_xml_element(elem, mats)
 
 
+def test_dagmc_length_multiplier_xml_roundtrip():
+    dagmc_u = openmc.DAGMCUniverse(filename="dagmc.h5m", universe_id=100, length_multiplier=0.1)
+    root = ET.Element('geometry')
+    dagmc_u.create_xml_subelement(root)
+    dagmc_elem = root.find('dagmc_universe')
+    assert dagmc_elem.get('length_multiplier') == '0.1'
+    dagmc_u_roundtrip = openmc.DAGMCUniverse.from_xml_element(dagmc_elem)
+    assert dagmc_u_roundtrip.length_multiplier == 0.1
+    default_elem = ET.fromstring('<dagmc_universe id="100" filename="dagmc.h5m"/>')
+    default_univ = openmc.DAGMCUniverse.from_xml_element(default_elem)
+    assert default_univ.length_multiplier == 1.0
+
+
+def test_dagmc_length_multiplier_from_hdf5(run_in_tmpdir):
+    # length_multiplier explicitly defined
+    with h5py.File("test_dagmc.h5", "w") as f:
+        g = f.create_group("geometry/universe 100")
+        g.create_dataset("filename", data=np.bytes_("dagmc.h5m"))
+        g.attrs["auto_geom_ids"] = np.int32(0)
+        g.attrs["auto_mat_ids"] = np.int32(0)
+        g.attrs["length_multiplier"] = 0.1
+
+    with h5py.File("test_dagmc.h5", "r") as f:
+        u = openmc.DAGMCUniverse.from_hdf5(f["geometry/universe 100"])
+
+    assert u.id == 100
+    assert u.filename == Path("dagmc.h5m")
+    assert u.length_multiplier == pytest.approx(0.1)
+
+    # length_multiplier not defined - should default to 1.0
+    with h5py.File("test_dagmc_default.h5", "w") as f:
+        g = f.create_group("geometry/universe 101")
+        g.create_dataset("filename", data=np.bytes_("dagmc.h5m"))
+        g.attrs["auto_geom_ids"] = np.int32(0)
+        g.attrs["auto_mat_ids"] = np.int32(0)
+
+    with h5py.File("test_dagmc_default.h5", "r") as f:
+        u_default = openmc.DAGMCUniverse.from_hdf5(f["geometry/universe 101"])
+
+    assert u_default.id == 101
+    assert u_default.filename == Path("dagmc.h5m")
+    assert u_default.length_multiplier == 1.0
+
+
+def test_dagmc_length_multiplier_hdf5_roundtrip(request):
+    p = Path(request.fspath).parent / "dagmc_sphere_r5.h5m"
+
+    daguniv = openmc.DAGMCUniverse(p, auto_geom_ids=True, length_multiplier=0.5)
+    root = daguniv.bounded_universe()
+
+    mat = openmc.Material(name="test_mat")
+    mat.add_nuclide("H1", 1.0)
+    mat.set_density("g/cm3", 1.0)
+
+    settings = openmc.Settings()
+    settings.batches = 100
+    settings.inactive = 10
+    settings.particles = 1000
+    ll, ur = daguniv.bounding_box
+
+    model = openmc.Model()
+    model.geometry = openmc.Geometry(root)
+    model.materials = openmc.Materials([mat])
+    model.settings = settings
+
+    with change_directory(tmpdir=True):
+        try:
+            model.init_lib()
+            model.sync_dagmc_universes()
+            summary = openmc.Summary("summary.h5")
+        finally:
+            model.finalize_lib()
+            openmc.reset_auto_ids()
+
+    all_univs = summary.geometry.get_all_universes()
+    u = all_univs[daguniv.id]
+    assert isinstance(u, openmc.DAGMCUniverse)
+    assert u.length_multiplier == pytest.approx(0.5)
+
+
 def _legacy_xml(cell_overrides):
     """Helper to build a <dagmc_universe> with old-format <material_overrides>."""
     inner = ''.join(
@@ -363,3 +444,51 @@ def test_dagmc_xml_temperature_roundtrip():
     dag_univ_roundtrip = openmc.DAGMCUniverse.from_xml_element(dagmc_elem, mats)
     assert dag_univ_roundtrip.cells[7].fill.id == 1
     assert dag_univ_roundtrip.cells[7].temperature == pytest.approx(825.0)
+
+
+def test_dagmc_length_multiplier_volume_scaling(request):
+    """Stochastic volume of a DAGMC sphere should scale as length_multiplier^3.
+    A DAGMC sphere with radius 5 cm (and no graveyard) is checked against the 
+    analytical volume (4/3 * pi * r^3) for length_multiplier values of 1.0 and 10.0.
+    """
+    p = Path(request.fspath).parent / "dagmc_sphere_r5.h5m"
+    n_samples = 1000000
+
+    def _compute_sphere_volume(length_multiplier):
+        openmc.reset_auto_ids()
+        daguniv = openmc.DAGMCUniverse(p, auto_geom_ids=True,
+                                       length_multiplier=length_multiplier)
+        root = daguniv.bounded_universe()
+
+        mat = openmc.Material(name="test_mat")
+        mat.add_nuclide("H1", 1.0)
+        mat.set_density("g/cm3", 1.0)
+
+        settings = openmc.Settings()
+        settings.batches = 100
+        settings.inactive = 10
+        settings.particles = 1000
+        ll, ur = daguniv.bounding_box
+        vol_calc = openmc.VolumeCalculation([mat], n_samples, ll, ur)
+        settings.volume_calculations = [vol_calc]
+        model = openmc.Model()
+        model.geometry = openmc.Geometry(root)
+        model.materials = openmc.Materials([mat])
+        model.settings = settings
+        with change_directory(tmpdir=True):
+            try:
+                model.init_lib()
+                model.sync_dagmc_universes()
+                model.calculate_volumes()
+            finally:
+                model.finalize_lib()
+                openmc.reset_auto_ids()
+        return mat.volume
+
+    v1 = _compute_sphere_volume(length_multiplier=1.0)
+    v10 = _compute_sphere_volume(length_multiplier=10.0)
+    expected_v1 = 4.0 / 3.0 * np.pi * 5.0**3
+    expected_v10 = expected_v1 * 10.0**3
+    assert v1 == pytest.approx(expected_v1, rel=0.02)
+    assert v10 == pytest.approx(expected_v10, rel=0.02)
+    assert v10 / v1 == pytest.approx(10.0**3, rel=0.02)