Changing over to the cell subelement approach for DAGMC universes

Author: pshriwise

include/openmc/dagmc.h

@@ -202,7 +202,7 @@ class DAGUniverse : public Universe {
   bool has_graveyard_; //!< Indicates if the DAGMC geometry has a "graveyard"
                        //!< volume
   std::unordered_map<int32_t, vector<int32_t>>
-    material_overrides_; //!< Map of material overrides
+    material_overrides_; //!< Map of DAGMC cell material overrides
                          //!< keys correspond to the DAGMCCell id
                          //!< values are a list of material ids used
                          //!< for the override

openmc/dagmc.py

@@ -37,10 +37,10 @@ class DAGMCUniverse(openmc.UniverseBase):
         Set IDs automatically on initialization (True)  or report overlaps in ID
         space between OpenMC and UWUW materials (False)
     material_overrides : dict, optional
-        A dictionary of material overrides. The keys are material name strings
-        and the values are Iterables of openmc.Material objects. If a material
-        name is found in the DAGMC file, the material will be replaced with the
-        openmc.Material object in the value.
+        A dictionary of material overrides. Keys are cell IDs (or
+        :class:`openmc.DAGMCCell` objects), and values are
+        :class:`openmc.Material` objects or iterables of
+        :class:`openmc.Material` objects.
 
     Attributes
     ----------
@@ -130,6 +130,8 @@ def filename(self, val: cv.PathLike):
 
     @property
     def material_overrides(self):
+        if self.cells:
+            return self._get_cell_material_overrides()
         return self._material_overrides
 
     @material_overrides.setter
@@ -201,7 +203,11 @@ def add_material_override(self, key, overrides=None):
         if key not in self.cells:
             raise ValueError(f"Cell ID '{key}' not found in DAGMC universe")
 
-        self._material_overrides[key] = overrides
+        self._material_overrides[key] = list(overrides)
+        if len(overrides) == 1:
+            self.cells[key].fill = overrides[0]
+        else:
+            self.cells[key].fill = list(overrides)
 
     @property
     def auto_geom_ids(self):
@@ -281,6 +287,21 @@ def n_cells(self):
     def n_surfaces(self):
         return self._n_geom_elements('surface')
 
+    def _get_cell_material_overrides(self):
+        overrides = {}
+        for cell in self.cells.values():
+            if cell.fill_type == 'material':
+                overrides[cell.id] = [cell.fill]
+            elif cell.fill_type == 'distribmat':
+                overrides[cell.id] = list(cell.fill)
+            elif cell.fill_type == 'void':
+                overrides[cell.id] = [None]
+            else:
+                raise ValueError(
+                    "Only material fills are supported for DAGMC cell "
+                    "overrides.")
+        return overrides
+
     def create_xml_subelement(self, xml_element, memo=None):
         if memo is None:
             memo = set()
@@ -290,12 +311,6 @@ def create_xml_subelement(self, xml_element, memo=None):
 
         memo.add(self)
 
-        # Ensure that the material overrides are up-to-date
-        for cell in self.cells.values():
-            if cell.fill is None:
-                continue
-            self.add_material_override(cell, cell.fill)
-
         # Set xml element values
         dagmc_element = ET.Element('dagmc_universe')
         dagmc_element.set('id', str(self.id))
@@ -307,17 +322,11 @@ def create_xml_subelement(self, xml_element, memo=None):
         if self.auto_mat_ids:
             dagmc_element.set('auto_mat_ids', 'true')
         dagmc_element.set('filename', str(self.filename))
-        if self._material_overrides:
-            mat_element = ET.Element('material_overrides')
-            for key in self._material_overrides:
-                cell_overrides = ET.Element('cell_override')
-                cell_overrides.set("id", str(key))
-                material_element = ET.Element('material_ids')
-                material_element.text = ' '.join(
-                    str(t.id) for t in self._material_overrides[key])
-                cell_overrides.append(material_element)
-                mat_element.append(cell_overrides)
-            dagmc_element.append(mat_element)
+        if self.cells:
+            self._material_overrides = self._get_cell_material_overrides()
+            for cell in self.cells.values():
+                cell_element = cell.create_xml_subelement(xml_element, memo)
+                dagmc_element.append(cell_element)
         xml_element.append(dagmc_element)
 
     def bounding_region(
@@ -442,7 +451,7 @@ def from_hdf5(cls, group):
         return out
 
     @classmethod
-    def from_xml_element(cls, elem, mats = None):
+    def from_xml_element(cls, elem, mats=None):
         """Generate DAGMC universe from XML element
 
         Parameters
@@ -471,21 +480,59 @@ def from_xml_element(cls, elem, mats = None):
         out.auto_geom_ids = bool(get_text(elem, "auto_geom_ids"))
         out.auto_mat_ids = bool(get_text(elem, "auto_mat_ids"))
 
-        el_mat_override = elem.find('material_overrides')
-        if el_mat_override is not None:
-            if mats is None:
-                raise ValueError("Material overrides found in DAGMC universe "
-                                 "but no materials were provided to populate "
-                                 "the mapping.")
-            out._material_overrides = {}
-            for elem in el_mat_override.findall('cell_override'):
-                cell_id = int(get_text(elem, 'id'))
-                mat_ids = get_elem_list(elem, "material_ids", str) or []
-                mat_objs = [mats[mat_id] for mat_id in mat_ids]
-                out._material_overrides[cell_id] = mat_objs
+        if elem.find('material_overrides') is not None:
+            raise ValueError(
+                "DAGMCUniverse <material_overrides> is no longer supported. "
+                "Use nested <cell> elements under <dagmc_universe> instead.")
+
+        if elem.find('cell') is not None:
+            out._parse_cell_overrides(elem, mats)
 
         return out
 
+    def _parse_cell_overrides(self, elem, mats):
+        if mats is None:
+            raise ValueError("DAGMC cell overrides found in DAGMC universe but "
+                             "no materials were provided to populate the "
+                             "mapping.")
+
+        self._material_overrides = {}
+        for cell_elem in elem.findall('cell'):
+            cell_id = int(get_text(cell_elem, 'id'))
+            name = get_text(cell_elem, 'name')
+
+            if get_text(cell_elem, 'region') is not None:
+                raise ValueError("DAGMC cell overrides cannot include a region.")
+            if get_text(cell_elem, 'fill') is not None:
+                raise ValueError("DAGMC cell overrides currently only support "
+                                 "material fills.")
+            if get_text(cell_elem, 'universe') is not None:
+                raise ValueError("DAGMC cell overrides cannot specify a "
+                                 "universe.")
+            for tag in ('temperature', 'density', 'translation', 'rotation', 'volume'):
+                if get_text(cell_elem, tag) is not None:
+                    raise ValueError(
+                        "DAGMC cell overrides currently only support material "
+                        f"fills (found unsupported '{tag}' for cell {cell_id}).")
+
+            mat_ids = get_elem_list(cell_elem, 'material', str)
+            if mat_ids is None:
+                raise ValueError(
+                    f"DAGMC cell {cell_id} must specify a material override.")
+
+            mat_objs = [mats[mat_id] for mat_id in mat_ids]
+            if len(mat_objs) == 1:
+                fill = mat_objs[0]
+            else:
+                fill = mat_objs
+
+            if cell_id in self.cells:
+                raise ValueError(
+                    f"Duplicate DAGMC cell override specified for cell {cell_id}.")
+            self.add_cell(openmc.DAGMCCell(
+                cell_id=cell_id, name=name or '', fill=fill))
+            self._material_overrides[cell_id] = mat_objs
+
     def _partial_deepcopy(self):
         """Clone all of the openmc.DAGMCUniverse object's attributes except for
         its cells, as they are copied within the clone function. This should
@@ -625,7 +672,15 @@ def plot(self, *args, **kwargs):
         raise TypeError("plot is not available for DAGMC cells.")
 
     def create_xml_subelement(self, xml_element, memo=None):
-        raise TypeError("create_xml_subelement is not available for DAGMC cells.")
+        if self.fill_type not in ('void', 'material', 'distribmat'):
+            raise TypeError("DAGMC cell overrides currently only support "
+                            "material fills.")
+        if any(getattr(self, attr) is not None for attr in (
+            'temperature', 'density', 'translation', 'rotation', 'volume'
+        )):
+            raise TypeError("DAGMC cell overrides currently only support "
+                            "material fills.")
+        return super().create_xml_subelement(xml_element, memo)
 
     @classmethod
     def from_xml_element(cls, elem, surfaces, materials, get_universe):

openmc/model/model.py

@@ -427,6 +427,8 @@ def sync_dagmc_universes(self):
         This method iterates over all DAGMC universes in the geometry and
         synchronizes their cells with the current material assignments. Requires
         that the model has been initialized via :meth:`Model.init_lib`.
+        Synchronized DAGMC cells can then be edited and exported as nested
+        `<cell>` overrides inside each `<dagmc_universe>` element.
 
         .. versionadded:: 0.15.1
 

src/dagmc.cpp

@@ -76,21 +76,71 @@ DAGUniverse::DAGUniverse(pugi::xml_node node)
     adjust_material_ids_ = get_node_value_bool(node, "auto_mat_ids");
   }
 
-  // get material assignment overloading
-  if (check_for_node(node, "material_overrides")) {
-    auto mat_node = node.child("material_overrides");
-    // loop over all subelements (each subelement corresponds to a material)
-    for (pugi::xml_node cell_node : mat_node.children("cell_override")) {
-      // Store assignment reference name
-      int32_t ref_assignment = std::stoi(get_node_value(cell_node, "id"));
-
-      // Get mat name for each assignement instances
-      vector<int32_t> instance_mats =
-        get_node_array<int32_t>(cell_node, "material_ids");
-
-      // Store mat name for each instances
-      material_overrides_.emplace(ref_assignment, instance_mats);
+  // Get material assignment overrides from nested DAGMC cell elements.
+  if (node.child("cell")) {
+    for (pugi::xml_node cell_node : node.children("cell")) {
+      if (!check_for_node(cell_node, "id")) {
+        fatal_error(
+          "Must specify id for each DAGMC cell override in <dagmc_universe>.");
+      }
+
+      int32_t cell_id = std::stoi(get_node_value(cell_node, "id"));
+
+      if (check_for_node(cell_node, "region")) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override cannot specify a region.", cell_id));
+      }
+      if (check_for_node(cell_node, "fill")) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override currently only supports material fills.",
+          cell_id));
+      }
+      if (check_for_node(cell_node, "universe")) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override cannot specify a universe.", cell_id));
+      }
+      if (check_for_node(cell_node, "temperature") ||
+          check_for_node(cell_node, "density") ||
+          check_for_node(cell_node, "translation") ||
+          check_for_node(cell_node, "rotation") ||
+          check_for_node(cell_node, "volume")) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override currently only supports material fills.",
+          cell_id));
+      }
+      if (!check_for_node(cell_node, "material")) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override must specify material.", cell_id));
+      }
+
+      vector<std::string> mats =
+        get_node_array<std::string>(cell_node, "material", true);
+      if (mats.empty()) {
+        fatal_error(fmt::format(
+          "DAGMC cell {} override has an empty material specification.",
+          cell_id));
+      }
+
+      vector<int32_t> override_mats;
+      override_mats.reserve(mats.size());
+      for (const auto& mat : mats) {
+        if (mat == "void") {
+          override_mats.push_back(MATERIAL_VOID);
+        } else {
+          override_mats.push_back(std::stoi(mat));
+        }
+      }
+
+      auto inserted = material_overrides_.emplace(cell_id, override_mats);
+      if (!inserted.second) {
+        fatal_error(fmt::format(
+          "Duplicate DAGMC cell override specified for cell {}", cell_id));
+      }
     }
