235 lines
7.9 KiB
Python
235 lines
7.9 KiB
Python
import copy
|
|
|
|
import numpy as np
|
|
|
|
from . import Config
|
|
from . import Lattice
|
|
from . import Rotation
|
|
from . import Table
|
|
|
|
class ConfigMaterial(Config):
|
|
"""Material configuration."""
|
|
|
|
def save(self,fname='material.yaml',**kwargs):
|
|
"""
|
|
Save to yaml file.
|
|
|
|
Parameters
|
|
----------
|
|
fname : file, str, or pathlib.Path, optional
|
|
Filename or file for writing. Defaults to 'material.yaml'.
|
|
**kwargs : dict
|
|
Keyword arguments parsed to yaml.dump.
|
|
|
|
"""
|
|
super().save(fname,**kwargs)
|
|
|
|
|
|
@staticmethod
|
|
def load_table(fname,coordinates=None,constituents={},**kwargs):
|
|
t = Table.load(fname)
|
|
if coordinates is not None: t = t.sort_by([f'{i}_{coordinates}' for i in range(3,0,-1)])
|
|
constituents_ = {k:t.get(v) for k,v in constituents.items()}
|
|
kwargs_ = {k:t.get(v) for k,v in kwargs.items()}
|
|
|
|
_,idx = np.unique(np.hstack(list({**constituents_,**kwargs_}.values())),return_index=True,axis=0)
|
|
|
|
constituents_ = {k:v[idx].squeeze() for k,v in constituents_.items()}
|
|
kwargs_ = {k:v[idx].squeeze() for k,v in kwargs_.items()}
|
|
|
|
return ConfigMaterial().material_add(constituents_,**kwargs_)
|
|
|
|
|
|
@property
|
|
def is_complete(self):
|
|
"""Check for completeness."""
|
|
ok = True
|
|
for top_level in ['homogenization','phase','material']:
|
|
# ToDo: With python 3.8 as prerequisite we can shorten with :=
|
|
ok &= top_level in self
|
|
if top_level not in self: print(f'{top_level} entry missing')
|
|
|
|
if ok:
|
|
ok &= len(self['material']) > 0
|
|
if len(self['material']) < 1: print('Incomplete material definition')
|
|
|
|
if ok:
|
|
homogenization = set()
|
|
phase = set()
|
|
for i,v in enumerate(self['material']):
|
|
if 'homogenization' in v:
|
|
homogenization.add(v['homogenization'])
|
|
else:
|
|
print(f'No homogenization specified in material {i}')
|
|
ok = False
|
|
|
|
if 'constituents' in v:
|
|
for ii,vv in enumerate(v['constituents']):
|
|
if 'O' not in vv:
|
|
print('No orientation specified in constituent {ii} of material {i}')
|
|
ok = False
|
|
if 'phase' in vv:
|
|
phase.add(vv['phase'])
|
|
else:
|
|
print(f'No phase specified in constituent {ii} of material {i}')
|
|
ok = False
|
|
|
|
for k,v in self['phase'].items():
|
|
if 'lattice' not in v:
|
|
print(f'No lattice specified in phase {k}')
|
|
ok = False
|
|
|
|
for k,v in self['homogenization'].items():
|
|
if 'N_constituents' not in v:
|
|
print(f'No. of constituents not specified in homogenization {k}')
|
|
ok = False
|
|
|
|
if phase - set(self['phase']):
|
|
print(f'Phase(s) {phase-set(self["phase"])} missing')
|
|
ok = False
|
|
if homogenization - set(self['homogenization']):
|
|
print(f'Homogenization(s) {homogenization-set(self["homogenization"])} missing')
|
|
ok = False
|
|
|
|
return ok
|
|
|
|
|
|
@property
|
|
def is_valid(self):
|
|
"""Check for valid file layout."""
|
|
ok = True
|
|
|
|
if 'phase' in self:
|
|
for k,v in self['phase'].items():
|
|
if 'lattice' in v:
|
|
try:
|
|
Lattice(v['lattice'])
|
|
except KeyError:
|
|
s = v['lattice']
|
|
print(f"Invalid lattice: '{s}' in phase '{k}'")
|
|
ok = False
|
|
|
|
if 'material' in self:
|
|
for i,v in enumerate(self['material']):
|
|
if 'constituents' in v:
|
|
f = 0.0
|
|
for c in v['constituents']:
|
|
f+= float(c['fraction'])
|
|
if 'O' in c:
|
|
try:
|
|
Rotation.from_quaternion(c['O'])
|
|
except ValueError:
|
|
o = c['O']
|
|
print(f"Invalid orientation: '{o}' in material '{i}'")
|
|
ok = False
|
|
if not np.isclose(f,1.0):
|
|
print(f"Invalid total fraction '{f}' in material '{i}'")
|
|
ok = False
|
|
|
|
return ok
|
|
|
|
|
|
def material_rename_phase(self,mapping,ID=None,constituent=None):
|
|
"""
|
|
Change phase name in material.
|
|
|
|
Parameters
|
|
----------
|
|
mapping: dictionary
|
|
Mapping from old name to new name
|
|
ID: list of ints, optional
|
|
Limit renaming to selected material IDs.
|
|
constituent: list of ints, optional
|
|
Limit renaming to selected constituents.
|
|
|
|
"""
|
|
dup = copy.deepcopy(self)
|
|
for i,m in enumerate(dup['material']):
|
|
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 material_rename_homogenization(self,mapping,ID=None):
|
|
"""
|
|
Change homogenization name in material.
|
|
|
|
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['material']):
|
|
if ID and i not in ID: continue
|
|
try:
|
|
m['homogenization'] = mapping[m['homogenization']]
|
|
except KeyError:
|
|
continue
|
|
return dup
|
|
|
|
|
|
def material_add(self,constituents,**kwargs):
|
|
"""
|
|
Add material entries.
|
|
|
|
Parameters
|
|
----------
|
|
constituents: scalar or numpy.ndarray
|
|
**kwargs: tbd
|
|
|
|
Examples
|
|
--------
|
|
m = damask.ConfigMaterial()
|
|
O = damask.Rotation.from_random(3).as_quaternion()
|
|
phase = ['Aluminum','Steel','Aluminum']
|
|
|
|
m.material_add(constituents={'phase':phase,'O':O},homogenization='SX')
|
|
|
|
"""
|
|
c = [{'constituents':u} for u in ConfigMaterial._constituents(**constituents)]
|
|
for k,v in kwargs.items():
|
|
if hasattr(v,'__len__') and not isinstance(v,str):
|
|
if len(v) != len(c):
|
|
raise ValueError('len mismatch 1')
|
|
for i,vv in enumerate(v):
|
|
c[i][k] = [w.item() for w in vv] if isinstance(vv,np.ndarray) else vv.item()
|
|
else:
|
|
for i in range(len(c)):
|
|
c[i][k] = v
|
|
dup = copy.deepcopy(self)
|
|
if 'material' not in dup: dup['material'] = []
|
|
dup['material'] +=c
|
|
|
|
return dup
|
|
|
|
|
|
@staticmethod
|
|
def _constituents(N=1,**kwargs):
|
|
"""Construct list of constituents."""
|
|
for v in kwargs.values():
|
|
if hasattr(v,'__len__') and not isinstance(v,str): N_material = len(v)
|
|
|
|
if N == 1:
|
|
m = [[{'fraction':1.0}] for _ in range(N_material)]
|
|
for k,v in kwargs.items():
|
|
if hasattr(v,'__len__') and not isinstance(v,str):
|
|
if len(v) != N_material:
|
|
raise ValueError('len mismatch 2')
|
|
for i,vv in enumerate(np.array(v)):
|
|
m[i][0][k] = [w.item() for w in vv] if isinstance(vv,np.ndarray) else vv.item()
|
|
else:
|
|
for i in range(N_material):
|
|
m[i][0][k] = v
|
|
return m
|
|
else:
|
|
raise NotImplementedError
|