Replace material overrides with standard cell specification subelements

Author: pshriwise

include/openmc/dagmc.h

@@ -94,6 +94,9 @@ class DAGCell : public Cell {
 class DAGUniverse : public Universe {
 
 public:
+  using MaterialOverrides = std::unordered_map<int32_t, vector<int32_t>>;
+  using TemperatureOverrides = std::unordered_map<int32_t, vector<double>>;
+
   explicit DAGUniverse(pugi::xml_node node);
 
   //! Create a new DAGMC universe
@@ -112,6 +115,8 @@ class DAGUniverse : public Universe {
   //! Initialize the DAGMC accel. data structures, indices, material
   //! assignments, etc.
   void initialize();
+  void initialize(const MaterialOverrides& material_overrides,
+    const TemperatureOverrides& temperature_overrides);
 
   //! Reads UWUW materials and returns an ID map
   void read_uwuw_materials();
@@ -146,7 +151,8 @@ class DAGUniverse : public Universe {
 
   //! Assign a material overriding normal assignement to a cell
   //! \param[in] c The OpenMC cell to which the material is assigned
-  void override_assign_material(std::unique_ptr<DAGCell>& c) const;
+  void override_assign_material(std::unique_ptr<DAGCell>& c,
+    const MaterialOverrides& material_overrides) const;
 
   //! Return the index into the model cells vector for a given DAGMC volume
   //! handle in the universe
@@ -187,7 +193,8 @@ class DAGUniverse : public Universe {
   void set_id();        //!< Deduce the universe id from model::universes
   void init_dagmc();    //!< Create and initialise DAGMC pointer
   void init_metadata(); //!< Create and initialise dagmcMetaData pointer
-  void init_geometry(); //!< Create cells and surfaces from DAGMC entities
+  void init_geometry(const MaterialOverrides& material_overrides,
+    const TemperatureOverrides& temperature_overrides);
 
   std::string
     filename_; //!< Name of the DAGMC file used to create this universe
@@ -201,11 +208,6 @@ class DAGUniverse : public Universe {
                              //!< generate new material IDs for the 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 DAGMC cell material overrides
-                         //!< keys correspond to the DAGMCCell id
-                         //!< values are a list of material ids used
-                         //!< for the override
 };
 
 //==============================================================================

openmc/dagmc.py

@@ -509,7 +509,7 @@ def _parse_cell_overrides(self, elem, mats):
             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'):
+            for tag in ('density', 'translation', 'rotation', 'volume'):
                 if get_text(cell_elem, tag) is not None:
                     raise ValueError(
                         "DAGMC cell overrides currently only support material "
@@ -526,11 +526,22 @@ def _parse_cell_overrides(self, elem, mats):
             else:
                 fill = mat_objs
 
+            temperature = get_elem_list(cell_elem, 'temperature', float)
+            if temperature is not None:
+                if len(temperature) > 1:
+                    cell_temp = temperature
+                else:
+                    cell_temp = temperature[0]
+            else:
+                cell_temp = None
+
             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))
+            cell = openmc.DAGMCCell(cell_id=cell_id, name=name or '', fill=fill)
+            if cell_temp is not None:
+                cell.temperature = cell_temp
+            self.add_cell(cell)
             self._material_overrides[cell_id] = mat_objs
 
     def _partial_deepcopy(self):
@@ -675,8 +686,13 @@ def create_xml_subelement(self, xml_element, memo=None):
         if self.fill_type not in ('void', 'material', 'distribmat'):
             raise TypeError("DAGMC cell overrides currently only support "
                             "material fills.")
+        if self.temperature is not None and self.fill_type not in (
+            'material', 'distribmat'
+        ):
+            raise TypeError("DAGMC cell temperature overrides require a "
+                            "material fill.")
         if any(getattr(self, attr) is not None for attr in (
-            'temperature', 'density', 'translation', 'rotation', 'volume'
+            'density', 'translation', 'rotation', 'volume'
         )):
             raise TypeError("DAGMC cell overrides currently only support "
                             "material fills.")

src/dagmc.cpp

@@ -50,6 +50,9 @@ namespace openmc {
 
 DAGUniverse::DAGUniverse(pugi::xml_node node)
 {
+  MaterialOverrides material_overrides;
+  TemperatureOverrides temperature_overrides;
+
   if (check_for_node(node, "id")) {
     id_ = std::stoi(get_node_value(node, "id"));
   } else {
@@ -99,8 +102,7 @@ DAGUniverse::DAGUniverse(pugi::xml_node node)
         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") ||
+      if (check_for_node(cell_node, "density") ||
           check_for_node(cell_node, "translation") ||
           check_for_node(cell_node, "rotation") ||
           check_for_node(cell_node, "volume")) {
@@ -131,19 +133,36 @@ DAGUniverse::DAGUniverse(pugi::xml_node node)
         }
       }
 
-      auto inserted = material_overrides_.emplace(cell_id, override_mats);
+      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));
       }
+
+      if (check_for_node(cell_node, "temperature")) {
+        auto temperatures = get_node_array<double>(cell_node, "temperature");
+        if (temperatures.empty()) {
+          fatal_error(fmt::format(
+            "DAGMC cell {} override has an empty temperature specification.",
+            cell_id));
+        }
+        for (auto T : temperatures) {
+          if (T < 0.0) {
+            fatal_error(fmt::format(
+              "DAGMC cell {} was specified with a negative temperature",
+              cell_id));
+          }
+        }
+        temperature_overrides.emplace(cell_id, temperatures);
+      }
     }
   } 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();
+  initialize(material_overrides, temperature_overrides);
 }
 
 DAGUniverse::DAGUniverse(
@@ -160,9 +179,11 @@ DAGUniverse::DAGUniverse(std::shared_ptr<moab::DagMC> dagmc_ptr,
   : dagmc_instance_(dagmc_ptr), filename_(filename),
     adjust_geometry_ids_(auto_geom_ids), adjust_material_ids_(auto_mat_ids)
 {
+  MaterialOverrides material_overrides;
+  TemperatureOverrides temperature_overrides;
   set_id();
   init_metadata();
-  init_geometry();
+  init_geometry(material_overrides, temperature_overrides);
 }
 
 void DAGUniverse::set_id()
@@ -180,6 +201,14 @@ void DAGUniverse::set_id()
 }
 
 void DAGUniverse::initialize()
+{
+  MaterialOverrides material_overrides;
+  TemperatureOverrides temperature_overrides;
+  initialize(material_overrides, temperature_overrides);
+}
+
+void DAGUniverse::initialize(const MaterialOverrides& material_overrides,
+  const TemperatureOverrides& temperature_overrides)
 {
 #ifdef OPENMC_UWUW_ENABLED
   // read uwuw materials from the .h5m file if present
@@ -190,7 +219,7 @@ void DAGUniverse::initialize()
 
   init_metadata();
 
-  init_geometry();
+  init_geometry(material_overrides, temperature_overrides);
 }
 
 void DAGUniverse::init_dagmc()
@@ -226,7 +255,8 @@ void DAGUniverse::init_metadata()
   MB_CHK_ERR_CONT(rval);
 }
 
