From 907b01e9f39f8689477e4673d33b2c3d1c988a17 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 15 Jan 2023 13:45:39 +0100 Subject: [PATCH 1/7] simple test setup --- python/tests/test_grid_filters.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/python/tests/test_grid_filters.py b/python/tests/test_grid_filters.py index bbf30e2e1..77d7e65ec 100644 --- a/python/tests/test_grid_filters.py +++ b/python/tests/test_grid_filters.py @@ -88,13 +88,25 @@ class TestGridFilters: @pytest.mark.parametrize('function',[grid_filters.displacement_fluct_point, grid_filters.displacement_fluct_node]) - def test_displacement_fluct_vanishes(self,function): + def test_displacement_fluct_vanishes_avg(self,function): """Ensure that constant F does not result in fluctuating displacement.""" # noqa size = np.random.random(3) cells = np.random.randint(8,32,(3)) F = np.broadcast_to(np.random.random((3,3)), tuple(cells)+(3,3)) assert np.allclose(function(size,F),0.0) + def test_displacement_fluct_vanishes_plus_minus(self): + F = np.eye(3) + F_c = F.copy() + F_t = F.copy() + + F_c[0,0] = 0.8 + F_t[0,0] = 1.2 + + F_no_avg = np.concatenate([np.broadcast_to(_,(10,20,20,3,3)) for _ in [F_t,F_c]]) + assert np.allclose(grid_filters.displacement_point([1,1,1],F_no_avg), + grid_filters.displacement_fluct_point([1,1,1],F_no_avg)) + @pytest.mark.parametrize('function',[grid_filters.cellsSizeOrigin_coordinates0_point, grid_filters.cellsSizeOrigin_coordinates0_node]) def test_invalid_coordinates(self,function): From d64b64ed0519c9506ac8d1b394f03a4e6b6c8045 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 4 Jun 2023 22:20:44 +0200 Subject: [PATCH 2/7] bugfix: fluct displacement were wrongly scaled --- python/damask/grid_filters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/damask/grid_filters.py b/python/damask/grid_filters.py index 462621e53..c60e973b9 100644 --- a/python/damask/grid_filters.py +++ b/python/damask/grid_filters.py @@ -186,7 +186,7 @@ def displacement_fluct_point(size: _FloatSequence, Fluctuating part of the cell center displacements. """ - integrator = 0.5j*_np.array(size,float)/_np.pi + integrator = 0.5j*_np.ones(3)/_np.pi k_s = _ks(size,F.shape[:3],False) k_s_squared = _np.einsum('...l,...l',k_s,k_s) From 11c4be008fba5abb1663538828509bceddd8e9a0 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 4 Jun 2023 22:53:42 +0200 Subject: [PATCH 3/7] analytic solution for displacement calculation --- python/tests/test_grid_filters.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/python/tests/test_grid_filters.py b/python/tests/test_grid_filters.py index 77d7e65ec..1c21fb4c7 100644 --- a/python/tests/test_grid_filters.py +++ b/python/tests/test_grid_filters.py @@ -107,6 +107,33 @@ class TestGridFilters: assert np.allclose(grid_filters.displacement_point([1,1,1],F_no_avg), grid_filters.displacement_fluct_point([1,1,1],F_no_avg)) + displacement_fluct_test_data = [ + (['np.sin(np.pi*2*nodes[...,0]/size[0])', '0.0', '0.0', + '0.0', '0.0', '0.0', + '0.0', '0.0', '0.0'], + ['-np.cos(np.pi*2*nodes[...,0]/size[0])/np.pi/2*size[0]', '0.0', '0.0']), + + (['np.cos(np.pi*2*nodes[...,0]/size[0])', '0.0', '0.0', + '0.0', '0.0', '0.0', + '0.0', '0.0', 'np.cos(np.pi*2*nodes[...,2]/size[2])'], + ['np.sin(np.pi*2*nodes[...,0]/size[0])/np.pi/2*size[0]', + '0.0', + 'np.sin(np.pi*2*nodes[...,2]/size[2])/np.pi/2*size[2]'])] + @pytest.mark.parametrize('F_def,u_def',displacement_fluct_test_data) + def test_displacment_fluct_analytic(self,F_def,u_def): + size = np.random.random(3)+1.0 + cells = np.random.randint(8,32,(3)) + + nodes = grid_filters.coordinates0_point(cells,size) + my_locals = locals() # needed for list comprehension + + F = np.stack([np.broadcast_to(eval(F,globals(),my_locals),cells) for F in F_def],axis=-1).reshape(tuple(cells) + (3,3)) + u = np.stack([np.broadcast_to(eval(u,globals(),my_locals),cells) for u in u_def],axis=-1).reshape(tuple(cells) + (3,)) + + + assert np.allclose(u,grid_filters.displacement_fluct_point(size,F)) + + @pytest.mark.parametrize('function',[grid_filters.cellsSizeOrigin_coordinates0_point, grid_filters.cellsSizeOrigin_coordinates0_node]) def test_invalid_coordinates(self,function): From 898aaf10681093d9eff4c99fdfeff2f4ef7e4a27 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sun, 4 Jun 2023 23:46:35 +0200 Subject: [PATCH 4/7] shortened --- python/damask/grid_filters.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/python/damask/grid_filters.py b/python/damask/grid_filters.py index c60e973b9..db1e596b7 100644 --- a/python/damask/grid_filters.py +++ b/python/damask/grid_filters.py @@ -186,8 +186,6 @@ def displacement_fluct_point(size: _FloatSequence, Fluctuating part of the cell center displacements. """ - integrator = 0.5j*_np.ones(3)/_np.pi - k_s = _ks(size,F.shape[:3],False) k_s_squared = _np.einsum('...l,...l',k_s,k_s) k_s_squared[0,0,0] = 1.0 @@ -195,8 +193,8 @@ def displacement_fluct_point(size: _FloatSequence, displacement = -_np.einsum('ijkml,ijkl,l->ijkm', _np.fft.rfftn(F,axes=(0,1,2)), k_s, - integrator, - ) / k_s_squared[...,_np.newaxis] + _np.array([0.5j/_np.pi]*3), + ) / k_s_squared[...,_np.newaxis] return _np.fft.irfftn(displacement,axes=(0,1,2),s=F.shape[:3]) From d42318cafc9cfe7d00dde8d7f6d3a44bf326cd1e Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 5 Jun 2023 11:04:55 +0200 Subject: [PATCH 5/7] new test for grid displacements --- PRIVATE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PRIVATE b/PRIVATE index 4cd6c7350..486e66396 160000 --- a/PRIVATE +++ b/PRIVATE @@ -1 +1 @@ -Subproject commit 4cd6c7350b0a9d4ad3efcb5fe6c6cfffa99c426f +Subproject commit 486e66396f57abe970f01337b9b3967993dd601f From 1a4c171109a7cbad1a203f70d71e20814f8ee466 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Tue, 6 Jun 2023 19:05:29 +0200 Subject: [PATCH 6/7] checking correctness of displacements for 1D strain --- python/tests/test_grid_filters.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/python/tests/test_grid_filters.py b/python/tests/test_grid_filters.py index 1c21fb4c7..2ca239b84 100644 --- a/python/tests/test_grid_filters.py +++ b/python/tests/test_grid_filters.py @@ -2,6 +2,7 @@ import pytest import numpy as np from damask import grid_filters +from damask import mechanics from damask import Grid from damask import seeds @@ -36,7 +37,7 @@ class TestGridFilters: _cells,_size,_origin = eval(f'grid_filters.cellsSizeOrigin_coordinates0_{mode}(coord0.reshape(-1,3,order="F"))') assert np.allclose(cells,_cells) and np.allclose(size,_size) and np.allclose(origin,_origin) - def test_displacement_fluct_equivalence(self): + def test_displacement_fluct_periodic(self): """Ensure that fluctuations are periodic.""" # noqa size = np.random.random(3) cells = np.random.randint(8,32,(3)) @@ -133,6 +134,19 @@ class TestGridFilters: assert np.allclose(u,grid_filters.displacement_fluct_point(size,F)) + def test_coordinates(self): + cells = np.array([np.random.randint(40,100)*2,2,2]) + size = (np.random.rand(3)+0.8)*cells + F = np.broadcast_to(np.eye(3),tuple(cells)+(3,3)).copy() + F[...,0,0] += np.expand_dims(0.1*np.sin(np.linspace(0,2*np.pi,cells[0],False))+ + np.random.rand(cells[0])*0.05,(-1,-2)) + + c_n = grid_filters.coordinates_node(size,F)[:,0,0,0] + l_0 = (size/cells)[0] + l = c_n[1:] - c_n[:-1] + epsilon_reconstructed = (l-l_0)/l_0 + epsilon_direct = mechanics.strain(F,'V',1)[:,0,0,0,0] + assert np.corrcoef(epsilon_reconstructed,epsilon_direct)[0,1] > 0.99 @pytest.mark.parametrize('function',[grid_filters.cellsSizeOrigin_coordinates0_point, grid_filters.cellsSizeOrigin_coordinates0_node]) From 137c4e3b0358b67bd8ad05afe9f8543c663460f7 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Mon, 12 Jun 2023 20:38:14 +0200 Subject: [PATCH 7/7] easier to understand --- python/tests/test_grid_filters.py | 130 +++++++++++++++--------------- 1 file changed, 66 insertions(+), 64 deletions(-) diff --git a/python/tests/test_grid_filters.py b/python/tests/test_grid_filters.py index 2ca239b84..20575f2bd 100644 --- a/python/tests/test_grid_filters.py +++ b/python/tests/test_grid_filters.py @@ -9,95 +9,89 @@ from damask import seeds class TestGridFilters: def test_coordinates0_point(self): - size = np.random.random(3) # noqa - cells = np.random.randint(8,32,(3)) - coord = grid_filters.coordinates0_point(cells,size) - assert np.allclose(coord[0,0,0],size/cells*.5) and coord.shape == tuple(cells) + (3,) + size = np.random.random(3) # noqa + cells = np.random.randint(8,32,(3)) + coord = grid_filters.coordinates0_point(cells,size) + assert np.allclose(coord[0,0,0],size/cells*.5) and coord.shape == tuple(cells) + (3,) def test_coordinates0_node(self): - size = np.random.random(3) # noqa - cells = np.random.randint(8,32,(3)) - coord = grid_filters.coordinates0_node(cells,size) - assert np.allclose(coord[-1,-1,-1],size) and coord.shape == tuple(cells+1) + (3,) + size = np.random.random(3) # noqa + cells = np.random.randint(8,32,(3)) + coord = grid_filters.coordinates0_node(cells,size) + assert np.allclose(coord[-1,-1,-1],size) and coord.shape == tuple(cells+1) + (3,) def test_coord0(self): - size = np.random.random(3) # noqa - cells = np.random.randint(8,32,(3)) - c = grid_filters.coordinates0_point(cells+1,size+size/cells) - n = grid_filters.coordinates0_node(cells,size) + size/cells*.5 - assert np.allclose(c,n) + size = np.random.random(3) # noqa + cells = np.random.randint(8,32,(3)) + c = grid_filters.coordinates0_point(cells+1,size+size/cells) + n = grid_filters.coordinates0_node(cells,size) + size/cells*.5 + assert np.allclose(c,n) @pytest.mark.parametrize('mode',['point','node']) def test_grid_DNA(self,mode): - """Ensure that cellsSizeOrigin_coordinates0_xx is the inverse of coordinates0_xx.""" # noqa - cells = np.random.randint(8,32,(3)) - size = np.random.random(3) - origin = np.random.random(3) - coord0 = eval(f'grid_filters.coordinates0_{mode}(cells,size,origin)') # noqa - _cells,_size,_origin = eval(f'grid_filters.cellsSizeOrigin_coordinates0_{mode}(coord0.reshape(-1,3,order="F"))') - assert np.allclose(cells,_cells) and np.allclose(size,_size) and np.allclose(origin,_origin) + """Ensure that cellsSizeOrigin_coordinates0_xx is the inverse of coordinates0_xx.""" # noqa + cells = np.random.randint(8,32,(3)) + size = np.random.random(3) + origin = np.random.random(3) + coord0 = eval(f'grid_filters.coordinates0_{mode}(cells,size,origin)') # noqa + _cells,_size,_origin = eval(f'grid_filters.cellsSizeOrigin_coordinates0_{mode}(coord0.reshape(-1,3,order="F"))') + assert np.allclose(cells,_cells) and np.allclose(size,_size) and np.allclose(origin,_origin) def test_displacement_fluct_periodic(self): - """Ensure that fluctuations are periodic.""" # noqa - size = np.random.random(3) - cells = np.random.randint(8,32,(3)) - F = np.random.random(tuple(cells)+(3,3)) - assert np.allclose(grid_filters.displacement_fluct_node(size,F), - grid_filters.point_to_node(grid_filters.displacement_fluct_point(size,F))) + """Ensure that fluctuations are periodic.""" # noqa + size = np.random.random(3) + cells = np.random.randint(8,32,(3)) + F = np.random.random(tuple(cells)+(3,3)) + assert np.allclose(grid_filters.displacement_fluct_node(size,F), + grid_filters.point_to_node(grid_filters.displacement_fluct_point(size,F))) def test_interpolation_to_node(self): - size = np.random.random(3) # noqa - cells = np.random.randint(8,32,(3)) - F = np.random.random(tuple(cells)+(3,3)) - assert np.allclose(grid_filters.coordinates_node(size,F) [1:-1,1:-1,1:-1], - grid_filters.point_to_node(grid_filters.coordinates_point(size,F))[1:-1,1:-1,1:-1]) + size = np.random.random(3) # noqa + cells = np.random.randint(8,32,(3)) + F = np.random.random(tuple(cells)+(3,3)) + assert np.allclose(grid_filters.coordinates_node(size,F) [1:-1,1:-1,1:-1], + grid_filters.point_to_node(grid_filters.coordinates_point(size,F))[1:-1,1:-1,1:-1]) def test_interpolation_to_cell(self): - cells = np.random.randint(1,30,(3)) # noqa + cells = np.random.randint(1,30,(3)) # noqa - coordinates_node_x = np.linspace(0,np.pi*2,num=cells[0]+1) - node_field_x = np.cos(coordinates_node_x) - node_field = np.broadcast_to(node_field_x.reshape(-1,1,1),cells+1) + coordinates_node_x = np.linspace(0,np.pi*2,num=cells[0]+1) + node_field_x = np.cos(coordinates_node_x) + node_field = np.broadcast_to(node_field_x.reshape(-1,1,1),cells+1) - coordinates0_point_x = coordinates_node_x[:-1]+coordinates_node_x[1]*.5 - cell_field_x = np.interp(coordinates0_point_x,coordinates_node_x,node_field_x,period=np.pi*2.) - cell_field = np.broadcast_to(cell_field_x.reshape(-1,1,1),cells) + coordinates0_point_x = coordinates_node_x[:-1]+coordinates_node_x[1]*.5 + cell_field_x = np.interp(coordinates0_point_x,coordinates_node_x,node_field_x,period=np.pi*2.) + cell_field = np.broadcast_to(cell_field_x.reshape(-1,1,1),cells) - assert np.allclose(cell_field,grid_filters.node_to_point(node_field)) + assert np.allclose(cell_field,grid_filters.node_to_point(node_field)) @pytest.mark.parametrize('mode',['point','node']) def test_coordinates0_origin(self,mode): - origin= np.random.random(3) # noqa - size = np.random.random(3) # noqa - cells = np.random.randint(8,32,(3)) - shifted = eval(f'grid_filters.coordinates0_{mode}(cells,size,origin)') - unshifted = eval(f'grid_filters.coordinates0_{mode}(cells,size)') - if mode == 'cell': + origin= np.random.random(3) # noqa + size = np.random.random(3) # noqa + cells = np.random.randint(8,32,(3)) + shifted = eval(f'grid_filters.coordinates0_{mode}(cells,size,origin)') + unshifted = eval(f'grid_filters.coordinates0_{mode}(cells,size)') + if mode == 'cell': assert np.allclose(shifted,unshifted+np.broadcast_to(origin,tuple(cells) +(3,))) - elif mode == 'node': + elif mode == 'node': assert np.allclose(shifted,unshifted+np.broadcast_to(origin,tuple(cells+1)+(3,))) @pytest.mark.parametrize('function',[grid_filters.displacement_avg_point, grid_filters.displacement_avg_node]) def test_displacement_avg_vanishes(self,function): - """Ensure that random fluctuations in F do not result in average displacement.""" # noqa - size = np.random.random(3) - cells = np.random.randint(8,32,(3)) - F = np.random.random(tuple(cells)+(3,3)) - F += np.eye(3) - np.average(F,axis=(0,1,2)) - assert np.allclose(function(size,F),0.0) + """Ensure that random fluctuations in F do not result in average displacement.""" # noqa + size = np.random.random(3) + 1.0 + cells = np.random.randint(8,32,(3)) + F = np.random.random(tuple(cells)+(3,3)) + F += np.eye(3) - np.average(F,axis=(0,1,2)) + assert np.allclose(function(size,F),0.0) - @pytest.mark.parametrize('function',[grid_filters.displacement_fluct_point, - grid_filters.displacement_fluct_node]) - def test_displacement_fluct_vanishes_avg(self,function): - """Ensure that constant F does not result in fluctuating displacement.""" # noqa - size = np.random.random(3) - cells = np.random.randint(8,32,(3)) - F = np.broadcast_to(np.random.random((3,3)), tuple(cells)+(3,3)) - assert np.allclose(function(size,F),0.0) - - def test_displacement_fluct_vanishes_plus_minus(self): + @pytest.mark.parametrize('function',[grid_filters.displacement_avg_point, + grid_filters.displacement_avg_node]) + def test_displacement_avg_vanishes_simple(self,function): F = np.eye(3) + size = np.random.random(3) + 1.0 F_c = F.copy() F_t = F.copy() @@ -105,8 +99,16 @@ class TestGridFilters: F_t[0,0] = 1.2 F_no_avg = np.concatenate([np.broadcast_to(_,(10,20,20,3,3)) for _ in [F_t,F_c]]) - assert np.allclose(grid_filters.displacement_point([1,1,1],F_no_avg), - grid_filters.displacement_fluct_point([1,1,1],F_no_avg)) + assert np.allclose(function(size,F_no_avg),0.0) + + @pytest.mark.parametrize('function',[grid_filters.displacement_fluct_point, + grid_filters.displacement_fluct_node]) + def test_displacement_fluct_vanishes_avg(self,function): + """Ensure that constant F does not result in fluctuating displacement.""" # noqa + size = np.random.random(3) + cells = np.random.randint(8,32,(3)) + F = np.broadcast_to(np.random.random((3,3)), tuple(cells)+(3,3)) + assert np.allclose(function(size,F),0.0) displacement_fluct_test_data = [ (['np.sin(np.pi*2*nodes[...,0]/size[0])', '0.0', '0.0',