+  } else if (check_for_node(node, "material_overrides")) {
+    fatal_error(
+      "DAGMCUniverse <material_overrides> is no longer supported. Use nested "
+      "<cell> elements under <dagmc_universe> instead.");
   }
 
   initialize();
@@ -230,17 +280,15 @@ void DAGUniverse::init_geometry()
     if (mat_str == "graveyard") {
       graveyard = vol_handle;
     }
-    // material void checks
-    if (mat_str == "void" || mat_str == "vacuum" || mat_str == "graveyard") {
+    if (material_overrides_.count(c->id_)) {
+      override_assign_material(c);
+    } else if (mat_str == "void" || mat_str == "vacuum" ||
+               mat_str == "graveyard") {
       c->material_.push_back(MATERIAL_VOID);
+    } else if (uses_uwuw()) {
+      uwuw_assign_material(vol_handle, c);
     } else {
-      if (material_overrides_.count(c->id_)) {
-        override_assign_material(c);
-      } else if (uses_uwuw()) {
-        uwuw_assign_material(vol_handle, c);
-      } else {
-        legacy_assign_material(mat_str, c);
-      }
+      legacy_assign_material(mat_str, c);
     }
 
     // check for temperature assignment
@@ -638,17 +686,30 @@ void DAGUniverse::override_assign_material(std::unique_ptr<DAGCell>& c) const
   // Notify User that an override is being applied on a DAGMCCell
   write_message(fmt::format("Applying override for DAGMCCell {}", c->id_), 8);
 
+  const auto& mat_overrides = material_overrides_.at(c->id_);
   if (settings::verbosity >= 10) {
-    auto msg = fmt::format("Assigning DAGMC cell {} material(s) based on "
-                           "override information (see input XML).",
-      c->id_);
+    std::stringstream override_values;
+    for (size_t i = 0; i < mat_overrides.size(); ++i) {
+      if (i > 0) {
+        override_values << " ";
+      }
+      if (mat_overrides[i] == MATERIAL_VOID) {
+        override_values << "void";
+      } else {
+        override_values << mat_overrides[i];
+      }
+    }
+    auto msg = fmt::format("Overriding DAGMC cell {} property 'material' "
+                           "with value(s): {}",
+      c->id_, override_values.str());
     write_message(msg, 10);
   }
 
   // Override the material assignment for each cell instance using the legacy
   // assignement
-  for (auto mat_id : material_overrides_.at(c->id_)) {
-    if (model::material_map.find(mat_id) == model::material_map.end()) {
+  for (auto mat_id : mat_overrides) {
+    if (mat_id != MATERIAL_VOID &&
+        model::material_map.find(mat_id) == model::material_map.end()) {
       fatal_error(fmt::format(
         "Material with ID '{}' not found for DAGMC cell {}", mat_id, c->id_));
     }