-void DAGUniverse::init_geometry()
+void DAGUniverse::init_geometry(const MaterialOverrides& material_overrides,
+  const TemperatureOverrides& temperature_overrides)
 {
   moab::ErrorCode rval;
 
@@ -280,8 +310,8 @@ void DAGUniverse::init_geometry()
     if (mat_str == "graveyard") {
       graveyard = vol_handle;
     }
-    if (material_overrides_.count(c->id_)) {
-      override_assign_material(c);
+    if (material_overrides.count(c->id_)) {
+      override_assign_material(c, material_overrides);
     } else if (mat_str == "void" || mat_str == "vacuum" ||
                mat_str == "graveyard") {
       c->material_.push_back(MATERIAL_VOID);
@@ -291,6 +321,35 @@ void DAGUniverse::init_geometry()
       legacy_assign_material(mat_str, c);
     }
 
+    if (temperature_overrides.count(c->id_)) {
+      if (c->material_.empty() || c->material_[0] == MATERIAL_VOID) {
+        fatal_error(fmt::format("DAGMC cell {} was specified with a "
+                                "temperature but no non-void material.",
+          c->id_));
+      }
+
+      c->sqrtkT_.clear();
+      const auto& temp_overrides = temperature_overrides.at(c->id_);
+      c->sqrtkT_.reserve(temp_overrides.size());
+      for (auto T : temp_overrides) {
+        c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * T));
+      }
+
+      if (settings::verbosity >= 10) {
+        std::stringstream override_values;
+        for (size_t i = 0; i < temp_overrides.size(); ++i) {
+          if (i > 0) {
+            override_values << " ";
+          }
+          override_values << temp_overrides[i];
+        }
+        auto msg = fmt::format("Overriding DAGMC cell {} property "
+                               "'temperature [K]' with value(s): {}",
+          c->id_, override_values.str());
+        write_message(msg, 10);
+      }
+    }
+
     // check for temperature assignment
     std::string temp_value;
 
