DAMASK_EICMD/python/tests/test_GeomGrid.py

516 lines
24 KiB
Python
Raw Normal View History

2022-03-27 02:38:09 +05:30
import sys
2019-11-23 17:29:41 +05:30
import pytest
import numpy as np
from vtkmodules.vtkCommonCore import vtkVersion
2019-11-23 17:29:41 +05:30
from damask import VTK
2023-11-28 03:11:28 +05:30
from damask import GeomGrid
2020-10-29 12:12:41 +05:30
from damask import Table
from damask import Rotation
from damask import Colormap
2020-06-25 01:04:51 +05:30
from damask import util
from damask import seeds
2020-10-29 12:12:41 +05:30
from damask import grid_filters
2019-11-23 17:29:41 +05:30
@pytest.fixture
def default():
"""Simple geometry."""
g = np.array([8,5,4])
l = np.prod(g[:2])
2023-11-28 03:11:28 +05:30
return GeomGrid(np.concatenate((np.ones (l,dtype=int),
np.arange(l,dtype=int)+2,
np.ones (l,dtype=int)*2,
np.arange(l,dtype=int)+1)).reshape(g,order='F'),
g*1e-6)
2019-11-23 17:29:41 +05:30
2022-03-04 15:09:02 +05:30
@pytest.fixture
def random():
"""Simple geometry."""
size = (1+np.random.rand(3))*1e-5
cells = np.random.randint(10,20,3)
s = seeds.from_random(size,np.random.randint(5,25),cells)
2023-11-28 03:11:28 +05:30
return GeomGrid.from_Voronoi_tessellation(cells,size,s)
2022-03-04 15:09:02 +05:30
2019-11-23 17:29:41 +05:30
@pytest.fixture
def res_path(res_path_base):
"""Directory containing testing resources."""
2023-11-28 03:11:28 +05:30
return res_path_base/'GeomGrid'
2019-11-23 17:29:41 +05:30
2023-11-28 03:11:28 +05:30
class TestGeomGrid:
2020-03-29 23:37:09 +05:30
@pytest.fixture(autouse=True)
def _patch_execution_stamp(self, patch_execution_stamp):
print('patched damask.util.execution_stamp')
@pytest.fixture(autouse=True)
def _patch_datetime_now(self, patch_datetime_now):
print('patched datetime.datetime.now')
2020-08-25 04:29:41 +05:30
@pytest.mark.parametrize('cmap',[Colormap.from_predefined('stress'),'viridis'])
2022-03-27 02:38:09 +05:30
@pytest.mark.skipif(sys.platform == 'win32', reason='DISPLAY has no effect on windows')
def test_show(sef,default,cmap,monkeypatch):
2022-02-22 18:30:36 +05:30
monkeypatch.delenv('DISPLAY',raising=False)
default.show(cmap)
2022-02-22 18:30:36 +05:30
def test_equal(self,default):
assert default == default
assert not default == 42
2020-08-25 04:29:41 +05:30
2020-11-14 22:24:47 +05:30
def test_repr(self,default):
print(default)
2019-11-23 17:29:41 +05:30
def test_read_write_vti(self,default,tmp_path):
2020-09-29 22:55:50 +05:30
default.save(tmp_path/'default')
2023-11-28 03:11:28 +05:30
new = GeomGrid.load(tmp_path/'default.vti')
assert new == default
2020-12-11 01:23:11 +05:30
def test_invalid_no_material(self,tmp_path):
v = VTK.from_image_data(np.random.randint(5,10,3)*2,np.random.random(3) + 1.0)
v.save(tmp_path/'no_materialpoint.vti',parallel=False)
2022-03-07 15:58:17 +05:30
with pytest.raises(KeyError):
2023-11-28 03:11:28 +05:30
GeomGrid.load(tmp_path/'no_materialpoint.vti')
2020-12-11 01:23:11 +05:30
def test_invalid_material_type(self):
2020-09-25 02:29:31 +05:30
with pytest.raises(TypeError):
2023-11-28 03:11:28 +05:30
GeomGrid(np.zeros((3,3,3),dtype='complex'),np.ones(3))
2020-09-25 02:29:31 +05:30
def test_cast_to_int(self):
2023-11-28 03:11:28 +05:30
g = GeomGrid(np.zeros((3,3,3)),np.ones(3))
2020-09-25 02:29:31 +05:30
assert g.material.dtype in np.sctypes['int']
2020-08-09 00:05:50 +05:30
2020-05-25 02:22:00 +05:30
def test_invalid_size(self,default):
with pytest.raises(ValueError):
2023-11-28 03:11:28 +05:30
GeomGrid(default.material[1:,1:,1:],
size=np.ones(2))
2020-11-14 22:24:47 +05:30
def test_save_load_ASCII(self,default,tmp_path):
default.save_ASCII(tmp_path/'ASCII')
default.material -= 1
2023-11-28 03:11:28 +05:30
assert GeomGrid.load_ASCII(tmp_path/'ASCII') == default
2020-05-25 02:22:00 +05:30
def test_save_load_SPPARKS(self,res_path,tmp_path):
v = VTK.load(res_path/'SPPARKS_dump.vti')
v.set('material',v.get('Spin')).delete('Spin').save(tmp_path/'SPPARKS_dump.vti',parallel=False)
assert GeomGrid.load_SPPARKS(res_path/'SPPARKS_dump.vti') == \
GeomGrid.load(tmp_path/'SPPARKS_dump.vti')
2020-08-08 23:12:34 +05:30
def test_invalid_origin(self,default):
2020-05-25 02:22:00 +05:30
with pytest.raises(ValueError):
2023-11-28 03:11:28 +05:30
GeomGrid(default.material[1:,1:,1:],
size=np.ones(3),
origin=np.ones(4))
def test_invalid_materials_shape(self,default):
material = np.ones((3,3))
2020-08-08 23:12:34 +05:30
with pytest.raises(ValueError):
2023-11-28 03:11:28 +05:30
GeomGrid(material,
size=np.ones(3))
2020-08-08 23:12:34 +05:30
def test_invalid_materials_type(self,default):
material = np.random.randint(1,300,(3,4,5))==1
2020-05-25 02:22:00 +05:30
with pytest.raises(TypeError):
2023-11-28 03:11:28 +05:30
GeomGrid(material)
@pytest.mark.parametrize('directions,reflect',[
2019-11-25 18:31:40 +05:30
(['x'], False),
(['x','y','z'],True),
(['z','x','y'],False),
(['y','z'], False)
]
)
def test_mirror(self,default,update,res_path,directions,reflect):
modified = default.mirror(directions,reflect)
tag = f'directions_{"-".join(directions)}+reflect_{reflect}'
reference = res_path/f'mirror_{tag}.vti'
if update: modified.save(reference)
2023-11-28 03:11:28 +05:30
assert GeomGrid.load(reference) == modified
2020-08-23 14:35:56 +05:30
@pytest.mark.parametrize('directions',[(1,2,'y'),('a','b','x'),[1]])
def test_mirror_invalid(self,default,directions):
with pytest.raises(ValueError):
default.mirror(directions)
2023-02-21 20:57:06 +05:30
@pytest.mark.parametrize('reflect',[True,False])
def test_mirror_order_invariant(self,default,reflect):
direction = np.array(['x','y','z'])
assert default.mirror(np.random.permutation(direction),reflect=reflect) \
== default.mirror(np.random.permutation(direction),reflect=reflect)
2020-08-25 04:29:41 +05:30
@pytest.mark.parametrize('directions',[
['x'],
['x','y','z'],
['z','x','y'],
['y','z'],
]
)
def test_flip(self,default,update,res_path,directions):
modified = default.flip(directions)
tag = f'directions_{"-".join(directions)}'
reference = res_path/f'flip_{tag}.vti'
if update: modified.save(reference)
2023-11-28 03:11:28 +05:30
assert GeomGrid.load(reference) == modified
2023-02-21 20:57:06 +05:30
def test_flip_order_invariant(self,default):
direction = np.array(['x','y','z'])
assert default.flip(np.random.permutation(direction)) \
== default.flip(np.random.permutation(direction))
2023-02-21 20:57:06 +05:30
def test_flip_mirrored_invariant(self,default):
direction = np.random.permutation(['x','y','z'])
assert default.mirror(direction,True) == default.mirror(direction,True).flip(direction)
2020-08-25 12:04:04 +05:30
2023-02-21 20:57:06 +05:30
def test_flip_equal_halfspin(self,default):
direction = ['x','y','z']
i = np.random.choice(3)
assert default.rotate(Rotation.from_axis_angle(np.hstack((np.identity(3)[i],180)),degrees=True)) \
== default.flip(direction[:i]+direction[i+1:])
2020-08-25 20:47:49 +05:30
@pytest.mark.parametrize('direction',[['x'],['x','y']])
def test_flip_double(self,default,direction):
assert default == default.flip(direction).flip(direction)
2020-08-25 20:47:49 +05:30
2020-08-23 14:35:56 +05:30
@pytest.mark.parametrize('directions',[(1,2,'y'),('a','b','x'),[1]])
2020-08-25 04:29:41 +05:30
def test_flip_invalid(self,default,directions):
2020-08-23 14:35:56 +05:30
with pytest.raises(ValueError):
2020-08-25 04:29:41 +05:30
default.flip(directions)
@pytest.mark.parametrize('distance',[1.,np.sqrt(3)])
@pytest.mark.parametrize('selection',[None,1,[1],[1,2,3]])
@pytest.mark.parametrize('periodic',[True,False])
def test_clean_reference(self,default,update,res_path,distance,selection,periodic):
current = default.clean(distance,selection,periodic=periodic,rng_seed=0)
reference = res_path/f'clean_{distance}_{util.srepr(selection,"+")}_{periodic}.vti'
if update:
current.save(reference)
2023-11-28 03:11:28 +05:30
assert GeomGrid.load(reference) == current
2019-11-25 18:31:40 +05:30
@pytest.mark.parametrize('selection',[list(np.random.randint(1,20,6)),np.random.randint(1,20,6)])
2022-03-04 15:09:02 +05:30
@pytest.mark.parametrize('invert',[True,False])
def test_clean_invert(self,default,selection,invert):
selection_inverse = np.setdiff1d(default.material,selection)
assert default.clean(selection=selection,invert_selection=invert,rng_seed=0) == \
default.clean(selection=selection_inverse,invert_selection=not invert,rng_seed=0)
def test_clean_selection_empty(self,random):
assert random.clean(selection=None,invert_selection=True,rng_seed=0) == random.clean(rng_seed=0) and \
random.clean(selection=None,invert_selection=False,rng_seed=0) == random.clean(rng_seed=0)
2020-12-04 02:28:24 +05:30
@pytest.mark.parametrize('cells',[
2020-03-31 14:35:25 +05:30
(10,11,10),
[10,13,10],
np.array((10,10,10)),
np.array((8, 10,12)),
np.array((5, 4, 20)),
np.array((10,20,2))
2019-11-25 18:31:40 +05:30
]
)
def test_scale(self,default,update,res_path,cells):
2020-12-04 02:28:24 +05:30
modified = default.scale(cells)
tag = f'grid_{util.srepr(cells,"-")}'
reference = res_path/f'scale_{tag}.vti'
if update: modified.save(reference)
2023-11-28 03:11:28 +05:30
assert GeomGrid.load(reference) == modified
2020-03-29 22:42:23 +05:30
def test_renumber(self,default):
material = default.material.copy()
for m in np.unique(material):
material[material==m] = material.max() + np.random.randint(1,30)
2020-10-28 14:01:55 +05:30
default.material -= 1
2023-11-28 03:11:28 +05:30
modified = GeomGrid(material,
default.size,
default.origin)
assert not default == modified
assert default == modified.renumber()
2022-11-09 00:22:08 +05:30
def test_assemble(self):
cells = np.random.randint(8,16,3)
N = cells.prod()
2023-11-28 03:11:28 +05:30
g = GeomGrid(np.arange(N).reshape(cells),np.ones(3))
2022-11-09 00:22:08 +05:30
idx = np.random.randint(0,N,N).reshape(cells)
assert (idx == g.assemble(idx).material).all
def test_substitute(self,default):
offset = np.random.randint(1,500)
2023-11-28 03:11:28 +05:30
modified = GeomGrid(default.material + offset,
default.size,
default.origin)
assert not default == modified
assert default == modified.substitute(np.arange(default.material.max())+1+offset,
np.arange(default.material.max())+1)
2022-03-04 15:09:02 +05:30
def test_substitute_integer_list(self,random):
f = np.random.randint(30)
t = np.random.randint(30)
assert random.substitute(f,t) == random.substitute([f],[t])
def test_substitute_invariant(self,default):
f = np.unique(default.material.flatten())[:np.random.randint(1,default.material.max())]
t = np.random.permutation(f)
modified = default.substitute(f,t)
assert np.array_equiv(t,f) or modified != default
assert default == modified.substitute(t,f)
def test_sort(self):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(5,20,3)
2023-11-28 03:11:28 +05:30
m = GeomGrid(np.random.randint(1,20,cells)*3,np.ones(3)).sort().material.flatten(order='F')
for i,v in enumerate(m):
2020-11-03 05:01:37 +05:30
assert i==0 or v > m[:i].max() or v in m[:i]
@pytest.mark.parametrize('axis_angle',[np.array([1,0,0,86.7]), np.array([0,1,0,90.4]), np.array([0,0,1,90]),
np.array([1,0,0,175]),np.array([0,-1,0,178]),np.array([0,0,1,180])])
2020-05-25 02:22:00 +05:30
def test_rotate360(self,default,axis_angle):
2020-08-22 23:25:18 +05:30
modified = default.copy()
for i in range(np.rint(360/axis_angle[3]).astype(int)):
modified.rotate(Rotation.from_axis_angle(axis_angle,degrees=True))
assert default == modified
@pytest.mark.parametrize('Eulers',[[32.0,68.0,21.0],
[0.0,32.0,240.0]])
def test_rotate(self,default,update,res_path,Eulers):
2020-11-18 03:26:22 +05:30
modified = default.rotate(Rotation.from_Euler_angles(Eulers,degrees=True))
tag = f'Eulers_{util.srepr(Eulers,"-")}'
reference = res_path/f'rotate_{tag}.vti'
if update: modified.save(reference)
2023-11-28 03:11:28 +05:30
assert GeomGrid.load(reference) == modified
2022-01-13 01:04:29 +05:30
def test_canvas_extend(self,default):
2020-12-04 02:28:24 +05:30
cells = default.cells
2022-01-13 01:04:29 +05:30
cells_add = np.random.randint(0,30,(3))
modified = default.canvas(cells + cells_add)
2020-12-04 02:28:24 +05:30
assert np.all(modified.material[:cells[0],:cells[1],:cells[2]] == default.material)
2022-01-13 01:04:29 +05:30
@pytest.mark.parametrize('sign',[+1,-1])
@pytest.mark.parametrize('extra_offset',[0,-1])
def test_canvas_move_out(self,sign,extra_offset):
2023-11-28 03:11:28 +05:30
g = GeomGrid(np.zeros(np.random.randint(3,30,(3)),int),np.ones(3))
2022-01-13 01:04:29 +05:30
o = sign*np.ones(3)*g.cells.min() +extra_offset*sign
if extra_offset == 0:
assert np.all(g.canvas(offset=o).material == 1)
else:
assert np.all(np.unique(g.canvas(offset=o).material) == (0,1))
def test_canvas_cells(self,default):
2023-11-28 03:11:28 +05:30
g = GeomGrid(np.zeros(np.random.randint(3,30,(3)),int),np.ones(3))
2022-01-13 01:04:29 +05:30
cells = np.random.randint(1,30,(3))
offset = np.random.randint(-30,30,(3))
assert np.all(g.canvas(cells,offset).cells == cells)
2020-08-09 00:05:50 +05:30
@pytest.mark.parametrize('center1,center2',[(np.random.random(3)*.5,np.random.random()*8),
2020-08-10 02:44:32 +05:30
(np.random.randint(4,8,(3)),np.random.randint(9,12,(3)))])
2020-08-22 23:25:18 +05:30
@pytest.mark.parametrize('diameter',[np.random.random(3)*.5,
np.random.randint(4,10,(3)),
np.random.rand(),
np.random.randint(30)])
@pytest.mark.parametrize('exponent',[np.random.random(3)*.5,
np.random.randint(4,10,(3)),
np.random.rand()*4,
np.random.randint(20)])
def test_add_primitive_shift(self,center1,center2,diameter,exponent):
"""Same volume fraction for periodic geometries and different center."""
2020-08-22 23:25:18 +05:30
o = np.random.random(3)-.5
g = np.random.randint(8,32,(3))
s = np.random.random(3)+.5
2023-11-28 03:11:28 +05:30
G_1 = GeomGrid(np.ones(g,'i'),s,o).add_primitive(diameter,center1,exponent)
G_2 = GeomGrid(np.ones(g,'i'),s,o).add_primitive(diameter,center2,exponent)
assert np.count_nonzero(G_1.material!=2) == np.count_nonzero(G_2.material!=2)
@pytest.mark.parametrize('center',[np.random.randint(4,10,(3)),
np.random.randint(2,10),
np.random.rand()*4,
np.random.rand(3)*10])
@pytest.mark.parametrize('inverse',[True,False])
@pytest.mark.parametrize('periodic',[True,False])
def test_add_primitive_rotation(self,center,inverse,periodic):
2020-11-13 11:20:57 +05:30
"""Rotation should not change result for sphere."""
g = np.random.randint(8,32,(3))
s = np.random.random(3)+.5
fill = np.random.randint(10)+2
2023-11-28 03:11:28 +05:30
G_1 = GeomGrid(np.ones(g,'i'),s).add_primitive(.3,center,1,fill,inverse=inverse,periodic=periodic)
G_2 = GeomGrid(np.ones(g,'i'),s).add_primitive(.3,center,1,fill,Rotation.from_random(),inverse,periodic=periodic)
assert G_1 == G_2
2022-08-29 17:14:50 +05:30
@pytest.mark.parametrize('exponent',[1,np.inf,np.random.random(3)*2.])
def test_add_primitive_shape_symmetry(self,exponent):
"""Shapes defined in the center should always produce a grid with reflection symmetry along the coordinate axis."""
o = np.random.random(3)-.5
s = np.random.random(3)*5.
2023-11-28 03:11:28 +05:30
grid = GeomGrid(np.zeros(np.random.randint(8,32,3),'i'),s,o).add_primitive(np.random.random(3)*3.,o+s/2.,exponent)
2022-08-29 17:14:50 +05:30
for axis in [0,1,2]:
assert np.all(grid.material==np.flip(grid.material,axis=axis))
@pytest.mark.parametrize('selection',[1,None])
def test_vicinity_offset(self,selection):
2020-08-08 23:12:34 +05:30
offset = np.random.randint(2,4)
distance = np.random.randint(2,4)
2020-08-09 00:05:50 +05:30
2020-08-10 02:44:32 +05:30
g = np.random.randint(28,40,(3))
m = np.ones(g,'i')
x = (g*np.random.permutation(np.array([.5,1,1]))).astype(int)
2020-08-10 02:44:32 +05:30
m[slice(0,x[0]),slice(0,x[1]),slice(0,x[2])] = 2
2020-08-22 23:25:18 +05:30
m2 = m.copy()
2020-08-08 23:12:34 +05:30
for i in [0,1,2]:
m2[(np.roll(m,+distance,i)-m)!=0] += offset
m2[(np.roll(m,-distance,i)-m)!=0] += offset
2022-03-04 15:09:02 +05:30
if selection == 1:
2020-08-10 02:44:32 +05:30
m2[m==1] = 1
2020-08-09 00:05:50 +05:30
2023-11-28 03:11:28 +05:30
grid = GeomGrid(m,np.random.rand(3)).vicinity_offset(distance,offset,selection=selection)
2020-08-09 00:05:50 +05:30
2020-12-04 11:42:18 +05:30
assert np.all(m2==grid.material)
@pytest.mark.parametrize('selection',[list(np.random.randint(1,20,6)),np.random.randint(1,20,6)])
2022-03-04 15:09:02 +05:30
@pytest.mark.parametrize('invert',[True,False])
def test_vicinity_offset_invert(self,random,selection,invert):
selection_inverse = np.setdiff1d(random.material,selection)
assert random.vicinity_offset(selection=selection ,invert_selection=not invert) == \
random.vicinity_offset(selection=selection_inverse,invert_selection= invert)
2022-03-04 15:09:02 +05:30
def test_vicinity_offset_selection_empty(self,random):
2022-03-10 05:31:45 +05:30
assert random.vicinity_offset(selection=None,invert_selection=False) == random.vicinity_offset() and \
random.vicinity_offset(selection=None,invert_selection=True ) == random.vicinity_offset()
2020-08-08 23:12:34 +05:30
@pytest.mark.parametrize('periodic',[True,False])
def test_vicinity_offset_invariant(self,default,periodic):
offset = default.vicinity_offset(selection=[default.material.max()+1,
2022-03-04 15:09:02 +05:30
default.material.min()-1])
assert np.all(offset.material==default.material)
2020-03-31 14:35:25 +05:30
@pytest.mark.parametrize('periodic',[True,False])
2020-03-29 23:58:54 +05:30
def test_tessellation_approaches(self,periodic):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(10,20,3)
2020-03-29 22:42:23 +05:30
size = np.random.random(3) + 1.0
N_seeds= np.random.randint(10,30)
seeds = np.random.rand(N_seeds,3) * np.broadcast_to(size,(N_seeds,3))
2023-11-28 03:11:28 +05:30
Voronoi = GeomGrid.from_Voronoi_tessellation( cells,size,seeds, np.arange(N_seeds)+5,periodic)
Laguerre = GeomGrid.from_Laguerre_tessellation(cells,size,seeds,np.ones(N_seeds),np.arange(N_seeds)+5,periodic)
assert Laguerre == Voronoi
2020-03-29 22:42:23 +05:30
2020-03-29 23:58:54 +05:30
def test_Laguerre_weights(self):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(10,20,3)
2020-03-29 22:42:23 +05:30
size = np.random.random(3) + 1.0
N_seeds= np.random.randint(10,30)
seeds = np.random.rand(N_seeds,3) * np.broadcast_to(size,(N_seeds,3))
weights= np.full((N_seeds),-np.inf)
2020-10-10 13:27:18 +05:30
ms = np.random.randint(N_seeds)
weights[ms] = np.random.random()
2023-11-28 03:11:28 +05:30
Laguerre = GeomGrid.from_Laguerre_tessellation(cells,size,seeds,weights,periodic=np.random.random()>0.5)
assert np.all(Laguerre.material == ms)
2020-03-31 14:35:25 +05:30
@pytest.mark.parametrize('approach',['Laguerre','Voronoi'])
2020-03-29 23:58:54 +05:30
def test_tessellate_bicrystal(self,approach):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(5,10,3)*2
2021-02-22 13:05:15 +05:30
size = cells.astype(float)
2020-03-29 23:58:54 +05:30
seeds = np.vstack((size*np.array([0.5,0.25,0.5]),size*np.array([0.5,0.75,0.5])))
2020-12-04 02:28:24 +05:30
material = np.zeros(cells)
material[:,cells[1]//2:,:] = 1
2020-03-29 23:58:54 +05:30
if approach == 'Laguerre':
2023-11-28 03:11:28 +05:30
grid = GeomGrid.from_Laguerre_tessellation(cells,size,seeds,np.ones(2),periodic=np.random.random()>0.5)
2020-03-29 23:58:54 +05:30
elif approach == 'Voronoi':
2023-11-28 03:11:28 +05:30
grid = GeomGrid.from_Voronoi_tessellation(cells,size,seeds, periodic=np.random.random()>0.5)
2020-12-04 11:42:18 +05:30
assert np.all(grid.material == material)
2020-09-30 10:40:15 +05:30
@pytest.mark.parametrize('surface',['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
def test_minimal_surface_basic_properties(self,surface):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(60,100,3)
size = np.ones(3)+np.random.rand(3)
threshold = 2*np.random.rand()-1.
2020-09-30 10:40:15 +05:30
periods = np.random.randint(2)+1
materials = np.random.randint(0,40,2)
2023-11-28 03:11:28 +05:30
grid = GeomGrid.from_minimal_surface(cells,size,surface,threshold,periods,materials)
2020-12-04 11:42:18 +05:30
assert set(grid.material.flatten()) | set(materials) == set(materials) \
and (grid.size == size).all() and (grid.cells == cells).all()
2020-09-30 10:40:15 +05:30
@pytest.mark.parametrize('surface,threshold',[('Schwarz P',0),
('Double Primitive',-1./6.),
('Schwarz D',0),
('Complementary D',0),
('Double Diamond',-0.133),
('Dprime',-0.0395),
('Gyroid',0),
('Gprime',0.22913),
('Karcher K',0.17045),
('Lidinoid',0.14455),
('Neovius',0),
('Fisher-Koch S',0),
])
def test_minimal_surface_volume(self,surface,threshold):
2020-12-04 02:28:24 +05:30
cells = np.ones(3,dtype=int)*64
2023-11-28 03:11:28 +05:30
grid = GeomGrid.from_minimal_surface(cells,np.ones(3),surface,threshold)
2020-12-04 11:42:18 +05:30
assert np.isclose(np.count_nonzero(grid.material==1)/np.prod(grid.cells),.5,rtol=1e-3)
2020-11-25 17:21:52 +05:30
2020-10-29 12:12:41 +05:30
def test_from_table(self):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(60,100,3)
2020-10-29 12:12:41 +05:30
size = np.ones(3)+np.random.rand(3)
coords = grid_filters.coordinates0_point(cells,size).reshape(-1,3,order='F')
z = np.ones(cells.prod())
z[cells[:2].prod()*int(cells[2]/2):] = 0
t = Table({'coords':3,'z':1},np.column_stack((coords,z)))
2022-05-11 18:49:48 +05:30
t = t.set('indicator',t.get('coords')[:,0])
2023-11-28 03:11:28 +05:30
g = GeomGrid.from_table(t,'coords',['indicator','z'])
2020-12-04 02:28:24 +05:30
assert g.N_materials == g.cells[0]*2 and (g.material[:,:,-1]-g.material[:,:,0] == cells[0]).all()
def test_from_table_recover(self,tmp_path):
2020-12-04 02:28:24 +05:30
cells = np.random.randint(60,100,3)
size = np.ones(3)+np.random.rand(3)
s = seeds.from_random(size,np.random.randint(60,100))
2023-11-28 03:11:28 +05:30
grid = GeomGrid.from_Voronoi_tessellation(cells,size,s)
coords = grid_filters.coordinates0_point(cells,size)
t = Table({'c':3,'m':1},np.column_stack((coords.reshape(-1,3,order='F'),grid.material.flatten(order='F'))))
2023-11-28 03:11:28 +05:30
assert grid.sort().renumber() == GeomGrid.from_table(t,'c',['m'])
2020-11-25 17:21:52 +05:30
@pytest.mark.parametrize('periodic',[True,False])
@pytest.mark.parametrize('direction',['x','y','z',['x','y'],'zy','xz',['x','y','z']])
@pytest.mark.xfail(vtkVersion.GetVTKMajorVersion()<8, reason='missing METADATA')
def test_get_grain_boundaries(self,update,res_path,periodic,direction):
2023-11-28 03:11:28 +05:30
grid = GeomGrid.load(res_path/'get_grain_boundaries_8g12x15x20.vti')
current = grid.get_grain_boundaries(periodic,direction)
if update:
current.save(res_path/f'get_grain_boundaries_8g12x15x20_{direction}_{periodic}.vtu',parallel=False)
reference = VTK.load(res_path/f'get_grain_boundaries_8g12x15x20_{"".join(direction)}_{periodic}.vtu')
assert current.__repr__() == reference.__repr__()
2021-03-27 12:05:49 +05:30
@pytest.mark.parametrize('directions',[(1,2,'y'),('a','b','x'),[1]])
def test_get_grain_boundaries_invalid(self,default,directions):
with pytest.raises(ValueError):
default.get_grain_boundaries(directions=directions)
def test_load_DREAM3D(self,res_path):
2023-11-28 03:11:28 +05:30
grain = GeomGrid.load_DREAM3D(res_path/'2phase_irregularGrid.dream3d','FeatureIds')
point = GeomGrid.load_DREAM3D(res_path/'2phase_irregularGrid.dream3d')
assert np.allclose(grain.origin,point.origin) and \
np.allclose(grain.size,point.size) and \
(grain.sort().material == point.material+1).all()
def test_load_DREAM3D_reference(self,res_path,update):
2023-11-28 03:11:28 +05:30
current = GeomGrid.load_DREAM3D(res_path/'measured.dream3d')
reference = GeomGrid.load(res_path/'measured.vti')
if update:
current.save(res_path/'measured.vti')
assert current == reference
def test_load_Neper_reference(self,res_path,update):
2023-11-28 03:11:28 +05:30
current = GeomGrid.load_Neper(res_path/'n10-id1_scaled.vtk').renumber()
reference = GeomGrid.load(res_path/'n10-id1_scaled.vti')
if update:
current.save(res_path/'n10-id1_scaled.vti')
assert current == reference