first version of a pyaml based class for material configuration

pyaml is (again) actively maintained and the ruamel.pyaml API is
instable

python/damask/__init__.py

@@ -18,6 +18,7 @@ from ._lattice     import Symmetry, Lattice# noqa
 from ._orientation import Orientation      # noqa
 from ._result      import Result           # noqa
 from ._geom        import Geom             # noqa
+from ._material    import Material         # noqa
 from .             import solver           # noqa
 
 # deprecated

python/damask/_material.py

@@ -0,0 +1,156 @@
+from io import StringIO
+import copy
+
+import yaml
+import numpy as np
+
+from . import Lattice
+from . import Rotation
+
+class NiceDumper(yaml.SafeDumper):
+    """Make YAML readable for humans."""
+
+    def write_line_break(self, data=None):
+        super().write_line_break(data)
+
+        if len(self.indents) == 1:
+            super().write_line_break()
+
+    def increase_indent(self, flow=False, indentless=False):
+        return super().increase_indent(flow, False)
+
+
+class Material(dict):
+    """Material configuration."""
+
+    def __repr__(self):
+        """Show as in file."""
+        output = StringIO()
+        self.save(output)
+        output.seek(0)
+        return ''.join(output.readlines())
+
+    @staticmethod
+    def load(fname):
+        """Load from yaml file."""
+        try:
+            fhandle = open(fname)
+        except TypeError:
+            fhandle = fname
+        return Material(yaml.safe_load(fhandle))
+
+    def save(self,fname='material.yaml'):
+        """
+        Save to yaml file.
+
+        Parameters
+        ----------
+        fname : file, str, or pathlib.Path
+            Filename or file for reading.
+
+        """
+        try:
+            fhandle = open(fname,'w')
+        except TypeError:
+            fhandle = fname
+        fhandle.write(yaml.dump(dict(self),width=256,default_flow_style=None,Dumper=NiceDumper))
+
+
+    @property
+    def is_complete(self):
+        """Check for completeness."""
+        try:
+           ok = len(self['microstructure']) > 0
+           for m in self['microstructure']:
+               ok &= m['homogenization'] in self['homogenization']
+               for c in m['constituents']:
+                   c['orientation']
+                   ok &= c['phase'] in self['phase']
+           for p in self['phase'].values():
+               ok &= 'lattice' in p
+           return ok
+        except KeyError:
+            return False
+
+
+    @property
+    def is_valid(self):
+        """Check for valid file layout."""
+        ok = True
+
+        if 'phase' in self:
+            for k,v in zip(self['phase'].keys(),self['phase'].values()):
+                if 'lattice' in v:
+                    try:
+                        Lattice(v['lattice'])
+                    except KeyError:
+                        s = v['lattice']
+                        print(f"Invalid lattice: '{s}' in phase '{k}'")
+                        ok = False
+
+        if 'microstructure' in self:
+            for i,v in enumerate(self['microstructure']):
+                if 'constituents' in v:
+                    f = 0.0
+                    for c in v['constituents']:
+                        f+= float(c['fraction'])
+                        if 'orientation' in c:
+                            try:
+                                Rotation.from_quaternion(c['orientation'])
+                            except ValueError:
+                                o = c['orientation']
+                                print(f"Invalid orientation: '{o}' in microstructure '{i}'")
+                                ok = False
+                    if not np.isclose(f,1.0):
+                        print(f"Invalid total fraction '{f}' in microstructure '{i}'")
+                        ok = False
+
+        return ok
+
+
+    def microstructure_rename_phase(self,mapping,ID=None,constituent=None):
+        """
+        Change phase name in microstructure.
+
+        Parameters
+        ----------
+        mapping: dictionary
+            Mapping from old name to new name
+        ID: list of ints, optional
+            Limit renaming to selected microstructure IDs.
+        constituent: list of ints, optional
+            Limit renaming to selected constituents.
+
+        """
+        dup = copy.deepcopy(self)
+        for i,m in enumerate(dup['microstructure']):
+            if ID and i not in ID: continue
+            for c in m['constituents']:
+                if constituent is not None and c not in constituent: continue
+                try:
+                    c['phase'] = mapping[c['phase']]
+                except KeyError:
+                    continue
+        return dup
+
+
+    def microstructure_rename_homogenization(self,mapping,ID=None):
+        """
+        Change homogenization name in microstructure.
+
+        Parameters
+        ----------
+        mapping: dictionary
+            Mapping from old name to new name
+        ID: list of ints, optional
+            Limit renaming to selected homogenization IDs.
+
+        """
+        dup = copy.deepcopy(self)
+        for i,m in enumerate(dup['microstructure']):
+            if ID and i not in ID: continue
+            try:
+                m['homogenization'] = mapping[m['homogenization']]
+            except KeyError:
+                continue
+        return dup