@@ -300,18 +359,21 @@ void DAGUniverse::init_geometry()
       continue;
     }
 
-    // assign cell temperature
-    const auto& mat = model::materials[model::material_map.at(c->material_[0])];
-    if (dagmc_instance_->has_prop(vol_handle, "temp")) {
-      rval = dagmc_instance_->prop_value(vol_handle, "temp", temp_value);
-      MB_CHK_ERR_CONT(rval);
-      double temp = std::stod(temp_value);
-      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * temp));
-    } else if (mat->temperature() > 0.0) {
-      c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * mat->temperature()));
-    } else {
-      c->sqrtkT_.push_back(
-        std::sqrt(K_BOLTZMANN * settings::temperature_default));
+    // assign cell temperature if not explicitly overridden
+    if (c->sqrtkT_.empty()) {
+      const auto& mat =
+        model::materials[model::material_map.at(c->material_[0])];
+      if (dagmc_instance_->has_prop(vol_handle, "temp")) {
+        rval = dagmc_instance_->prop_value(vol_handle, "temp", temp_value);
+        MB_CHK_ERR_CONT(rval);
+        double temp = std::stod(temp_value);
+        c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * temp));
+      } else if (mat->temperature() > 0.0) {
+        c->sqrtkT_.push_back(std::sqrt(K_BOLTZMANN * mat->temperature()));
+      } else {
+        c->sqrtkT_.push_back(
+          std::sqrt(K_BOLTZMANN * settings::temperature_default));
+      }
     }
 
     model::cells.emplace_back(std::move(c));
@@ -678,15 +740,16 @@ void DAGUniverse::uwuw_assign_material(
 #endif // OPENMC_UWUW_ENABLED
 }
 
-void DAGUniverse::override_assign_material(std::unique_ptr<DAGCell>& c) const
+void DAGUniverse::override_assign_material(std::unique_ptr<DAGCell>& c,
+  const MaterialOverrides& material_overrides) const
 {
   // if Cell ID matches an override key, use it to override the material
   // assignment else if UWUW is used, get the material assignment from the DAGMC
   // metadata
   // 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_);
+  const auto& mat_overrides = material_overrides.at(c->id_);
   if (settings::verbosity >= 10) {
     std::stringstream override_values;
     for (size_t i = 0; i < mat_overrides.size(); ++i) {

tests/unit_tests/dagmc/test_model.py

@@ -314,3 +314,28 @@ def test_dagmc_xml_reject_legacy_material_overrides():
     )
     with pytest.raises(ValueError, match="no longer supported"):
         openmc.DAGMCUniverse.from_xml_element(elem, mats)
+
+
+def test_dagmc_xml_temperature_roundtrip():
+    mat = openmc.Material(1)
+    mats = {'1': mat, 'void': None}
+
+    elem = ET.fromstring(
+        '<dagmc_universe id="10" filename="dagmc.h5m">'
+        '<cell id="7" material="1" temperature="825.0"/>'
+        '</dagmc_universe>'
+    )
+
+    dag_univ = openmc.DAGMCUniverse.from_xml_element(elem, mats)
+    assert dag_univ.cells[7].fill.id == 1
+    assert dag_univ.cells[7].temperature == pytest.approx(825.0)
+
+    root = ET.Element('geometry')
+    dag_univ.create_xml_subelement(root)
+    dagmc_elem = root.find('dagmc_universe')
+    xml_cell = dagmc_elem.find('cell')
+    assert xml_cell.get('temperature') == '825.0'
+
+    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)