DAMASK_EICMD/python/damask/_grid.py

1048 lines
41 KiB
Python
Raw Normal View History

2020-08-22 23:25:18 +05:30
import copy
2020-09-18 20:02:08 +05:30
import multiprocessing as mp
2020-03-29 22:42:23 +05:30
from functools import partial
2021-01-13 17:18:20 +05:30
import os
2020-11-14 22:24:47 +05:30
import warnings
2019-05-26 15:33:21 +05:30
import numpy as np
import pandas as pd
import h5py
2020-12-11 01:23:11 +05:30
from scipy import ndimage, spatial
from vtk.util.numpy_support import vtk_to_numpy as vtk_to_np
2019-05-26 15:33:21 +05:30
2020-03-11 12:02:03 +05:30
from . import VTK
2019-05-28 01:30:26 +05:30
from . import util
2020-03-29 22:42:23 +05:30
from . import grid_filters
from . import Rotation
2019-05-28 01:30:26 +05:30
2019-05-26 15:33:21 +05:30
2020-12-04 11:42:18 +05:30
class Grid:
"""
Geometry definition for grid solvers.
Create and manipulate geometry definitions for storage as VTK
rectiliear grid files ('.vtr' extension). A grid contains the
material ID (referring to the entry in 'material.yaml') and
the physical size.
"""
2019-11-23 01:22:36 +05:30
def __init__(self,material,size,origin=[0.0,0.0,0.0],comments=[]):
2019-11-23 01:22:36 +05:30
"""
New geometry definition for grid solvers.
2019-11-23 01:22:36 +05:30
Parameters
----------
material : numpy.ndarray
Material index array (3D).
2019-11-23 01:22:36 +05:30
size : list or numpy.ndarray
2020-12-04 11:42:18 +05:30
Physical size of the grid in meter.
2019-11-23 01:22:36 +05:30
origin : list or numpy.ndarray, optional
2020-12-04 11:42:18 +05:30
Physical origin of the grid in meter.
2019-11-23 01:22:36 +05:30
comments : list of str, optional
Comment lines.
2019-11-23 01:22:36 +05:30
"""
self.material = material
self.size = size
self.origin = origin
self.comments = comments
2020-03-21 15:37:21 +05:30
2019-11-23 01:22:36 +05:30
def __repr__(self):
2020-12-04 11:42:18 +05:30
"""Basic information on grid definition."""
mat_min = np.nanmin(self.material)
mat_max = np.nanmax(self.material)
mat_N = self.N_materials
2019-11-23 01:22:36 +05:30
return util.srepr([
f'cells a b c: {util.srepr(self.cells, " x ")}',
f'size x y z: {util.srepr(self.size, " x ")}',
f'origin x y z: {util.srepr(self.origin," ")}',
2020-12-11 01:23:11 +05:30
f'# materials: {mat_N}' + ('' if mat_min == 0 and mat_max+1 == mat_N else
f' (min: {mat_min}, max: {mat_max})')
2019-11-23 01:22:36 +05:30
])
2020-08-22 23:25:18 +05:30
def __copy__(self):
2021-01-03 16:33:40 +05:30
"""Create deep copy."""
2020-08-22 23:25:18 +05:30
return copy.deepcopy(self)
2021-01-03 16:33:40 +05:30
copy = __copy__
2020-08-22 23:25:18 +05:30
def __eq__(self,other):
"""
Test equality of other.
Parameters
----------
2020-12-04 11:42:18 +05:30
other : damask.Grid
Grid to compare self against.
"""
return (np.allclose(other.size,self.size)
and np.allclose(other.origin,self.origin)
and np.all(other.cells == self.cells)
and np.all(other.material == self.material))
2019-11-23 01:22:36 +05:30
@property
def material(self):
"""Material indices."""
return self._material
@material.setter
def material(self,material):
if len(material.shape) != 3:
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid material shape {material.shape}')
elif material.dtype not in np.sctypes['float'] + np.sctypes['int']:
2020-12-11 01:23:11 +05:30
raise TypeError(f'invalid material data type {material.dtype}')
else:
self._material = np.copy(material)
if self.material.dtype in np.sctypes['float'] and \
np.all(self.material == self.material.astype(int).astype(float)):
self._material = self.material.astype(int)
@property
def size(self):
2020-12-04 11:42:18 +05:30
"""Physical size of grid in meter."""
return self._size
@size.setter
def size(self,size):
if len(size) != 3 or any(np.array(size) < 0):
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid size {size}')
else:
self._size = np.array(size)
@property
def origin(self):
2020-12-04 11:42:18 +05:30
"""Coordinates of grid origin in meter."""
return self._origin
@origin.setter
def origin(self,origin):
if len(origin) != 3:
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid origin {origin}')
else:
self._origin = np.array(origin)
@property
def comments(self):
2020-12-04 11:42:18 +05:30
"""Comments, e.g. history of operations."""
return self._comments
@comments.setter
def comments(self,comments):
self._comments = [str(c) for c in comments] if isinstance(comments,list) else [str(comments)]
2019-12-08 13:47:57 +05:30
@property
2020-12-04 02:28:24 +05:30
def cells(self):
"""Number of cells in x,y,z direction."""
return np.asarray(self.material.shape)
2019-11-23 01:22:36 +05:30
2020-03-18 18:19:53 +05:30
@property
def N_materials(self):
2020-12-04 11:42:18 +05:30
"""Number of (unique) material indices within grid."""
return np.unique(self.material).size
2019-11-23 01:22:36 +05:30
@staticmethod
def load(fname):
"""
2020-12-04 02:28:24 +05:30
Load from VTK rectilinear grid file.
Parameters
----------
fname : str or or pathlib.Path
2020-12-04 11:42:18 +05:30
Grid file to read. Valid extension is .vtr, which will be appended
if not given.
Returns
-------
loaded : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from file.
"""
v = VTK.load(fname if str(fname).endswith('.vtr') else str(fname)+'.vtr')
comments = v.get_comments()
2020-12-04 02:28:24 +05:30
cells = np.array(v.vtk_data.GetDimensions())-1
bbox = np.array(v.vtk_data.GetBounds()).reshape(3,2).T
2020-12-11 01:23:11 +05:30
for i,c in enumerate([v.vtk_data.GetXCoordinates(),v.vtk_data.GetYCoordinates(),v.vtk_data.GetZCoordinates()]):
if not np.allclose(vtk_to_np(c),np.linspace(bbox[0][i],bbox[1][i],cells[i]+1)):
raise ValueError('regular grid spacing violated')
2020-12-04 11:42:18 +05:30
return Grid(material = v.get('material').reshape(cells,order='F'),
size = bbox[1] - bbox[0],
origin = bbox[0],
comments=comments)
@staticmethod
def load_ASCII(fname):
2019-11-23 01:22:36 +05:30
"""
2020-12-04 02:28:24 +05:30
Load from geom file.
2019-11-23 01:22:36 +05:30
2020-11-14 22:24:47 +05:30
Storing geometry files in ASCII format is deprecated.
This function will be removed in a future version of DAMASK.
2019-11-23 01:22:36 +05:30
Parameters
----------
fname : str, pathlib.Path, or file handle
2020-08-08 23:12:34 +05:30
Geometry file to read.
2019-11-23 01:22:36 +05:30
Returns
-------
loaded : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from file.
2019-11-23 01:22:36 +05:30
"""
warnings.warn('Support for ASCII-based geom format will be removed in DAMASK 3.1.0', DeprecationWarning,2)
try:
f = open(fname)
except TypeError:
f = fname
f.seek(0)
try:
header_length,keyword = f.readline().split()[:2]
header_length = int(header_length)
except ValueError:
header_length,keyword = (-1, 'invalid')
2019-11-23 01:22:36 +05:30
if not keyword.startswith('head') or header_length < 3:
2020-12-11 01:23:11 +05:30
raise TypeError('header length information missing or invalid')
2019-11-23 01:22:36 +05:30
2020-03-21 15:37:21 +05:30
comments = []
2020-11-20 00:56:15 +05:30
content = f.readlines()
2019-11-23 01:22:36 +05:30
for i,line in enumerate(content[:header_length]):
2020-04-02 15:24:34 +05:30
items = line.split('#')[0].lower().strip().split()
2020-02-22 05:24:15 +05:30
key = items[0] if items else ''
2019-11-23 01:22:36 +05:30
if key == 'grid':
2020-12-04 02:28:24 +05:30
cells = np.array([ int(dict(zip(items[1::2],items[2::2]))[i]) for i in ['a','b','c']])
2019-11-23 01:22:36 +05:30
elif key == 'size':
size = np.array([float(dict(zip(items[1::2],items[2::2]))[i]) for i in ['x','y','z']])
elif key == 'origin':
origin = np.array([float(dict(zip(items[1::2],items[2::2]))[i]) for i in ['x','y','z']])
else:
comments.append(line.strip())
2020-12-04 02:28:24 +05:30
material = np.empty(cells.prod()) # initialize as flat array
2019-11-23 01:22:36 +05:30
i = 0
for line in content[header_length:]:
2020-04-02 15:24:34 +05:30
items = line.split('#')[0].split()
2019-11-23 01:22:36 +05:30
if len(items) == 3:
if items[1].lower() == 'of':
items = np.ones(int(items[0]))*float(items[2])
elif items[1].lower() == 'to':
items = np.linspace(int(items[0]),int(items[2]),
abs(int(items[2])-int(items[0]))+1,dtype=float)
else: items = list(map(float,items))
else: items = list(map(float,items))
material[i:i+len(items)] = items
2019-11-23 01:22:36 +05:30
i += len(items)
2020-03-21 15:37:21 +05:30
2020-12-04 02:28:24 +05:30
if i != cells.prod():
2020-12-11 01:23:11 +05:30
raise TypeError(f'invalid file: expected {cells.prod()} entries, found {i}')
2020-03-21 15:37:21 +05:30
if not np.any(np.mod(material,1) != 0.0): # no float present
material = material.astype('int') - (1 if material.min() > 0 else 0)
2020-03-21 15:37:21 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material.reshape(cells,order='F'),size,origin,comments)
2019-11-23 01:22:36 +05:30
2020-10-09 17:49:19 +05:30
@staticmethod
def load_DREAM3D(fname,
2021-03-23 18:58:56 +05:30
feature_IDs=None,cell_data=None,
phases='Phases',Euler_angles='EulerAngles',
base_group=None):
2020-10-09 17:49:19 +05:30
"""
2021-03-20 18:07:06 +05:30
Load DREAM.3D (HDF5) file.
Data in DREAM.3D files can be stored per cell ('CellData') and/or
per grain ('Grain Data'). Per default, cell-wise data is assumed.
2021-03-20 18:07:06 +05:30
damask.ConfigMaterial.load_DREAM3D gives the corresponding material definition.
2020-10-09 17:49:19 +05:30
Parameters
----------
fname : str
Filename of the DREAM.3D (HDF5) file.
2021-03-20 18:07:06 +05:30
feature_IDs : str
Name of the dataset containing the mapping between cells and
grain-wise data. Defaults to 'None', in which case cell-wise
data is used.
cell_data : str
2021-03-23 18:58:56 +05:30
Name of the group (folder) containing cell-wise data. Defaults to
None in wich case it is automatically detected.
2021-03-20 18:07:06 +05:30
phases : str
Name of the dataset containing the phase ID. It is not used for
grain-wise data, i.e. when feature_IDs is not None.
Defaults to 'Phases'.
Euler_angles : str
Name of the dataset containing the crystallographic orientation as
Euler angles in radians It is not used for grain-wise data, i.e.
when feature_IDs is not None. Defaults to 'EulerAngles'.
2021-03-20 04:19:41 +05:30
base_group : str
2021-03-20 18:07:06 +05:30
Path to the group (folder) that contains geometry (_SIMPL_GEOMETRY),
and grain- or cell-wise data. Defaults to None, in which case
2021-03-20 04:19:41 +05:30
it is set as the path that contains _SIMPL_GEOMETRY/SPACING.
Returns
-------
loaded : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from file.
2021-03-20 18:07:06 +05:30
2020-10-09 17:49:19 +05:30
"""
b = util.DREAM3D_base_group(fname) if base_group is None else base_group
c = util.DREAM3D_cell_data_group(fname) if cell_data is None else cell_data
2020-10-09 17:49:19 +05:30
f = h5py.File(fname, 'r')
2021-03-23 18:58:56 +05:30
cells = f['/'.join([b,'_SIMPL_GEOMETRY','DIMENSIONS'])][()]
size = f['/'.join([b,'_SIMPL_GEOMETRY','SPACING'])] * cells
origin = f['/'.join([b,'_SIMPL_GEOMETRY','ORIGIN'])][()]
2021-03-20 04:19:41 +05:30
if feature_IDs is None:
phase = f['/'.join([b,c,phases])][()].reshape(-1,1)
O = Rotation.from_Euler_angles(f['/'.join([b,c,Euler_angles])]).as_quaternion().reshape(-1,4) # noqa
unique,unique_inverse = np.unique(np.hstack([O,phase]),return_inverse=True,axis=0)
ma = np.arange(cells.prod()) if len(unique) == cells.prod() else \
np.arange(unique.size)[np.argsort(pd.unique(unique_inverse))][unique_inverse]
else:
ma = f['/'.join([b,c,feature_IDs])][()].flatten()
2020-10-09 17:49:19 +05:30
2020-12-04 11:42:18 +05:30
return Grid(ma.reshape(cells,order='F'),size,origin,util.execution_stamp('Grid','load_DREAM3D'))
2020-10-09 17:49:19 +05:30
@staticmethod
def from_table(table,coordinates,labels):
2020-10-09 17:49:19 +05:30
"""
2020-12-04 02:28:24 +05:30
Generate grid from ASCII table.
2020-10-09 17:49:19 +05:30
Parameters
----------
table : damask.Table
Table that contains material information.
2020-10-09 17:49:19 +05:30
coordinates : str
Label of the vector column containing the spatial coordinates.
Need to be ordered (1./x fast, 3./z slow).
2020-10-09 17:49:19 +05:30
labels : str or list of str
Label(s) of the columns containing the material definition.
Each unique combination of values results in one material ID.
2020-10-09 17:49:19 +05:30
Returns
-------
new : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from values in table.
2020-10-09 17:49:19 +05:30
"""
cells,size,origin = grid_filters.cellsSizeOrigin_coordinates0_point(table.get(coordinates))
2020-10-09 17:49:19 +05:30
labels_ = [labels] if isinstance(labels,str) else labels
unique,unique_inverse = np.unique(np.hstack([table.get(l) for l in labels_]),return_inverse=True,axis=0)
2020-10-31 21:53:58 +05:30
2020-12-04 02:28:24 +05:30
ma = np.arange(cells.prod()) if len(unique) == cells.prod() else \
2020-10-31 21:53:58 +05:30
np.arange(unique.size)[np.argsort(pd.unique(unique_inverse))][unique_inverse]
2020-10-09 17:49:19 +05:30
2020-12-04 11:42:18 +05:30
return Grid(ma.reshape(cells,order='F'),size,origin,util.execution_stamp('Grid','from_table'))
2020-10-09 17:49:19 +05:30
2020-03-29 22:42:23 +05:30
@staticmethod
def _find_closest_seed(seeds, weights, point):
return np.argmin(np.sum((np.broadcast_to(point,(len(seeds),3))-seeds)**2,axis=1) - weights)
2020-06-24 21:35:12 +05:30
2020-03-29 22:42:23 +05:30
@staticmethod
2020-12-04 02:28:24 +05:30
def from_Laguerre_tessellation(cells,size,seeds,weights,material=None,periodic=True):
2020-03-29 22:42:23 +05:30
"""
2020-12-04 02:28:24 +05:30
Generate grid from Laguerre tessellation.
2020-03-29 22:42:23 +05:30
Parameters
----------
2020-12-04 02:28:24 +05:30
cells : int numpy.ndarray of shape (3)
Number of cells in x,y,z direction.
2020-03-29 22:42:23 +05:30
size : list or numpy.ndarray of shape (3)
2020-12-04 11:42:18 +05:30
Physical size of the grid in meter.
2020-03-29 22:42:23 +05:30
seeds : numpy.ndarray of shape (:,3)
2020-08-08 23:12:34 +05:30
Position of the seed points in meter. All points need to lay within the box.
2020-03-29 22:42:23 +05:30
weights : numpy.ndarray of shape (seeds.shape[0])
2020-08-08 23:12:34 +05:30
Weights of the seeds. Setting all weights to 1.0 gives a standard Voronoi tessellation.
material : numpy.ndarray of shape (seeds.shape[0]), optional
Material ID of the seeds.
Defaults to None, in which case materials are consecutively numbered.
2020-03-29 22:42:23 +05:30
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
2020-03-29 22:42:23 +05:30
Returns
-------
new : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from tessellation.
2020-03-29 22:42:23 +05:30
"""
if periodic:
2020-04-20 23:46:25 +05:30
weights_p = np.tile(weights,27) # Laguerre weights (1,2,3,1,2,3,...,1,2,3)
2020-03-29 22:42:23 +05:30
seeds_p = np.vstack((seeds -np.array([size[0],0.,0.]),seeds, seeds +np.array([size[0],0.,0.])))
seeds_p = np.vstack((seeds_p-np.array([0.,size[1],0.]),seeds_p,seeds_p+np.array([0.,size[1],0.])))
seeds_p = np.vstack((seeds_p-np.array([0.,0.,size[2]]),seeds_p,seeds_p+np.array([0.,0.,size[2]])))
coords = grid_filters.coordinates0_point(cells*3,size*3,-size).reshape(-1,3)
2020-03-29 22:42:23 +05:30
else:
2020-04-20 23:46:25 +05:30
weights_p = weights
2020-03-29 22:42:23 +05:30
seeds_p = seeds
coords = grid_filters.coordinates0_point(cells,size).reshape(-1,3)
2020-03-29 22:42:23 +05:30
pool = mp.Pool(int(os.environ.get('OMP_NUM_THREADS',4)))
2020-12-04 11:42:18 +05:30
result = pool.map_async(partial(Grid._find_closest_seed,seeds_p,weights_p), [coord for coord in coords])
2020-03-29 22:42:23 +05:30
pool.close()
pool.join()
material_ = np.array(result.get())
2020-03-29 22:42:23 +05:30
if periodic:
2020-12-04 02:28:24 +05:30
material_ = material_.reshape(cells*3)
material_ = material_[cells[0]:cells[0]*2,cells[1]:cells[1]*2,cells[2]:cells[2]*2]%seeds.shape[0]
2020-03-29 22:42:23 +05:30
else:
2020-12-04 02:28:24 +05:30
material_ = material_.reshape(cells)
2020-03-29 22:42:23 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material = material_ if material is None else material[material_],
size = size,
2020-12-04 11:42:18 +05:30
comments = util.execution_stamp('Grid','from_Laguerre_tessellation'),
)
2020-03-29 22:42:23 +05:30
@staticmethod
2020-12-04 02:28:24 +05:30
def from_Voronoi_tessellation(cells,size,seeds,material=None,periodic=True):
2020-03-29 22:42:23 +05:30
"""
2020-12-04 02:28:24 +05:30
Generate grid from Voronoi tessellation.
2020-03-29 22:42:23 +05:30
Parameters
----------
2020-12-04 02:28:24 +05:30
cells : int numpy.ndarray of shape (3)
Number of cells in x,y,z direction.
2020-03-29 22:42:23 +05:30
size : list or numpy.ndarray of shape (3)
2020-12-04 11:42:18 +05:30
Physical size of the grid in meter.
2020-03-29 22:42:23 +05:30
seeds : numpy.ndarray of shape (:,3)
2020-08-08 23:12:34 +05:30
Position of the seed points in meter. All points need to lay within the box.
material : numpy.ndarray of shape (seeds.shape[0]), optional
Material ID of the seeds.
Defaults to None, in which case materials are consecutively numbered.
2020-03-29 22:42:23 +05:30
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
2020-03-29 22:42:23 +05:30
Returns
-------
new : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from tessellation.
2020-03-29 22:42:23 +05:30
"""
coords = grid_filters.coordinates0_point(cells,size).reshape(-1,3)
2021-04-29 12:26:40 +05:30
tree = spatial.cKDTree(seeds,boxsize=size) if periodic else \
spatial.cKDTree(seeds)
try:
material_ = tree.query(coords, workers = int(os.environ.get('OMP_NUM_THREADS',4)))[1]
except TypeError:
material_ = tree.query(coords, n_jobs = int(os.environ.get('OMP_NUM_THREADS',4)))[1] # scipy <1.6
2020-03-29 22:42:23 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material = (material_ if material is None else material[material_]).reshape(cells),
size = size,
2020-12-04 11:42:18 +05:30
comments = util.execution_stamp('Grid','from_Voronoi_tessellation'),
)
2020-03-29 22:42:23 +05:30
_minimal_surface = \
{'Schwarz P': lambda x,y,z: np.cos(x) + np.cos(y) + np.cos(z),
'Double Primitive': lambda x,y,z: ( 0.5 * (np.cos(x)*np.cos(y) + np.cos(y)*np.cos(z) + np.cos(z)*np.cos(x))
+ 0.2 * (np.cos(2*x) + np.cos(2*y) + np.cos(2*z)) ),
'Schwarz D': lambda x,y,z: ( np.sin(x)*np.sin(y)*np.sin(z)
+ np.sin(x)*np.cos(y)*np.cos(z)
+ np.cos(x)*np.cos(y)*np.sin(z)
+ np.cos(x)*np.sin(y)*np.cos(z) ),
'Complementary D': lambda x,y,z: ( np.cos(3*x+y)*np.cos(z) - np.sin(3*x-y)*np.sin(z) + np.cos(x+3*y)*np.cos(z)
+ np.sin(x-3*y)*np.sin(z) + np.cos(x-y)*np.cos(3*z) - np.sin(x+y)*np.sin(3*z) ),
'Double Diamond': lambda x,y,z: 0.5 * (np.sin(x)*np.sin(y)
+ np.sin(y)*np.sin(z)
+ np.sin(z)*np.sin(x)
+ np.cos(x) * np.cos(y) * np.cos(z) ),
'Dprime': lambda x,y,z: 0.5 * ( np.cos(x)*np.cos(y)*np.cos(z)
+ np.cos(x)*np.sin(y)*np.sin(z)
+ np.sin(x)*np.cos(y)*np.sin(z)
+ np.sin(x)*np.sin(y)*np.cos(z)
- np.sin(2*x)*np.sin(2*y)
- np.sin(2*y)*np.sin(2*z)
- np.sin(2*z)*np.sin(2*x) ) - 0.2,
'Gyroid': lambda x,y,z: np.cos(x)*np.sin(y) + np.cos(y)*np.sin(z) + np.cos(z)*np.sin(x),
'Gprime': lambda x,y,z : ( np.sin(2*x)*np.cos(y)*np.sin(z)
+ np.sin(2*y)*np.cos(z)*np.sin(x)
+ np.sin(2*z)*np.cos(x)*np.sin(y) ) + 0.32,
'Karcher K': lambda x,y,z: ( 0.3 * ( np.cos(x) + np.cos(y) + np.cos(z)
+ np.cos(x)*np.cos(y) + np.cos(y)*np.cos(z) + np.cos(z)*np.cos(x) )
- 0.4 * ( np.cos(2*x) + np.cos(2*y) + np.cos(2*z) ) ) + 0.2,
'Lidinoid': lambda x,y,z: 0.5 * ( np.sin(2*x)*np.cos(y)*np.sin(z)
+ np.sin(2*y)*np.cos(z)*np.sin(x)
+ np.sin(2*z)*np.cos(x)*np.sin(y)
- np.cos(2*x)*np.cos(2*y)
- np.cos(2*y)*np.cos(2*z)
- np.cos(2*z)*np.cos(2*x) ) + 0.15,
'Neovius': lambda x,y,z: ( 3 * (np.cos(x)+np.cos(y)+np.cos(z))
+ 4 * np.cos(x)*np.cos(y)*np.cos(z) ),
'Fisher-Koch S': lambda x,y,z: ( np.cos(2*x)*np.sin( y)*np.cos( z)
+ np.cos( x)*np.cos(2*y)*np.sin( z)
+ np.sin( x)*np.cos( y)*np.cos(2*z) ),
}
2020-09-30 10:40:15 +05:30
@staticmethod
2020-12-04 02:28:24 +05:30
def from_minimal_surface(cells,size,surface,threshold=0.0,periods=1,materials=(0,1)):
2020-09-30 10:40:15 +05:30
"""
2020-12-04 02:28:24 +05:30
Generate grid from definition of triply periodic minimal surface.
2020-09-30 10:40:15 +05:30
Parameters
----------
2020-12-04 02:28:24 +05:30
cells : int numpy.ndarray of shape (3)
Number of cells in x,y,z direction.
2020-09-30 10:40:15 +05:30
size : list or numpy.ndarray of shape (3)
2020-12-04 11:42:18 +05:30
Physical size of the grid in meter.
surface : str
Type of the minimal surface. See notes for details.
2020-09-30 10:40:15 +05:30
threshold : float, optional.
Threshold of the minimal surface. Defaults to 0.0.
periods : integer, optional.
Number of periods per unit cell. Defaults to 1.
materials : (int, int), optional
Material IDs. Defaults to (1,2).
2020-10-28 14:01:55 +05:30
Returns
-------
new : damask.Grid
2021-04-24 18:17:52 +05:30
Grid-based geometry from definition of minimal surface.
Notes
-----
The following triply-periodic minimal surfaces are implemented:
- Schwarz P
- Double Primitive
- Schwarz D
- Complementary D
- Double Diamond
- Dprime
- Gyroid
- Gprime
- Karcher K
- Lidinoid
- Neovius
- Fisher-Koch S
2020-09-30 10:40:15 +05:30
References
----------
2021-03-18 20:06:40 +05:30
S.B.G. Blanquer et al., Biofabrication 9(2):025001, 2017
https://doi.org/10.1088/1758-5090/aa6553
2021-03-18 20:06:40 +05:30
M. Wohlgemuth et al., Macromolecules 34(17):6083-6089, 2001
https://doi.org/10.1021/ma0019499
2021-03-18 20:06:40 +05:30
M.-T. Hsieh and L. Valdevit, Software Impacts 6:100026, 2020
https://doi.org/10.1016/j.simpa.2020.100026
2020-09-30 10:40:15 +05:30
"""
2020-12-04 02:28:24 +05:30
x,y,z = np.meshgrid(periods*2.0*np.pi*(np.arange(cells[0])+0.5)/cells[0],
periods*2.0*np.pi*(np.arange(cells[1])+0.5)/cells[1],
periods*2.0*np.pi*(np.arange(cells[2])+0.5)/cells[2],
2020-09-30 10:40:15 +05:30
indexing='ij',sparse=True)
2020-12-04 11:42:18 +05:30
return Grid(material = np.where(threshold < Grid._minimal_surface[surface](x,y,z),materials[1],materials[0]),
2020-09-30 10:40:15 +05:30
size = size,
2020-12-04 11:42:18 +05:30
comments = util.execution_stamp('Grid','from_minimal_surface'),
2020-09-30 10:40:15 +05:30
)
def save(self,fname,compress=True):
"""
2020-12-04 02:28:24 +05:30
Save as VTK rectilinear grid file.
Parameters
----------
2020-11-20 00:56:15 +05:30
fname : str or pathlib.Path
Filename to write. Valid extension is .vtr, it will be appended if not given.
compress : bool, optional
Compress with zlib algorithm. Defaults to True.
"""
2020-12-04 02:28:24 +05:30
v = VTK.from_rectilinear_grid(self.cells,self.size,self.origin)
v.add(self.material.flatten(order='F'),'material')
v.add_comments(self.comments)
v.save(fname if str(fname).endswith('.vtr') else str(fname)+'.vtr',parallel=False,compress=compress)
def save_ASCII(self,fname):
2019-11-23 01:22:36 +05:30
"""
2020-12-04 02:28:24 +05:30
Save as geom file.
2019-11-23 01:22:36 +05:30
2020-11-14 22:24:47 +05:30
Storing geometry files in ASCII format is deprecated.
This function will be removed in a future version of DAMASK.
2019-11-23 01:22:36 +05:30
Parameters
----------
fname : str or file handle
Geometry file to write with extension '.geom'.
2020-09-18 20:02:08 +05:30
compress : bool, optional
Compress geometry with 'x of y' and 'a to b'.
2019-11-23 01:22:36 +05:30
"""
warnings.warn('Support for ASCII-based geom format will be removed in DAMASK 3.1.0', DeprecationWarning,2)
header = [f'{len(self.comments)+4} header'] + self.comments \
2020-12-04 02:28:24 +05:30
+ ['grid a {} b {} c {}'.format(*self.cells),
'size x {} y {} z {}'.format(*self.size),
'origin x {} y {} z {}'.format(*self.origin),
'homogenization 1',
]
format_string = '%g' if self.material.dtype in np.sctypes['float'] else \
'%{}i'.format(1+int(np.floor(np.log10(np.nanmax(self.material)))))
np.savetxt(fname,
2020-12-04 02:28:24 +05:30
self.material.reshape([self.cells[0],np.prod(self.cells[1:])],order='F').T,
header='\n'.join(header), fmt=format_string, comments='')
2020-09-18 20:02:08 +05:30
def show(self):
"""Show on screen."""
2020-12-04 02:28:24 +05:30
VTK.from_rectilinear_grid(self.cells,self.size,self.origin).show()
2020-08-08 23:44:30 +05:30
def add_primitive(self,dimension,center,exponent,
fill=None,R=Rotation(),inverse=False,periodic=True):
"""
Insert a primitive geometric object at a given position.
2020-08-08 23:44:30 +05:30
Parameters
----------
dimension : int or float numpy.ndarray of shape (3)
2020-08-08 23:44:30 +05:30
Dimension (diameter/side length) of the primitive. If given as
2020-12-04 02:28:24 +05:30
integers, cell centers are addressed.
2020-08-08 23:44:30 +05:30
If given as floats, coordinates are addressed.
center : int or float numpy.ndarray of shape (3)
2020-12-04 02:28:24 +05:30
Center of the primitive. If given as integers, cell centers are addressed.
If given as floats, coordinates in space are addressed.
exponent : numpy.ndarray of shape (3) or float
2020-09-26 21:32:25 +05:30
Exponents for the three axes.
2020-09-23 19:51:20 +05:30
0 gives octahedron (ǀxǀ^(2^0) + ǀyǀ^(2^0) + ǀzǀ^(2^0) < 1)
2020-09-26 21:32:25 +05:30
1 gives sphere (ǀxǀ^(2^1) + ǀyǀ^(2^1) + ǀzǀ^(2^1) < 1)
2020-08-09 00:26:17 +05:30
fill : int, optional
Fill value for primitive. Defaults to material.max()+1.
2020-08-08 23:44:30 +05:30
R : damask.Rotation, optional
Rotation of primitive. Defaults to no rotation.
inverse : Boolean, optional
Retain original materials within primitive and fill outside.
Defaults to False.
2020-08-08 23:44:30 +05:30
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
2020-08-08 23:44:30 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2020-08-08 23:44:30 +05:30
"""
# radius and center
2020-12-04 02:28:24 +05:30
r = np.array(dimension)/2.0*self.size/self.cells if np.array(dimension).dtype in np.sctypes['int'] else \
np.array(dimension)/2.0
2020-12-04 02:28:24 +05:30
c = (np.array(center) + .5)*self.size/self.cells if np.array(center).dtype in np.sctypes['int'] else \
(np.array(center) - self.origin)
2020-08-08 23:44:30 +05:30
coords = grid_filters.coordinates0_point(self.cells,self.size,
2020-12-04 02:28:24 +05:30
-(0.5*(self.size + (self.size/self.cells
if np.array(center).dtype in np.sctypes['int'] else
0)) if periodic else c))
2020-12-04 02:28:24 +05:30
coords_rot = R.broadcast_to(tuple(self.cells))@coords
2020-08-08 23:44:30 +05:30
2020-08-27 13:02:49 +05:30
with np.errstate(all='ignore'):
mask = np.sum(np.power(coords_rot/r,2.0**np.array(exponent)),axis=-1) > 1.0
2020-08-08 23:44:30 +05:30
if periodic: # translate back to center
2020-12-04 02:28:24 +05:30
mask = np.roll(mask,((c/self.size-0.5)*self.cells).round().astype(int),(0,1,2))
2020-08-08 23:44:30 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material = np.where(np.logical_not(mask) if inverse else mask,
self.material,
np.nanmax(self.material)+1 if fill is None else fill),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','add_primitive')],
)
2020-08-08 23:44:30 +05:30
def mirror(self,directions,reflect=False):
"""
2020-12-04 11:42:18 +05:30
Mirror grid along given directions.
2019-11-24 13:22:46 +05:30
Parameters
----------
directions : iterable containing str
2020-12-04 11:42:18 +05:30
Direction(s) along which the grid is mirrored.
2020-08-08 23:44:30 +05:30
Valid entries are 'x', 'y', 'z'.
reflect : bool, optional
2020-08-25 12:04:04 +05:30
Reflect (include) outermost layers. Defaults to False.
2019-11-24 13:22:46 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
"""
2020-08-25 12:04:04 +05:30
valid = ['x','y','z']
2020-08-23 14:35:56 +05:30
if not set(directions).issubset(valid):
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid direction {set(directions).difference(valid)} specified')
limits = [None,None] if reflect else [-2,0]
mat = self.material.copy()
if 'x' in directions:
mat = np.concatenate([mat,mat[limits[0]:limits[1]:-1,:,:]],0)
if 'y' in directions:
mat = np.concatenate([mat,mat[:,limits[0]:limits[1]:-1,:]],1)
if 'z' in directions:
mat = np.concatenate([mat,mat[:,:,limits[0]:limits[1]:-1]],2)
2020-03-21 15:37:21 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material = mat,
2020-12-04 02:28:24 +05:30
size = self.size/self.cells*np.asarray(mat.shape),
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','mirror')],
)
def flip(self,directions):
"""
2020-12-04 11:42:18 +05:30
Flip grid along given directions.
Parameters
----------
directions : iterable containing str
2020-12-04 11:42:18 +05:30
Direction(s) along which the grid is flipped.
Valid entries are 'x', 'y', 'z'.
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
"""
2020-08-25 12:04:04 +05:30
valid = ['x','y','z']
if not set(directions).issubset(valid):
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid direction {set(directions).difference(valid)} specified')
mat = np.flip(self.material, (valid.index(d) for d in directions if d in valid))
2020-12-04 11:42:18 +05:30
return Grid(material = mat,
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','flip')],
)
2020-12-04 02:28:24 +05:30
def scale(self,cells,periodic=True):
2019-11-24 19:43:26 +05:30
"""
2020-12-04 11:42:18 +05:30
Scale grid to new cells.
2019-11-24 19:43:26 +05:30
Parameters
----------
2020-12-04 02:28:24 +05:30
cells : numpy.ndarray of shape (3)
Number of cells in x,y,z direction.
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
2019-11-24 19:43:26 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2019-11-24 19:43:26 +05:30
"""
2020-12-04 11:42:18 +05:30
return Grid(material = ndimage.interpolation.zoom(
self.material,
2020-12-04 02:28:24 +05:30
cells/self.cells,
output=self.material.dtype,
order=0,
mode=('wrap' if periodic else 'nearest'),
prefilter=False
),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','scale')],
)
2019-11-24 19:43:26 +05:30
def clean(self,stencil=3,selection=None,periodic=True):
"""
2020-12-04 11:42:18 +05:30
Smooth grid by selecting most frequent material index within given stencil at each location.
2019-11-24 13:22:46 +05:30
Parameters
----------
stencil : int, optional
2020-08-08 23:12:34 +05:30
Size of smoothing stencil.
selection : list, optional
Field values that can be altered. Defaults to all.
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
"""
def mostFrequent(arr,selection=None):
me = arr[arr.size//2]
if selection is None or me in selection:
unique, inverse = np.unique(arr, return_inverse=True)
return unique[np.argmax(np.bincount(inverse))]
else:
return me
2020-12-04 11:42:18 +05:30
return Grid(material = ndimage.filters.generic_filter(
self.material,
mostFrequent,
size=(stencil if selection is None else stencil//2*2+1,)*3,
mode=('wrap' if periodic else 'nearest'),
extra_keywords=dict(selection=selection),
).astype(self.material.dtype),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','clean')],
)
2019-11-24 22:51:05 +05:30
def renumber(self):
"""
Renumber sorted material indices as 0,...,N-1.
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
"""
2020-10-28 14:13:20 +05:30
_,renumbered = np.unique(self.material,return_inverse=True)
2020-12-04 11:42:18 +05:30
return Grid(material = renumbered.reshape(self.cells),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','renumber')],
)
2020-05-24 12:36:42 +05:30
def rotate(self,R,fill=None):
2020-05-30 21:01:50 +05:30
"""
2020-12-04 11:42:18 +05:30
Rotate grid (pad if required).
2020-05-30 21:01:50 +05:30
Parameters
----------
R : damask.Rotation
2020-12-04 11:42:18 +05:30
Rotation to apply to the grid.
2020-05-30 21:01:50 +05:30
fill : int or float, optional
Material index to fill the corners. Defaults to material.max() + 1.
2020-05-30 21:01:50 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2020-05-30 21:01:50 +05:30
"""
if fill is None: fill = np.nanmax(self.material) + 1
dtype = float if isinstance(fill,float) or self.material.dtype in np.sctypes['float'] else int
2020-05-24 12:36:42 +05:30
2021-01-13 16:03:28 +05:30
material = self.material
2020-05-24 12:36:42 +05:30
# These rotations are always applied in the reference coordinate system, i.e. (z,x,z) not (z,x',z'')
2020-05-24 22:00:45 +05:30
# see https://www.cs.utexas.edu/~theshark/courses/cs354/lectures/cs354-14.pdf
2021-01-13 16:03:28 +05:30
for angle,axes in zip(R.as_Euler_angles(degrees=True)[::-1], [(0,1),(1,2),(0,1)]):
material_temp = ndimage.rotate(material,angle,axes,order=0,prefilter=False,output=dtype,cval=fill)
# avoid scipy interpolation errors for rotations close to multiples of 90°
material = material_temp if np.prod(material_temp.shape) != np.prod(material.shape) else \
np.rot90(material,k=np.rint(angle/90.).astype(int),axes=axes)
2020-05-24 12:36:42 +05:30
2021-01-13 16:03:28 +05:30
origin = self.origin-(np.asarray(material.shape)-self.cells)*.5 * self.size/self.cells
2020-05-24 12:36:42 +05:30
2021-01-13 16:03:28 +05:30
return Grid(material = material,
size = self.size/self.cells*np.asarray(material.shape),
origin = origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','rotate')],
)
2020-05-24 12:36:42 +05:30
2020-12-04 02:28:24 +05:30
def canvas(self,cells=None,offset=None,fill=None):
2020-05-30 21:01:50 +05:30
"""
2020-12-04 11:42:18 +05:30
Crop or enlarge/pad grid.
2020-05-30 21:01:50 +05:30
Parameters
----------
2020-12-04 02:28:24 +05:30
cells : numpy.ndarray of shape (3)
Number of cells x,y,z direction.
2020-05-30 21:01:50 +05:30
offset : numpy.ndarray of shape (3)
2020-12-04 11:42:18 +05:30
Offset (measured in cells) from old to new grid [0,0,0].
2020-05-30 21:01:50 +05:30
fill : int or float, optional
Material index to fill the background. Defaults to material.max() + 1.
2020-05-30 21:01:50 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2020-05-30 21:01:50 +05:30
"""
2020-05-25 02:22:00 +05:30
if offset is None: offset = 0
if fill is None: fill = np.nanmax(self.material) + 1
dtype = float if int(fill) != fill or self.material.dtype in np.sctypes['float'] else int
2020-05-24 12:36:42 +05:30
2020-12-04 02:28:24 +05:30
canvas = np.full(self.cells if cells is None else cells,fill,dtype)
2020-05-24 12:36:42 +05:30
2020-12-04 02:28:24 +05:30
LL = np.clip( offset, 0,np.minimum(self.cells, cells+offset))
UR = np.clip( offset+cells, 0,np.minimum(self.cells, cells+offset))
ll = np.clip(-offset, 0,np.minimum( cells,self.cells-offset))
ur = np.clip(-offset+self.cells,0,np.minimum( cells,self.cells-offset))
2020-05-24 12:36:42 +05:30
canvas[ll[0]:ur[0],ll[1]:ur[1],ll[2]:ur[2]] = self.material[LL[0]:UR[0],LL[1]:UR[1],LL[2]:UR[2]]
2020-05-24 12:36:42 +05:30
2020-12-04 11:42:18 +05:30
return Grid(material = canvas,
2020-12-04 02:28:24 +05:30
size = self.size/self.cells*np.asarray(canvas.shape),
origin = self.origin+offset*self.size/self.cells,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','canvas')],
)
2020-05-24 12:36:42 +05:30
def substitute(self,from_material,to_material):
2020-05-30 21:01:50 +05:30
"""
Substitute material indices.
2020-05-30 21:01:50 +05:30
Parameters
----------
from_material : iterable of ints
Material indices to be substituted.
to_material : iterable of ints
New material indices.
2020-05-30 21:01:50 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2020-05-30 21:01:50 +05:30
"""
2020-10-29 02:21:20 +05:30
def mp(entry,mapper):
return mapper[entry] if entry in mapper else entry
2020-05-24 12:36:42 +05:30
mp = np.vectorize(mp)
2020-10-29 02:21:20 +05:30
mapper = dict(zip(from_material,to_material))
2020-12-04 11:42:18 +05:30
return Grid(material = mp(self.material,mapper).reshape(self.cells),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','substitute')],
)
2020-08-08 23:12:34 +05:30
def sort(self):
"""
Sort material indices such that min(material) is located at (0,0,0).
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
"""
a = self.material.flatten(order='F')
from_ma = pd.unique(a)
sort_idx = np.argsort(from_ma)
ma = np.unique(a)[sort_idx][np.searchsorted(from_ma,a,sorter = sort_idx)]
2020-12-04 11:42:18 +05:30
return Grid(material = ma.reshape(self.cells,order='F'),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','sort')],
)
2020-08-08 23:12:34 +05:30
def vicinity_offset(self,vicinity=1,offset=None,trigger=[],periodic=True):
"""
Offset material index of points in the vicinity of xxx.
2020-08-08 23:12:34 +05:30
Different from themselves (or listed as triggers) within a given (cubic) vicinity,
i.e. within the region close to a grain/phase boundary.
2020-12-04 11:42:18 +05:30
ToDo: use include/exclude as in seeds.from_grid
2020-08-08 23:12:34 +05:30
Parameters
----------
vicinity : int, optional
Voxel distance checked for presence of other materials.
2020-08-08 23:12:34 +05:30
Defaults to 1.
offset : int, optional
Offset (positive or negative) to tag material indices,
defaults to material.max()+1.
2020-08-08 23:12:34 +05:30
trigger : list of ints, optional
List of material indices that trigger a change.
Defaults to [], meaning that any different neighbor triggers a change.
2020-08-08 23:12:34 +05:30
periodic : Boolean, optional
2020-12-04 11:42:18 +05:30
Assume grid to be periodic. Defaults to True.
2020-08-08 23:12:34 +05:30
Returns
-------
updated : damask.Grid
2021-04-24 18:17:52 +05:30
Updated grid-based geometry.
2020-08-08 23:12:34 +05:30
"""
def tainted_neighborhood(stencil,trigger):
me = stencil[stencil.shape[0]//2]
return np.any(stencil != me if len(trigger) == 0 else
2020-11-03 04:50:52 +05:30
np.in1d(stencil,np.array(list(set(trigger) - {me}))))
2020-08-08 23:12:34 +05:30
offset_ = np.nanmax(self.material)+1 if offset is None else offset
mask = ndimage.filters.generic_filter(self.material,
2020-08-08 23:12:34 +05:30
tainted_neighborhood,
size=1+2*vicinity,
mode='wrap' if periodic else 'nearest',
2020-08-08 23:12:34 +05:30
extra_keywords={'trigger':trigger})
2020-12-04 11:42:18 +05:30
return Grid(material = np.where(mask, self.material + offset_,self.material),
size = self.size,
origin = self.origin,
2020-12-04 11:42:18 +05:30
comments = self.comments+[util.execution_stamp('Grid','vicinity_offset')],
)
2020-11-28 00:46:06 +05:30
def get_grain_boundaries(self,periodic=True,directions='xyz'):
2020-11-18 16:55:08 +05:30
"""
2020-11-28 00:46:06 +05:30
Create VTK unstructured grid containing grain boundaries.
2020-11-18 16:44:12 +05:30
Parameters
----------
2020-12-04 11:42:18 +05:30
periodic : Boolean, optional
Assume grid to be periodic. Defaults to True.
directions : iterable containing str, optional
2020-12-04 11:42:18 +05:30
Direction(s) along which the boundaries are determined.
Valid entries are 'x', 'y', 'z'. Defaults to 'xyz'.
2020-11-18 16:44:12 +05:30
2021-04-25 11:17:00 +05:30
Returns
-------
grain_boundaries : damask.VTK
VTK-based geometry of grain boundary network.
2020-11-18 16:44:12 +05:30
"""
valid = ['x','y','z']
if not set(directions).issubset(valid):
2020-12-11 01:23:11 +05:30
raise ValueError(f'invalid direction {set(directions).difference(valid)} specified')
2020-11-19 00:40:04 +05:30
2020-12-04 02:28:24 +05:30
o = [[0, self.cells[0]+1, np.prod(self.cells[:2]+1)+self.cells[0]+1, np.prod(self.cells[:2]+1)],
[0, np.prod(self.cells[:2]+1), np.prod(self.cells[:2]+1)+1, 1],
[0, 1, self.cells[0]+1+1, self.cells[0]+1]] # offset for connectivity
2020-11-28 00:46:06 +05:30
connectivity = []
for i,d in enumerate(['x','y','z']):
if d not in directions: continue
2020-11-28 00:46:06 +05:30
mask = self.material != np.roll(self.material,1,i)
for j in [0,1,2]:
mask = np.concatenate((mask,np.take(mask,[0],j)*(i==j)),j)
if i == 0 and not periodic: mask[0,:,:] = mask[-1,:,:] = False
if i == 1 and not periodic: mask[:,0,:] = mask[:,-1,:] = False
if i == 2 and not periodic: mask[:,:,0] = mask[:,:,-1] = False
2020-11-28 00:46:06 +05:30
base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1)
connectivity.append(np.block([base_nodes + o[i][k] for k in range(4)]))
coords = grid_filters.coordinates0_node(self.cells,self.size,self.origin).reshape(-1,3,order='F')
return VTK.from_unstructured_grid(coords,np.vstack(connectivity),'QUAD')