python/tests/reference/Material/material.yaml

@@ -0,0 +1,42 @@
+homogenization:
+  SX:
+    mech: {type: none}
+  Taylor:
+    mech: {type: isostrain, N_constituents: 2}
+
+microstructure:
+  - constituents:
+      - fraction: 1.0
+        orientation: [1.0, 0.0, 0.0, 0.0]
+        phase: Aluminum
+    homogenization: SX
+  - constituents:
+      - fraction: 1.0
+        orientation: [0.7936696712125002, -0.28765777461664166, -0.3436487135089419, 0.4113964260949434]
+        phase: Aluminum
+    homogenization: SX
+  - constituents:
+      - fraction: 1.0
+        orientation: [0.3986143167493579, -0.7014883552495493, 0.2154871765709027, 0.5500781677772945]
+        phase: Aluminum
+    homogenization: SX
+  - homogenization: Taylor
+    constituents:
+      - fraction: .5
+        orientation: [0.28645844315788244, -0.022571491243423537, -0.467933059311115, -0.8357456192708106]
+        phase: Aluminum
+      - fraction: .5
+        orientation: [0.3986143167493579, -0.7014883552495493, 0.2154871765709027, 0.5500781677772945]
+        phase: Steel
+
+phase:
+  Aluminum:
+    elasticity: {C_11: 106.75e9, C_12: 60.41e9, C_44: 28.34e9, type: hooke}
+    generic:
+      output: [F, P, Fe, Fp, Lp]
+    lattice: fcc
+  Steel:
+    elasticity: {C_11: 233.3e9, C_12: 135.5e9, C_44: 118.0e9, type: hooke}
+    generic:
+      output: [F, P, Fe, Fp, Lp]
+    lattice: bcc

python/tests/test_Material.py

@@ -0,0 +1,61 @@
+import os
+
+import pytest
+
+from damask import Material
+
+@pytest.fixture
+def reference_dir(reference_dir_base):
+    """Directory containing reference results."""
+    return reference_dir_base/'Material'
+
+
+class TestMaterial:
+    
+    @pytest.mark.parametrize('fname',[None,'test.yaml'])
+    def test_load_save(self,reference_dir,tmp_path,fname):
+        reference = Material.load(reference_dir/'material.yaml')
+        os.chdir(tmp_path)
+        if fname is None:
+            reference.save()
+            new = Material.load('material.yaml')
+        else:
+            reference.save(fname)
+            new = Material.load(fname)
+        assert reference == new
+
+    def test_valid_complete(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        assert material_config.is_valid and material_config.is_complete
+
+    def test_invalid_lattice(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        material_config['phase']['Aluminum']['lattice']='fxc'
+        assert not material_config.is_valid
+    
+    def test_invalid_orientation(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        material_config['microstructure'][0]['constituents'][0]['orientation']=[0,0,0,0]
+        assert not material_config.is_valid
+    
+    def test_invalid_fraction(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        material_config['microstructure'][0]['constituents'][0]['fraction']=.9
+        assert not material_config.is_valid
+    
+
+    @pytest.mark.parametrize('item',['homogenization','phase','microstructure'])
+    def test_incomplete_missing(self,reference_dir,item):
+        material_config = Material.load(reference_dir/'material.yaml')
+        del material_config[item]
+        assert not material_config.is_complete
+    
+    def test_incomplete_wrong_phase(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        new = material_config.microstructure_rename_phase({'Steel':'FeNbC'})
+        assert not new.is_complete
+    
+    def test_incomplete_wrong_homogenization(self,reference_dir):
+        material_config = Material.load(reference_dir/'material.yaml')
+        new = material_config.microstructure_rename_homogenization({'Taylor':'isostrain'})
+        assert not new.is_complete