Consistent XML parsing using functions from _xml module (#3517)

Co-authored-by: Paul Romano <paul.k.romano@gmail.com>

Author: GuySten

openmc/_xml.py

@@ -64,8 +64,8 @@ def get_text(elem, name, default=None):
 
 
 
-def get_elem_tuple(elem, name, dtype=int):
-    """Helper function to get a tuple of values from an elem
+def get_elem_list(elem, name, dtype=int):
+    """Helper function to get a list of values from an elem
 
     Parameters
     ----------
@@ -78,9 +78,9 @@ def get_elem_tuple(elem, name, dtype=int):
 
     Returns
     -------
-    tuple of dtype
-        Data read from the tuple
+    list of dtype
+        Data read from the list
     """
-    subelem = elem.find(name)
-    if subelem is not None:
-        return tuple([dtype(x) for x in subelem.text.split()])
+    text = get_text(elem, name)
+    if text is not None:
+        return [dtype(x) for x in text.split()]

openmc/cell.py

@@ -8,7 +8,7 @@
 
 import openmc
 import openmc.checkvalue as cv
-from ._xml import get_text
+from ._xml import get_elem_list, get_text
 from .mixin import IDManagerMixin
 from .plots import add_plot_params
 from .region import Region, Complement
@@ -689,9 +689,8 @@ def from_xml_element(cls, elem, surfaces, materials, get_universe):
         c = cls(cell_id, name)
 
         # Assign material/distributed materials or fill
-        mat_text = get_text(elem, 'material')
-        if mat_text is not None:
-            mat_ids = mat_text.split()
+        mat_ids = get_elem_list(elem, 'material', str)
+        if mat_ids is not None:
             if len(mat_ids) > 1:
                 c.fill = [materials[i] for i in mat_ids]
             else:
@@ -706,19 +705,18 @@ def from_xml_element(cls, elem, surfaces, materials, get_universe):
             c.region = Region.from_expression(region, surfaces)
 
         # Check for other attributes
-        t = get_text(elem, 'temperature')
-        if t is not None:
-            if ' ' in t:
-                c.temperature = [float(t_i) for t_i in t.split()]
+        temperature = get_elem_list(elem, 'temperature', float)
+        if temperature is not None:
+            if len(temperature) > 1:
+                c.temperature = temperature
             else:
-                c.temperature = float(t)
+                c.temperature = temperature[0]
         v = get_text(elem, 'volume')
         if v is not None:
             c.volume = float(v)
         for key in ('temperature', 'rotation', 'translation'):
-            value = get_text(elem, key)
-            if value is not None:
-                values = [float(x) for x in value.split()]
+            values = get_elem_list(elem, key, float)
+            if values is not None:
                 if key == 'rotation' and len(values) == 9:
                     values = np.array(values).reshape(3, 3)
                 setattr(c, key, values)

openmc/dagmc.py

@@ -8,7 +8,7 @@
 
 import openmc
 import openmc.checkvalue as cv
-from ._xml import get_text
+from ._xml import get_elem_list, get_text
 from .checkvalue import check_type, check_value
 from .surface import _BOUNDARY_TYPES
 from .bounding_box import BoundingBox
@@ -468,8 +468,8 @@ def from_xml_element(cls, elem, mats = None):
         if name is not None:
             out.name = name
 
-        out.auto_geom_ids = bool(elem.get('auto_geom_ids'))
-        out.auto_mat_ids = bool(elem.get('auto_mat_ids'))
+        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:
@@ -480,7 +480,7 @@ def from_xml_element(cls, elem, mats = None):
             out._material_overrides = {}
             for elem in el_mat_override.findall('cell_override'):
                 cell_id = int(get_text(elem, 'id'))
-                mat_ids = get_text(elem, 'material_ids').split(' ')
+                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
 

openmc/data/library.py

@@ -5,7 +5,7 @@
 import lxml.etree as ET
 
 import openmc
-from openmc._xml import clean_indentation
+from openmc._xml import get_elem_list, get_text, clean_indentation
 
 
 class DataLibrary(list):
@@ -172,17 +172,17 @@ def from_xml(cls, path=None):
             directory = os.path.dirname(path)
 
         for lib_element in root.findall('library'):
-            filename = os.path.join(directory, lib_element.attrib['path'])
-            filetype = lib_element.attrib['type']
-            materials = lib_element.attrib['materials'].split()
+            filename = os.path.join(directory, get_text(lib_element, "path"))
+            filetype = get_text(lib_element, "type")
+            materials = get_elem_list(lib_element, "materials", str) or []
             library = {'path': filename, 'type': filetype,
                        'materials': materials}
             data.libraries.append(library)
 
         # get depletion chain data
         dep_node = root.find("depletion_chain")
         if dep_node is not None:
-            filename = os.path.join(directory, dep_node.attrib['path'])
+            filename = os.path.join(directory, get_text(dep_node, "path"))
             library = {'path': filename, 'type': 'depletion_chain',
                        'materials': []}
             data.libraries.append(library)

openmc/deplete/chain.py

@@ -22,6 +22,7 @@
 from openmc.data import gnds_name, zam
 from openmc.exceptions import DataError
 from .nuclide import FissionYieldDistribution, Nuclide
+from .._xml import get_text
 import openmc.data
 
 
@@ -553,7 +554,7 @@ def from_xml(cls, filename, fission_q=None):
         root = ET.parse(str(filename))
 
         for i, nuclide_elem in enumerate(root.findall('nuclide')):
-            this_q = fission_q.get(nuclide_elem.get("name"))
+            this_q = fission_q.get(get_text(nuclide_elem, "name"))
 
             nuc = Nuclide.from_xml(nuclide_elem, root, this_q)
             chain.add_nuclide(nuc)

openmc/deplete/nuclide.py

@@ -14,6 +14,7 @@
 
 from openmc.checkvalue import check_type
 from openmc.stats import Univariate
+from .._xml import get_elem_list, get_text
 
 __all__ = [
     "DecayTuple", "ReactionTuple", "Nuclide", "FissionYield",
@@ -225,38 +226,39 @@ def from_xml(cls, element, root=None, fission_q=None):
 
         """
         nuc = cls()
-        nuc.name = element.get('name')
+        nuc.name = get_text(element, "name")
 
         # Check for half-life
-        if 'half_life' in element.attrib:
-            nuc.half_life = float(element.get('half_life'))
-            nuc.decay_energy = float(element.get('decay_energy', '0'))
+        half_life = get_text(element, "half_life")
+        if half_life is not None:
+            nuc.half_life = float(half_life)
+            nuc.decay_energy = float(get_text(element, "decay_energy", 0.0))
 
         # Check for decay paths
         for decay_elem in element.iter('decay'):
-            d_type = decay_elem.get('type')
-            target = decay_elem.get('target')
+            d_type = get_text(decay_elem, "type")
+            target = get_text(decay_elem, "target")
             if target is not None and target.lower() == "nothing":
                 target = None
-            branching_ratio = float(decay_elem.get('branching_ratio'))
+            branching_ratio = float(get_text(decay_elem, "branching_ratio"))
             nuc.decay_modes.append(DecayTuple(d_type, target, branching_ratio))
 
         # Check for sources
         for src_elem in element.iter('source'):
-            particle = src_elem.get('particle')
+            particle = get_text(src_elem, "particle")
             distribution = Univariate.from_xml_element(src_elem)
             nuc.sources[particle] = distribution
 
         # Check for reaction paths
         for reaction_elem in element.iter('reaction'):
-            r_type = reaction_elem.get('type')
-            Q = float(reaction_elem.get('Q', '0'))
-            branching_ratio = float(reaction_elem.get('branching_ratio', '1'))
+            r_type = get_text(reaction_elem, "type")
+            Q = float(get_text(reaction_elem, "Q", 0.0))
+            branching_ratio = float(get_text(reaction_elem, "branching_ratio", 1.0))
 
             # If the type is not fission, get target and Q value, otherwise
             # just set null values
             if r_type != 'fission':
-                target = reaction_elem.get('target')
+                target = get_text(reaction_elem, "target")
                 if target is not None and target.lower() == "nothing":
                     target = None
             else:
@@ -271,7 +273,7 @@ def from_xml(cls, element, root=None, fission_q=None):
         fpy_elem = element.find('neutron_fission_yields')
         if fpy_elem is not None:
             # Check for use of FPY from other nuclide
-            parent = fpy_elem.get('parent')
+            parent = get_text(fpy_elem, "parent")
             if parent is not None:
                 assert root is not None
                 fpy_elem = root.find(
@@ -529,9 +531,9 @@ def from_xml_element(cls, element):
         """
         all_yields = {}
         for yield_elem in element.iter("fission_yields"):
-            energy = float(yield_elem.get("energy"))
-            products = yield_elem.find("products").text.split()
-            yields = map(float, yield_elem.find("data").text.split())
+            energy = float(get_text(yield_elem, "energy"))
+            products = get_elem_list(yield_elem, "products", str) or []
+            yields = get_elem_list(yield_elem, "data", float) or []
             # Get a map of products to their corresponding yield
             all_yields[energy] = dict(zip(products, yields))
 

openmc/filter.py

@@ -17,7 +17,7 @@
 from .mixin import IDManagerMixin
 from .surface import Surface
 from .universe import UniverseBase
-from ._xml import get_text
+from ._xml import get_elem_list, get_text
 
 
 _FILTER_TYPES = (
@@ -259,17 +259,15 @@ def from_xml_element(cls, elem, **kwargs):
             Filter object
 
         """
-        filter_type = elem.get('type')
-        if filter_type is None:
-            filter_type = elem.find('type').text
+        filter_type = get_text(elem, "type")
 
         # If the filter type matches this class's short_name, then
         # there is no overridden from_xml_element method
         if filter_type == cls.short_name.lower():
             # Get bins from element -- the default here works for any filters
             # that just store a list of bins that can be represented as integers
-            filter_id = int(elem.get('id'))
-            bins = [int(x) for x in get_text(elem, 'bins').split()]
+            filter_id = int(get_text(elem, "id"))
+            bins = get_elem_list(elem, "bins", int) or []
             return cls(bins, filter_id=filter_id)
 
         # Search through all subclasses and find the one matching the HDF5
@@ -701,8 +699,8 @@ def to_xml_element(self):
 
     @classmethod
     def from_xml_element(cls, elem, **kwargs):
-        filter_id = int(elem.get('id'))
-        bins = [int(x) for x in get_text(elem, 'bins').split()]
+        filter_id = int(get_text(elem, "id"))
+        bins = get_elem_list(elem, "bins", int) or []
         cell_instances = list(zip(bins[::2], bins[1::2]))
         return cls(cell_instances, filter_id=filter_id)
 
@@ -784,8 +782,8 @@ def from_hdf5(cls, group, **kwargs):
 
     @classmethod
     def from_xml_element(cls, elem, **kwargs):
-        filter_id = int(elem.get('id'))
-        bins = get_text(elem, 'bins').split()
+        filter_id = int(get_text(elem, "id"))
+        bins = get_elem_list(elem, "bins", str) or []
         return cls(bins, filter_id=filter_id)
 
 
@@ -1004,12 +1002,12 @@ def to_xml_element(self):
     def from_xml_element(cls, elem: ET.Element, **kwargs) -> MeshFilter:
         mesh_id = int(get_text(elem, 'bins'))
         mesh_obj = kwargs['meshes'][mesh_id]
-        filter_id = int(elem.get('id'))
+        filter_id = int(get_text(elem, "id"))
         out = cls(mesh_obj, filter_id=filter_id)
 
-        translation = elem.get('translation')
+        translation = get_elem_list(elem, "translation", float) or []
         if translation:
-            out.translation = [float(x) for x in translation.split()]
+            out.translation = translation
         return out
 
 
@@ -1149,16 +1147,16 @@ def to_xml_element(self):
 
     @classmethod
     def from_xml_element(cls, elem: ET.Element, **kwargs) -> MeshMaterialFilter:
-        filter_id = int(elem.get('id'))
-        mesh_id = int(elem.get('mesh'))
+        filter_id = int(get_text(elem, "id"))
+        mesh_id = int(get_text(elem, "mesh"))
         mesh_obj = kwargs['meshes'][mesh_id]
-        bins = [int(x) for x in get_text(elem, 'bins').split()]
+        bins = get_elem_list(elem, "bins", int) or []
         bins = list(zip(bins[::2], bins[1::2]))
         out = cls(mesh_obj, bins, filter_id=filter_id)
 
-        translation = elem.get('translation')
+        translation = get_elem_list(elem, "translation", float) or []
         if translation:
-            out.translation = [float(x) for x in translation.split()]
+            out.translation = translation
         return out
 
     @classmethod
@@ -1557,8 +1555,8 @@ def to_xml_element(self):
 
     @classmethod
     def from_xml_element(cls, elem, **kwargs):
-        filter_id = int(elem.get('id'))
-        bins = [float(x) for x in get_text(elem, 'bins').split()]
+        filter_id = int(get_text(elem, "id"))
+        bins = get_elem_list(elem, "bins", float) or []
         return cls(bins, filter_id=filter_id)
 
 
@@ -2447,12 +2445,13 @@ def to_xml_element(self):
 
     @classmethod
     def from_xml_element(cls, elem, **kwargs):
-        filter_id = int(elem.get('id'))
-        energy = [float(x) for x in get_text(elem, 'energy').split()]
-        y = [float(x) for x in get_text(elem, 'y').split()]
+        filter_id = int(get_text(elem, "id"))
+        energy = get_elem_list(elem, "energy", float) or []
+        y = get_elem_list(elem, "y", float) or []
         out = cls(energy, y, filter_id=filter_id)
-        if elem.find('interpolation') is not None:
-            out.interpolation = elem.find('interpolation').text
+        interpolation = get_text(elem, "interpolation")
+        if interpolation is not None:
+            out.interpolation = interpolation
         return out
 
     def can_merge(self, other):