From 4c22efc6ce6f80df6e197d0f3044114eb640a82c Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Mon, 19 Oct 2020 12:52:10 +0200 Subject: [PATCH 01/22] added show GB --- python/damask/_geom.py | 76 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 6366f06ab..4eec19628 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -6,6 +6,9 @@ from os import path import numpy as np import h5py from scipy import ndimage,spatial +import vtk +from vtk.util.numpy_support import numpy_to_vtk as np_to_vtk +from vtk.util.numpy_support import numpy_to_vtkIdTypeArray as np_to_vtkIdTypeArray from . import environment from . import VTK @@ -840,3 +843,76 @@ class Geom: origin = self.origin, comments = self.comments+[util.execution_stamp('Geom','vicinity_offset')], ) + + def ShowGB(self,periodic=False): + """ + Create an extra VTK file to show grain boundaries as feature edges. + + Parameters + ---------- + periodic : Boolean, optional + Show boundaries at periodic nodes too. Defalts to False. + + """ + v = VTK.from_polyData(grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F')) + cells = vtk.vtkCellArray() + + #Grid to nodes + a=self.grid[0]+1 + b=self.grid[1]+1 + c=self.grid[2]+1 + + if periodic: + FaceYZ_per=np.empty() + FaceXY_per=np.empty() + FaceXZ_per=np.empty() + else: + # get nodes of periodic boundaries in X + FaceYZ_per=np.concatenate(( np.arange(0,a*b*c,a) , np.arange(self.grid[0], a*b*c,a) )) + # get nodes of periodic boundaries in Z + FaceXY_per=np.concatenate(( np.arange(0,a*b) , np.arange(a*b*c - a*b, a*b*c ) )) + # get nodes of periodic boundaries in Y + FaceXZ_0=np.arange(0, a) # face Y=0 + for i in range(c): + add=np.arange( (i+1)*(a)*(b), (i+1)*(a)*(b)+ (a)) + FaceXZ_0=np.append(FaceXZ_0, add) + FaceXZ_end=np.arange(a*b-b, a*b) # face Y=end + for i in range(c): + add= np.arange( (i+1)*a*b-b, (i+1)*a*b) + FaceXZ_end=np.append(FaceXZ_end, add) + FaceXZ_per=np.concatenate (( FaceXZ_0, FaceXZ_end )) + + for d_s in [0,1,2]: + base_nodes = np.where(self.material==np.roll(self.material,1,d_s),False,True) + for d in [0,1,2]: + if d_s == d: + base_nodes = np.concatenate((base_nodes,np.take(base_nodes,[0],d)),d) + else: + base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) + for p in np.argwhere(base_nodes.flatten(order='F')): + if np.any(FaceYZ_per == p[0]) and d_s == 0: + pass + elif np.any(FaceXY_per == p[0]) and d_s == 2: + pass + elif np.any(FaceXZ_per == p[0]) and d_s == 1: + pass + else: + q = vtk.vtkQuad() + q.GetPointIds().SetId(0, p[0]) + if d_s == 0: + q.GetPointIds().SetId(1, p[0]+a) + q.GetPointIds().SetId(2, p[0]+a*b+a) + q.GetPointIds().SetId(3, p[0]+a*b) + if d_s == 1: + q.GetPointIds().SetId(1, p[0]+a*b) + q.GetPointIds().SetId(2, p[0]+a*b+1) + q.GetPointIds().SetId(3, p[0]+1) + if d_s == 2: + q.GetPointIds().SetId(1, p[0]+1) + q.GetPointIds().SetId(2, p[0]+a+1) + q.GetPointIds().SetId(3, p[0]+a) + cells.InsertNextCell(q) + v.vtk_data.SetPolys(cells) + v.save('GrainBoundaries') + + From 7fa31a8a1b5914ad78b5fb1202fbd11ed63964b7 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Mon, 19 Oct 2020 12:55:35 +0200 Subject: [PATCH 02/22] solving imported but unused pyflake --- python/damask/_geom.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 4eec19628..b40bedb04 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -7,8 +7,6 @@ import numpy as np import h5py from scipy import ndimage,spatial import vtk -from vtk.util.numpy_support import numpy_to_vtk as np_to_vtk -from vtk.util.numpy_support import numpy_to_vtkIdTypeArray as np_to_vtkIdTypeArray from . import environment from . import VTK From 1cbfa866d2d1c432780b644f1e4a6457be67e8ae Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Fri, 23 Oct 2020 16:23:36 +0200 Subject: [PATCH 03/22] get rid of scalar variables --- python/damask/_geom.py | 55 ++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 31 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index b40bedb04..5d89d0750 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -849,37 +849,30 @@ class Geom: Parameters ---------- periodic : Boolean, optional - Show boundaries at periodic nodes too. Defalts to False. + Show boundaries at periodic nodes too. Defaults to False. """ v = VTK.from_polyData(grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F')) cells = vtk.vtkCellArray() - #Grid to nodes - a=self.grid[0]+1 - b=self.grid[1]+1 - c=self.grid[2]+1 - if periodic: - FaceYZ_per=np.empty() - FaceXY_per=np.empty() - FaceXZ_per=np.empty() + FaceYZ_per=np.empty([]) + FaceXY_per=np.empty([]) + FaceXZ_per=np.empty([]) else: - # get nodes of periodic boundaries in X - FaceYZ_per=np.concatenate(( np.arange(0,a*b*c,a) , np.arange(self.grid[0], a*b*c,a) )) - # get nodes of periodic boundaries in Z - FaceXY_per=np.concatenate(( np.arange(0,a*b) , np.arange(a*b*c - a*b, a*b*c ) )) - # get nodes of periodic boundaries in Y - FaceXZ_0=np.arange(0, a) # face Y=0 - for i in range(c): - add=np.arange( (i+1)*(a)*(b), (i+1)*(a)*(b)+ (a)) - FaceXZ_0=np.append(FaceXZ_0, add) - FaceXZ_end=np.arange(a*b-b, a*b) # face Y=end - for i in range(c): - add= np.arange( (i+1)*a*b-b, (i+1)*a*b) - FaceXZ_end=np.append(FaceXZ_end, add) - FaceXZ_per=np.concatenate (( FaceXZ_0, FaceXZ_end )) - + FaceYZ_per=np.concatenate(( + np.arange(0 , np.prod(self.grid+1) , (self.grid[0]+1) ), + np.arange(self.grid[0] , np.prod(self.grid+1) , (self.grid[0]+1) ) )) + FaceXY_per=np.concatenate(( + np.arange(0 , np.prod(self.grid[:2]+1) , 1 ), + np.arange(np.prod(self.grid+1) - np.prod(self.grid[:2]+1), \ + np.prod(self.grid+1) , 1 ) )) + FaceXZ_per=np.concatenate(( + np.concatenate([np.arange((i)*np.prod(self.grid[:2]+1), \ + (i)*np.prod(self.grid[:2]+1)+ (self.grid[0]+1)) for i in range(self.grid[2]+1)]) , + np.concatenate([np.arange( (i+1)*np.prod(self.grid[:2]+1)-(self.grid[0]+1),\ + (i+1)*np.prod(self.grid[:2]+1)) for i in range(self.grid[2]+1)]) )) + for d_s in [0,1,2]: base_nodes = np.where(self.material==np.roll(self.material,1,d_s),False,True) for d in [0,1,2]: @@ -898,17 +891,17 @@ class Geom: q = vtk.vtkQuad() q.GetPointIds().SetId(0, p[0]) if d_s == 0: - q.GetPointIds().SetId(1, p[0]+a) - q.GetPointIds().SetId(2, p[0]+a*b+a) - q.GetPointIds().SetId(3, p[0]+a*b) + q.GetPointIds().SetId(1, p[0]+(self.grid[0]+1)) + q.GetPointIds().SetId(2, p[0]+np.prod(self.grid[:2]+1)+(self.grid[0]+1)) + q.GetPointIds().SetId(3, p[0]+np.prod(self.grid[:2]+1)) if d_s == 1: - q.GetPointIds().SetId(1, p[0]+a*b) - q.GetPointIds().SetId(2, p[0]+a*b+1) + q.GetPointIds().SetId(1, p[0]+np.prod(self.grid[:2]+1)) + q.GetPointIds().SetId(2, p[0]+np.prod(self.grid[:2]+1)+1) q.GetPointIds().SetId(3, p[0]+1) if d_s == 2: q.GetPointIds().SetId(1, p[0]+1) - q.GetPointIds().SetId(2, p[0]+a+1) - q.GetPointIds().SetId(3, p[0]+a) + q.GetPointIds().SetId(2, p[0]+(self.grid[0]+1)+1) + q.GetPointIds().SetId(3, p[0]+(self.grid[0]+1)) cells.InsertNextCell(q) v.vtk_data.SetPolys(cells) v.save('GrainBoundaries') From 2715e7b1a79663c5afcfc16c997275606bda92d0 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Mon, 26 Oct 2020 15:09:32 +0100 Subject: [PATCH 04/22] a bit more vectorized --- python/damask/_geom.py | 69 +++++++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 31 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 5d89d0750..31a98e32e 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -854,20 +854,23 @@ class Geom: """ v = VTK.from_polyData(grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F')) cells = vtk.vtkCellArray() - + + index={} + nodes={} + nodes_PBC={} if periodic: - FaceYZ_per=np.empty([]) - FaceXY_per=np.empty([]) - FaceXZ_per=np.empty([]) - else: - FaceYZ_per=np.concatenate(( + nodes_PBC['0']=np.array([]) + nodes_PBC['1']=np.array([]) + nodes_PBC['2']=np.array([]) + else: + nodes_PBC['0']=np.concatenate(( np.arange(0 , np.prod(self.grid+1) , (self.grid[0]+1) ), np.arange(self.grid[0] , np.prod(self.grid+1) , (self.grid[0]+1) ) )) - FaceXY_per=np.concatenate(( + nodes_PBC['2']=np.concatenate(( np.arange(0 , np.prod(self.grid[:2]+1) , 1 ), np.arange(np.prod(self.grid+1) - np.prod(self.grid[:2]+1), \ np.prod(self.grid+1) , 1 ) )) - FaceXZ_per=np.concatenate(( + nodes_PBC['1']=np.concatenate(( np.concatenate([np.arange((i)*np.prod(self.grid[:2]+1), \ (i)*np.prod(self.grid[:2]+1)+ (self.grid[0]+1)) for i in range(self.grid[2]+1)]) , np.concatenate([np.arange( (i+1)*np.prod(self.grid[:2]+1)-(self.grid[0]+1),\ @@ -880,29 +883,33 @@ class Geom: base_nodes = np.concatenate((base_nodes,np.take(base_nodes,[0],d)),d) else: base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) - for p in np.argwhere(base_nodes.flatten(order='F')): - if np.any(FaceYZ_per == p[0]) and d_s == 0: - pass - elif np.any(FaceXY_per == p[0]) and d_s == 2: - pass - elif np.any(FaceXZ_per == p[0]) and d_s == 1: - pass - else: - q = vtk.vtkQuad() - q.GetPointIds().SetId(0, p[0]) - if d_s == 0: - q.GetPointIds().SetId(1, p[0]+(self.grid[0]+1)) - q.GetPointIds().SetId(2, p[0]+np.prod(self.grid[:2]+1)+(self.grid[0]+1)) - q.GetPointIds().SetId(3, p[0]+np.prod(self.grid[:2]+1)) - if d_s == 1: - q.GetPointIds().SetId(1, p[0]+np.prod(self.grid[:2]+1)) - q.GetPointIds().SetId(2, p[0]+np.prod(self.grid[:2]+1)+1) - q.GetPointIds().SetId(3, p[0]+1) - if d_s == 2: - q.GetPointIds().SetId(1, p[0]+1) - q.GetPointIds().SetId(2, p[0]+(self.grid[0]+1)+1) - q.GetPointIds().SetId(3, p[0]+(self.grid[0]+1)) - cells.InsertNextCell(q) + nodes['{}'.format(d_s)]= np.argwhere(base_nodes.flatten(order='F'))[:,0] + index['{}'.format(d_s)]= np.isin( nodes['{}'.format(d_s)] , nodes_PBC['{}'.format(d_s)] , assume_unique=True, invert=True ) + + for p in nodes['0'][index['0']]: + q = vtk.vtkQuad() + q.GetPointIds().SetId(0, p) + q.GetPointIds().SetId(1, p+(self.grid[0]+1)) + q.GetPointIds().SetId(2, p+np.prod(self.grid[:2]+1)+(self.grid[0]+1)) + q.GetPointIds().SetId(3, p+np.prod(self.grid[:2]+1)) + cells.InsertNextCell(q) + + for p in nodes['1'][index['1']]: + q = vtk.vtkQuad() + q.GetPointIds().SetId(0, p) + q.GetPointIds().SetId(1, p+np.prod(self.grid[:2]+1)) + q.GetPointIds().SetId(2, p+np.prod(self.grid[:2]+1)+1) + q.GetPointIds().SetId(3, p+1) + cells.InsertNextCell(q) + + for p in nodes['2'][index['2']]: + q = vtk.vtkQuad() + q.GetPointIds().SetId(0, p) + q.GetPointIds().SetId(1, p+1) + q.GetPointIds().SetId(2, p+(self.grid[0]+1)+1) + q.GetPointIds().SetId(3, p+(self.grid[0]+1)) + cells.InsertNextCell(q) + v.vtk_data.SetPolys(cells) v.save('GrainBoundaries') From 802e09be4f4a3890012de0c80e6bcbc8de18ec9d Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Mon, 26 Oct 2020 15:11:06 +0100 Subject: [PATCH 05/22] python/damask/_geom.py exceeds line length limit (maximum line length 143 > 132) --- python/damask/_geom.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 31a98e32e..914c6bafa 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -884,7 +884,7 @@ class Geom: else: base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) nodes['{}'.format(d_s)]= np.argwhere(base_nodes.flatten(order='F'))[:,0] - index['{}'.format(d_s)]= np.isin( nodes['{}'.format(d_s)] , nodes_PBC['{}'.format(d_s)] , assume_unique=True, invert=True ) + index['{}'.format(d_s)]=np.isin(nodes['{}'.format(d_s)],nodes_PBC['{}'.format(d_s)],assume_unique=True,invert=True) for p in nodes['0'][index['0']]: q = vtk.vtkQuad() From be206d28b34497c8f9f47dde0aed3801230a327f Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:14:12 +0100 Subject: [PATCH 06/22] vectorized and more options --- python/damask/_geom.py | 114 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 112 insertions(+), 2 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 914c6bafa..964421af1 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -857,7 +857,7 @@ class Geom: index={} nodes={} - nodes_PBC={} + nodes_PBC={} if periodic: nodes_PBC['0']=np.array([]) nodes_PBC['1']=np.array([]) @@ -909,8 +909,118 @@ class Geom: q.GetPointIds().SetId(2, p+(self.grid[0]+1)+1) q.GetPointIds().SetId(3, p+(self.grid[0]+1)) cells.InsertNextCell(q) - + v.vtk_data.SetPolys(cells) v.save('GrainBoundaries') + def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): + """ + Create an extra VTK file to show grain boundaries as feature edges. + + Parameters + ---------- + periodic : Boolean, optional + Show boundaries at periodic nodes too. Defaults to False. + across : list of lists + Show grain boundaries only across certain axis. [X=0,Y=1,Z=2]. Defaults to all possible. + + """ + + if across in [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: + pass + elif across == [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: + pass + else: + print('across list not valid, it must be in [[0],[1],[2],[1,2],[2,3],[1,3],[1,2,3]]') + + coord=grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') + index={} + nodes={} + nodes_PBC={} + if periodic: + nodes_PBC['0']=np.array([]) + nodes_PBC['1']=np.array([]) + nodes_PBC['2']=np.array([]) + else: + nodes_PBC['0']=np.concatenate(( + np.arange(0 , np.prod(self.grid+1) , (self.grid[0]+1) ), + np.arange(self.grid[0] , np.prod(self.grid+1) , (self.grid[0]+1) ) )) + nodes_PBC['2']=np.concatenate(( + np.arange(0 , np.prod(self.grid[:2]+1) , 1 ), + np.arange(np.prod(self.grid+1) - np.prod(self.grid[:2]+1), \ + np.prod(self.grid+1) , 1 ) )) + nodes_PBC['1']=np.concatenate(( + np.concatenate([np.arange((i)*np.prod(self.grid[:2]+1), \ + (i)*np.prod(self.grid[:2]+1)+ (self.grid[0]+1)) for i in range(self.grid[2]+1)]) , + np.concatenate([np.arange( (i+1)*np.prod(self.grid[:2]+1)-(self.grid[0]+1),\ + (i+1)*np.prod(self.grid[:2]+1)) for i in range(self.grid[2]+1)]) )) + + for d_s in [0,1,2]: + base_nodes = np.where(self.material==np.roll(self.material,1,d_s),False,True) + for d in [0,1,2]: + if d_s == d: + base_nodes = np.concatenate((base_nodes,np.take(base_nodes,[0],d)),d) + else: + base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) + nodes['{}'.format(d_s)]= np.argwhere(base_nodes.flatten(order='F'))[:,0] + index['{}'.format(d_s)]=np.isin(nodes['{}'.format(d_s)],nodes_PBC['{}'.format(d_s)],assume_unique=True,invert=True) + + nodes_x=nodes['0'][index['0']] + coord_x=np.concatenate(( [[coord[p], \ + coord[p+(self.grid[0]+1)], \ + coord[p+np.prod(self.grid[:2]+1)+(self.grid[0]+1)], \ + coord[p +np.prod(self.grid[:2]+1)]] for p in nodes_x] )) + + nodes_y=nodes['1'][index['1']] + coord_y=np.concatenate(( [[coord[p], \ + coord[p+np.prod(self.grid[:2]+1)], \ + coord[p+np.prod(self.grid[:2]+1)+1], \ + coord[p +1]] for p in nodes_y] )) + + nodes_z=nodes['2'][index['2']] + coord_z=np.concatenate(( [[coord[p], \ + coord[p+1], \ + coord[p+(self.grid[0]+1)+1], \ + coord[p+(self.grid[0]+1)]] for p in nodes_z] )) + + + if [0] in across: + connectivity_x=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_x.shape[0],4)]) + vtk_x=VTK.from_unstructuredGrid(coord_x,connectivity_x,'QUAD') + vtk_x.save('GrainBoundariesX') + if [1] in across: + connectivity_y=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_y.shape[0],4)]) + vtk_y=VTK.from_unstructuredGrid(coord_y,connectivity_y,'QUAD') + vtk_y.save('GrainBoundariesY') + if [2] in across: + connectivity_z=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_z.shape[0],4)]) + vtk_z=VTK.from_unstructuredGrid(coord_z,connectivity_z,'QUAD') + vtk_y.save('GrainBoundariesZ') + + if [0,1] in across: + connectivity_xy=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_x.shape[0]+nodes_y.shape[0]),4)]) + nodes_vXY=np.concatenate(( coord_x, coord_y )) + vtk_xy=VTK.from_unstructuredGrid(nodes_vXY,connectivity_xy,'QUAD') + vtk_xy.save('GrainBoundariesXY') + + if [0,2] in across: + connectivity_xz=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_x.shape[0]+nodes_z.shape[0]),4)]) + nodes_vXZ=np.concatenate(( coord_x, coord_z )) + vtk_xz=VTK.from_unstructuredGrid(nodes_vXZ,connectivity_xz,'QUAD') + vtk_xz.save('GrainBoundariesXZ') + + if [1,2] in across: + connectivity_yz=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_y.shape[0]+nodes_z.shape[0]),4)]) + nodes_vYZ=np.concatenate(( coord_y, coord_z )) + vtk_yz=VTK.from_unstructuredGrid(nodes_vYZ,connectivity_yz,'QUAD') + vtk_yz.save('GrainBoundariesYZ') + + if [0,1,2] in across: + connectivity_xyz=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_x.shape[0]+nodes_y.shape[0]+nodes_z.shape[0],4)]) + nodes_vXYZ=np.concatenate(( coord_x, coord_y, coord_z )) + vtk_xyz=VTK.from_unstructuredGrid(nodes_vXYZ,connectivity_xyz,'QUAD') + vtk_xyz.save('GrainBoundariesXYZ') + else: + pass + From e8f82d52cc131a181f56ae80cb5d9358ef874ccb Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:16:08 +0100 Subject: [PATCH 07/22] fix bug --- python/damask/_geom.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 964421af1..dc29af29b 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -995,7 +995,7 @@ class Geom: if [2] in across: connectivity_z=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_z.shape[0],4)]) vtk_z=VTK.from_unstructuredGrid(coord_z,connectivity_z,'QUAD') - vtk_y.save('GrainBoundariesZ') + vtk_z.save('GrainBoundariesZ') if [0,1] in across: connectivity_xy=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_x.shape[0]+nodes_y.shape[0]),4)]) From 33aa888fc7113bfca40a4837aaeeefbaa4550b69 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:17:05 +0100 Subject: [PATCH 08/22] avoid pyflake for blank line --- python/damask/_geom.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index dc29af29b..98f19b985 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -912,7 +912,7 @@ class Geom: v.vtk_data.SetPolys(cells) v.save('GrainBoundaries') - + def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): """ Create an extra VTK file to show grain boundaries as feature edges. From c6811011361bc9b00b7a46497991c1fe545fc0e2 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:19:47 +0100 Subject: [PATCH 09/22] avoid pyflake for blank line 2 --- python/damask/_geom.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 98f19b985..cc8a54785 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -913,6 +913,7 @@ class Geom: v.vtk_data.SetPolys(cells) v.save('GrainBoundaries') + def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): """ Create an extra VTK file to show grain boundaries as feature edges. From eda3837874d0d60472c2fcd53a48c2955e5e445e Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:21:09 +0100 Subject: [PATCH 10/22] avoid pyflake for blank line 3 --- python/damask/_geom.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index cc8a54785..a929adbd3 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -916,7 +916,7 @@ class Geom: def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): """ - Create an extra VTK file to show grain boundaries as feature edges. + Create an extra VTK file to show grain boundaries as feature edges optimized. Parameters ---------- From 4dbfad74cb194f5f9748bce46138625a79e9c50f Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:24:17 +0100 Subject: [PATCH 11/22] avoid pyflake for blank line 4 --- python/damask/_geom.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index a929adbd3..59972d967 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -915,8 +915,7 @@ class Geom: def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): - """ - Create an extra VTK file to show grain boundaries as feature edges optimized. + """Create an extra VTK file to show grain boundaries as feature edges optimized. Parameters ---------- From ee5822b7210f2e521203e5ca01a325c28e42c837 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:25:08 +0100 Subject: [PATCH 12/22] avoid pyflake for blank line 5 --- python/damask/_geom.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 59972d967..15db18e9e 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -915,7 +915,8 @@ class Geom: def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): - """Create an extra VTK file to show grain boundaries as feature edges optimized. + """ + Create an VTK files to show grain boundaries as feature edges. Parameters ---------- From 7291b9505566efe9845520a741cfb2bdc662c1f4 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 18 Nov 2020 12:29:10 +0100 Subject: [PATCH 13/22] avoid pyflake for blank line 6 final --- python/damask/_geom.py | 1 - 1 file changed, 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 15db18e9e..49863af5a 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -926,7 +926,6 @@ class Geom: Show grain boundaries only across certain axis. [X=0,Y=1,Z=2]. Defaults to all possible. """ - if across in [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: pass elif across == [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: From 735243114377c715e0570c09fc4111b9f75e6da6 Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Wed, 18 Nov 2020 20:10:04 +0100 Subject: [PATCH 14/22] vectorized --- python/damask/_geom.py | 112 +++++++---------------------------------- 1 file changed, 17 insertions(+), 95 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 49863af5a..2022c59f5 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -914,7 +914,7 @@ class Geom: v.save('GrainBoundaries') - def ShowGBoptimized(self,periodic=False,across=[[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]): + def ShowGBoptimized(self,periodic=True,direction='xyz'): """ Create an VTK files to show grain boundaries as feature edges. @@ -926,101 +926,23 @@ class Geom: Show grain boundaries only across certain axis. [X=0,Y=1,Z=2]. Defaults to all possible. """ - if across in [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: - pass - elif across == [[0],[1],[2],[0,1],[1,2],[0,2],[0,1,2]]: - pass - else: - print('across list not valid, it must be in [[0],[1],[2],[1,2],[2,3],[1,3],[1,2,3]]') - coord=grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') - index={} - nodes={} - nodes_PBC={} - if periodic: - nodes_PBC['0']=np.array([]) - nodes_PBC['1']=np.array([]) - nodes_PBC['2']=np.array([]) - else: - nodes_PBC['0']=np.concatenate(( - np.arange(0 , np.prod(self.grid+1) , (self.grid[0]+1) ), - np.arange(self.grid[0] , np.prod(self.grid+1) , (self.grid[0]+1) ) )) - nodes_PBC['2']=np.concatenate(( - np.arange(0 , np.prod(self.grid[:2]+1) , 1 ), - np.arange(np.prod(self.grid+1) - np.prod(self.grid[:2]+1), \ - np.prod(self.grid+1) , 1 ) )) - nodes_PBC['1']=np.concatenate(( - np.concatenate([np.arange((i)*np.prod(self.grid[:2]+1), \ - (i)*np.prod(self.grid[:2]+1)+ (self.grid[0]+1)) for i in range(self.grid[2]+1)]) , - np.concatenate([np.arange( (i+1)*np.prod(self.grid[:2]+1)-(self.grid[0]+1),\ - (i+1)*np.prod(self.grid[:2]+1)) for i in range(self.grid[2]+1)]) )) - + + # offset (for connectivity) + o = [[0, self.grid[0]+1, np.prod(self.grid[:2]+1)+self.grid[0]+1, np.prod(self.grid[:2]+1)], + [0, np.prod(self.grid[:2]+1), np.prod(self.grid[:2]+1)+1, 1], + [0, 1, self.grid[0]+1+1, self.grid[0]+1]] + for d_s in [0,1,2]: - base_nodes = np.where(self.material==np.roll(self.material,1,d_s),False,True) + mask = np.where(self.material==np.roll(self.material,1,d_s),False,True) for d in [0,1,2]: - if d_s == d: - base_nodes = np.concatenate((base_nodes,np.take(base_nodes,[0],d)),d) - else: - base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) - nodes['{}'.format(d_s)]= np.argwhere(base_nodes.flatten(order='F'))[:,0] - index['{}'.format(d_s)]=np.isin(nodes['{}'.format(d_s)],nodes_PBC['{}'.format(d_s)],assume_unique=True,invert=True) - - nodes_x=nodes['0'][index['0']] - coord_x=np.concatenate(( [[coord[p], \ - coord[p+(self.grid[0]+1)], \ - coord[p+np.prod(self.grid[:2]+1)+(self.grid[0]+1)], \ - coord[p +np.prod(self.grid[:2]+1)]] for p in nodes_x] )) - - nodes_y=nodes['1'][index['1']] - coord_y=np.concatenate(( [[coord[p], \ - coord[p+np.prod(self.grid[:2]+1)], \ - coord[p+np.prod(self.grid[:2]+1)+1], \ - coord[p +1]] for p in nodes_y] )) - - nodes_z=nodes['2'][index['2']] - coord_z=np.concatenate(( [[coord[p], \ - coord[p+1], \ - coord[p+(self.grid[0]+1)+1], \ - coord[p+(self.grid[0]+1)]] for p in nodes_z] )) - - - if [0] in across: - connectivity_x=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_x.shape[0],4)]) - vtk_x=VTK.from_unstructuredGrid(coord_x,connectivity_x,'QUAD') - vtk_x.save('GrainBoundariesX') - if [1] in across: - connectivity_y=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_y.shape[0],4)]) - vtk_y=VTK.from_unstructuredGrid(coord_y,connectivity_y,'QUAD') - vtk_y.save('GrainBoundariesY') - if [2] in across: - connectivity_z=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_z.shape[0],4)]) - vtk_z=VTK.from_unstructuredGrid(coord_z,connectivity_z,'QUAD') - vtk_z.save('GrainBoundariesZ') - - if [0,1] in across: - connectivity_xy=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_x.shape[0]+nodes_y.shape[0]),4)]) - nodes_vXY=np.concatenate(( coord_x, coord_y )) - vtk_xy=VTK.from_unstructuredGrid(nodes_vXY,connectivity_xy,'QUAD') - vtk_xy.save('GrainBoundariesXY') - - if [0,2] in across: - connectivity_xz=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_x.shape[0]+nodes_z.shape[0]),4)]) - nodes_vXZ=np.concatenate(( coord_x, coord_z )) - vtk_xz=VTK.from_unstructuredGrid(nodes_vXZ,connectivity_xz,'QUAD') - vtk_xz.save('GrainBoundariesXZ') - - if [1,2] in across: - connectivity_yz=np.array([[p,p+1,p+2,p+3] for p in range(0,4*(nodes_y.shape[0]+nodes_z.shape[0]),4)]) - nodes_vYZ=np.concatenate(( coord_y, coord_z )) - vtk_yz=VTK.from_unstructuredGrid(nodes_vYZ,connectivity_yz,'QUAD') - vtk_yz.save('GrainBoundariesYZ') - - if [0,1,2] in across: - connectivity_xyz=np.array([[p,p+1,p+2,p+3] for p in range(0,nodes_x.shape[0]+nodes_y.shape[0]+nodes_z.shape[0],4)]) - nodes_vXYZ=np.concatenate(( coord_x, coord_y, coord_z )) - vtk_xyz=VTK.from_unstructuredGrid(nodes_vXYZ,connectivity_xyz,'QUAD') - vtk_xyz.save('GrainBoundariesXYZ') - else: - pass - + mask = np.concatenate((mask,np.take(mask,[0],d)),d) if d_s == d else \ + np.concatenate((mask,np.logical_and(np.take(mask,[0],d),False)),d) + if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False + if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False + if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False + base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) + connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) + vtk = VTK.from_unstructuredGrid(coord,connectivity,'QUAD') + vtk.save(f'GrainBoundaries{d_s}') From b885e38b3f001770cfd5e0263f317673ee59365d Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Wed, 18 Nov 2020 22:12:23 +0100 Subject: [PATCH 15/22] better readable --- python/damask/_geom.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 2022c59f5..3d93d9252 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -934,10 +934,10 @@ class Geom: [0, 1, self.grid[0]+1+1, self.grid[0]+1]] for d_s in [0,1,2]: - mask = np.where(self.material==np.roll(self.material,1,d_s),False,True) + mask = self.material != np.roll(self.material,1,d_s) for d in [0,1,2]: - mask = np.concatenate((mask,np.take(mask,[0],d)),d) if d_s == d else \ - np.concatenate((mask,np.logical_and(np.take(mask,[0],d),False)),d) + extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) + mask = np.concatenate((mask,extra_layer),d) if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False From c8b1f8d9f174fa2c9b57b1a4b91c7d860b4d1831 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Tue, 24 Nov 2020 17:49:58 +0100 Subject: [PATCH 16/22] shortest possible way i found to include directions in an elegant way --- python/damask/_geom.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 3d93d9252..587860742 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -914,16 +914,16 @@ class Geom: v.save('GrainBoundaries') - def ShowGBoptimized(self,periodic=True,direction='xyz'): + def get_grain_boundaries(self,periodic=True,direction='xyz'): """ - Create an VTK files to show grain boundaries as feature edges. + Create VTK files to show grain boundaries as feature edges. Parameters ---------- periodic : Boolean, optional - Show boundaries at periodic nodes too. Defaults to False. - across : list of lists - Show grain boundaries only across certain axis. [X=0,Y=1,Z=2]. Defaults to all possible. + Show boundaries at periodic nodes too. Defaults to True. + direction : string + Show grain boundaries only across certain directions. [X=0,Y=1,Z=2]. Defaults to all possible. """ coord=grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') @@ -933,7 +933,7 @@ class Geom: [0, np.prod(self.grid[:2]+1), np.prod(self.grid[:2]+1)+1, 1], [0, 1, self.grid[0]+1+1, self.grid[0]+1]] - for d_s in [0,1,2]: + for d_s in [ord(i)-120 for i in direction]: mask = self.material != np.roll(self.material,1,d_s) for d in [0,1,2]: extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) From 7abc32b09c6067523550bb7bfd054c646d27435a Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Tue, 24 Nov 2020 19:59:46 +0100 Subject: [PATCH 17/22] alternative for if d_s== , not sure it improves the previous --- python/damask/_geom.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 587860742..618c7bb5a 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -938,11 +938,15 @@ class Geom: for d in [0,1,2]: extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) mask = np.concatenate((mask,extra_layer),d) + eval(f"if periodic: mask[{'0' if d_s==0 else ':'}"+f",{'0' if d_s==1 else ':'}"+ f",{'0' if d_s==2 else ':'}]= \ + [] mask[{'-1' if d_s==0 else ':'}"+f",{'-1' if d_s==1 else ':'}"+ f",{'-1' if d_s==2 else ':'}]=False") if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False + #eval('if periodic: mask['+','.join(['0' if d_s==d else ':' for d in range(3)])+']=\ + #mask['+','.join(['-1' if d_s==d else ':' for d in range(3)])+']=False') base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) - vtk = VTK.from_unstructuredGrid(coord,connectivity,'QUAD') + vtk=VTK.from_unstructuredGrid(coord,connectivity,'QUAD') vtk.save(f'GrainBoundaries{d_s}') From cd58278a0100bdf0e2a5f498f5132aa8d0e9ba5c Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 25 Nov 2020 10:39:58 +0100 Subject: [PATCH 18/22] returns vtk object --- python/damask/_geom.py | 36 ++++++++++++++++-------------------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 618c7bb5a..088387dc0 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -914,16 +914,16 @@ class Geom: v.save('GrainBoundaries') - def get_grain_boundaries(self,periodic=True,direction='xyz'): + def get_grain_boundaries(self,periodic=True,direction='x'): """ - Create VTK files to show grain boundaries as feature edges. + Create mesh in VTK to show grain boundaries as feature edges. Parameters ---------- periodic : Boolean, optional Show boundaries at periodic nodes too. Defaults to True. direction : string - Show grain boundaries only across certain directions. [X=0,Y=1,Z=2]. Defaults to all possible. + Show grain boundaries only across a certain direction. ['x','y','z'] """ coord=grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') @@ -932,21 +932,17 @@ class Geom: o = [[0, self.grid[0]+1, np.prod(self.grid[:2]+1)+self.grid[0]+1, np.prod(self.grid[:2]+1)], [0, np.prod(self.grid[:2]+1), np.prod(self.grid[:2]+1)+1, 1], [0, 1, self.grid[0]+1+1, self.grid[0]+1]] - - for d_s in [ord(i)-120 for i in direction]: - mask = self.material != np.roll(self.material,1,d_s) - for d in [0,1,2]: - extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) - mask = np.concatenate((mask,extra_layer),d) - eval(f"if periodic: mask[{'0' if d_s==0 else ':'}"+f",{'0' if d_s==1 else ':'}"+ f",{'0' if d_s==2 else ':'}]= \ - [] mask[{'-1' if d_s==0 else ':'}"+f",{'-1' if d_s==1 else ':'}"+ f",{'-1' if d_s==2 else ':'}]=False") - if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False - if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False - if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False - #eval('if periodic: mask['+','.join(['0' if d_s==d else ':' for d in range(3)])+']=\ - #mask['+','.join(['-1' if d_s==d else ':' for d in range(3)])+']=False') - base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) - connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) - vtk=VTK.from_unstructuredGrid(coord,connectivity,'QUAD') - vtk.save(f'GrainBoundaries{d_s}') + + d_s=ord(direction)-120 # x=0, y=1, z=2 + mask = self.material != np.roll(self.material,1,d_s) + for d in [0,1,2]: + extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) + mask = np.concatenate((mask,extra_layer),d) + if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False + if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False + if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False + base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) + connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) + return VTK.from_unstructuredGrid(coord,connectivity,'QUAD') + From eb085958f889710827195d1abd72a769cd30a3f3 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 25 Nov 2020 11:32:07 +0100 Subject: [PATCH 19/22] polishing --- python/damask/_geom.py | 80 +++--------------------------------------- 1 file changed, 4 insertions(+), 76 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 088387dc0..c0383062b 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -842,78 +842,6 @@ class Geom: comments = self.comments+[util.execution_stamp('Geom','vicinity_offset')], ) - def ShowGB(self,periodic=False): - """ - Create an extra VTK file to show grain boundaries as feature edges. - - Parameters - ---------- - periodic : Boolean, optional - Show boundaries at periodic nodes too. Defaults to False. - - """ - v = VTK.from_polyData(grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F')) - cells = vtk.vtkCellArray() - - index={} - nodes={} - nodes_PBC={} - if periodic: - nodes_PBC['0']=np.array([]) - nodes_PBC['1']=np.array([]) - nodes_PBC['2']=np.array([]) - else: - nodes_PBC['0']=np.concatenate(( - np.arange(0 , np.prod(self.grid+1) , (self.grid[0]+1) ), - np.arange(self.grid[0] , np.prod(self.grid+1) , (self.grid[0]+1) ) )) - nodes_PBC['2']=np.concatenate(( - np.arange(0 , np.prod(self.grid[:2]+1) , 1 ), - np.arange(np.prod(self.grid+1) - np.prod(self.grid[:2]+1), \ - np.prod(self.grid+1) , 1 ) )) - nodes_PBC['1']=np.concatenate(( - np.concatenate([np.arange((i)*np.prod(self.grid[:2]+1), \ - (i)*np.prod(self.grid[:2]+1)+ (self.grid[0]+1)) for i in range(self.grid[2]+1)]) , - np.concatenate([np.arange( (i+1)*np.prod(self.grid[:2]+1)-(self.grid[0]+1),\ - (i+1)*np.prod(self.grid[:2]+1)) for i in range(self.grid[2]+1)]) )) - - for d_s in [0,1,2]: - base_nodes = np.where(self.material==np.roll(self.material,1,d_s),False,True) - for d in [0,1,2]: - if d_s == d: - base_nodes = np.concatenate((base_nodes,np.take(base_nodes,[0],d)),d) - else: - base_nodes = np.concatenate((base_nodes,np.logical_and(np.take(base_nodes,[0],d),False)),d) - nodes['{}'.format(d_s)]= np.argwhere(base_nodes.flatten(order='F'))[:,0] - index['{}'.format(d_s)]=np.isin(nodes['{}'.format(d_s)],nodes_PBC['{}'.format(d_s)],assume_unique=True,invert=True) - - for p in nodes['0'][index['0']]: - q = vtk.vtkQuad() - q.GetPointIds().SetId(0, p) - q.GetPointIds().SetId(1, p+(self.grid[0]+1)) - q.GetPointIds().SetId(2, p+np.prod(self.grid[:2]+1)+(self.grid[0]+1)) - q.GetPointIds().SetId(3, p+np.prod(self.grid[:2]+1)) - cells.InsertNextCell(q) - - for p in nodes['1'][index['1']]: - q = vtk.vtkQuad() - q.GetPointIds().SetId(0, p) - q.GetPointIds().SetId(1, p+np.prod(self.grid[:2]+1)) - q.GetPointIds().SetId(2, p+np.prod(self.grid[:2]+1)+1) - q.GetPointIds().SetId(3, p+1) - cells.InsertNextCell(q) - - for p in nodes['2'][index['2']]: - q = vtk.vtkQuad() - q.GetPointIds().SetId(0, p) - q.GetPointIds().SetId(1, p+1) - q.GetPointIds().SetId(2, p+(self.grid[0]+1)+1) - q.GetPointIds().SetId(3, p+(self.grid[0]+1)) - cells.InsertNextCell(q) - - v.vtk_data.SetPolys(cells) - v.save('GrainBoundaries') - - def get_grain_boundaries(self,periodic=True,direction='x'): """ Create mesh in VTK to show grain boundaries as feature edges. @@ -921,7 +849,7 @@ class Geom: Parameters ---------- periodic : Boolean, optional - Show boundaries at periodic nodes too. Defaults to True. + Show boundaries across periodicity. Defaults to True. direction : string Show grain boundaries only across a certain direction. ['x','y','z'] @@ -938,9 +866,9 @@ class Geom: for d in [0,1,2]: extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) mask = np.concatenate((mask,extra_layer),d) - if d_s == 0 and periodic: mask[0,:,:] = mask[-1,:,:] = False - if d_s == 1 and periodic: mask[:,0,:] = mask[:,-1,:] = False - if d_s == 2 and periodic: mask[:,:,0] = mask[:,:,-1] = False + if d_s == 0 and not periodic: mask[0,:,:] = mask[-1,:,:] = False + if d_s == 1 and not periodic: mask[:,0,:] = mask[:,-1,:] = False + if d_s == 2 and not periodic: mask[:,:,0] = mask[:,:,-1] = False base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) return VTK.from_unstructuredGrid(coord,connectivity,'QUAD') From 31df4c04c8469d592f2ebd761bcc8f17cddf88af Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 25 Nov 2020 12:51:52 +0100 Subject: [PATCH 20/22] added test --- .../Geom/get_grain_boundaries_4g12x15x20.vtr | 30 ++++++++++++++++ ...grain_boundaries_4g12x15x20_x_perFalse.vtu | 35 +++++++++++++++++++ ..._grain_boundaries_4g12x15x20_x_perTrue.vtu | 35 +++++++++++++++++++ ...grain_boundaries_4g12x15x20_y_perFalse.vtu | 35 +++++++++++++++++++ ..._grain_boundaries_4g12x15x20_y_perTrue.vtu | 35 +++++++++++++++++++ ...grain_boundaries_4g12x15x20_z_perFalse.vtu | 35 +++++++++++++++++++ ..._grain_boundaries_4g12x15x20_z_perTrue.vtu | 35 +++++++++++++++++++ python/tests/test_Geom.py | 9 +++++ 8 files changed, 249 insertions(+) create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20.vtr create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perFalse.vtu create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perTrue.vtu create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perFalse.vtu create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perTrue.vtu create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perFalse.vtu create mode 100644 python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perTrue.vtu diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20.vtr b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20.vtr new file mode 100644 index 000000000..dc1924d58 --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20.vtr @@ -0,0 +1,30 @@ + + + + + + AQAAAACAAABdAAAAYAAAAA==eF4NwlsKgCAQAMCO4mcRK6tmrwt0g35jKXuQtqHR+WuYhQKlUw6Og1wjh2nkyBcf0+NSct7Tc/AlXiNRIpC/dwJra9hW03Tk5qUVuUaNoBRoKxT2lf6XqBCL7APiGxu3 + + + + + + + + AQAAAACAAACAcAAAFwQAAA==eF7t2sFuYzkQQ9Gk+///uTddm0KIy6JUdmCbG2KAV0e2n6QBJvP19XO+//cf0X9FU77NnroVcnu7ISf1aZ663ocKzStPdYWcqdv31S3P3bc0R63cV/Er5KRuhbxTv0Lus32Kex6moXNX7X7OHnJ7uyEn9WnebRWaU03vm+anbt+v5Lieex623O37s4ec3+5XyEvdCrnKn8b1p6FzkYbc03XIS31yUp/m3VahObd76HlqtV9pbuqp80De1KXznHrTe4gc16eQp3w35PVOQ+70c/eQn4b2bRpyT9chL/XJSX2ad1uF5tzuoefd7vuVnndbnQeam3rqPPffLfXS80xO6lbIO/UrW25l21fv+zS0X9OQe7oOealPTurTvNsqNOd2Dz0/7Qo9N+1+Luh5avc8T7+X67oh79SvbLmVbb+y5dJ+T0P7KQ25p+uQl/rkpD7Nu61Cc2730PPTrtBzad+6n7unznP6vW7dQ+Slbs+2X9lyK1s+7fc0tI/SkHu6DnmpT07q07zbKjTndg89P+0KPfdbu+f0e53eE8rbuoe23Mq2T+8zjbtfpqH9k4bc03XIS31yUp/m3VahObd76PlpV+i5tKd/F5y2+ntg/+dpp3+f2nJVtu/P7fTf51bU738aer9pyD1dh7zUJyf1ad5tFZpzu4een3aFnkt7635W/1/F6fdy/38NlS1Xpe7lR/u30n+fW1Hv4TS0f9KQe7oOealPTurTvNsqNOd2Dz0/7Wfdn2krV90f5FXTPefeT8p1fTdbbg/5p6H3mob2TxraR6lPbu9pyEt9clKf5t1WoTm3e+h5t7fuT/LTdeiemK6j/rsweXT+6O925KY+ea5fSX03U38adz9Ok+53Cu1/tY4bcnu7ISf1ad5tFZpzu78Hep6azgPNk0u+u96te6ivc+v+7E1u6vfc8lVOXfIr276731P3tk/ni9xTn9ZRIY/WUaF5t1VoTjW9b5pXXnoepu7UrybvUT45r+pXbvs9W27llv/oz0/nmLxT312nh7zUJ8e9l04/9+l52HK7T17qV5P3Kj45Hz/rym33UT6dX5qnz033EDmpm65DjnsvpZ+bXPe9TL2pX01O6n58r8lL3XfxaZ5626d1aI6a7iGan7qn/55xPWp3HXJSn+apn+2n65D3rj45Hz9rcrd9mqeme47mXffWOq7ndvq7U9P3oHnqZ/vpOuR9/FmTl7of32u6f2hedYXuO3Km7uk6rue2+7nJmb4Xmqd+dT9dh7yPP2vyUnfb77nl97j3BLmu35u81J3e0xVy6Hfq3XPLpe+TeuRO9/27+uk65L2rT86jfJVTX8W9J2777j2tQh6to0Lz7u+lQs70Xq3vc8tz3/uWOz1Xv9VP1yHvVfwKeVNf5dSt/gdcjxTB + + + + + AQAAAACAAABoAAAANAAAAA==eF5jYICAUDDYag+hj9pDRC9A+VftV4HBLaj4Ayj/EVT+KVT8BVT8FVT8LVT8gz0An9sjLg== + + + AQAAAACAAACAAAAASAAAAA==eF5jYIAAQTDYaA+hD9rPmgkCJ6H8i/ahYHAVKn7T/t5dMIDKP7Q3BoPHUHVP7cvB4DlU/Uv7PbtB4DVU31t7iK0f7AHaRzOg + + + AQAAAACAAACoAAAAVQAAAA==eF5jYICAWTNBYKU9hN5pb2IMAoeh/JP2EFUXoOKX7dPTQOAaVP6m/dkzIHAHqu4BVPwhVP1jqPwTqL5nUHUvoOpeQtW9hqp7A1X3Dqrugz0ASSZF3Q== + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perFalse.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perFalse.vtu new file mode 100644 index 000000000..62809aa74 --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perFalse.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADAVQAASRMAAA==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 + + + AQAAAACAAABwFQAAvgMAAA==eF411xGbAogCQNF5+3q77X5BEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEATBwEAQBEEQBEEQBEEQLMx5V85vuIGv34IMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaeccc4Fl1xxzQ233PGbP9zzwCNPPPPCK2+888EnX3zzw6///BJgkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhlDPOueCSK6654ZY7fvOHex545IlnXnjljXc++OSLb3749ccvAQYZYpgRRhljnAkmmWKaGWaZY54FFllimRVWWWOdDTbZYpsddtljnwMOOeKYE04545wLLrnimhtuueM3f7jngUeeeOaFV95454NPvvjmh1///SXAIEMMM8IoY4wzwSRTTDPDLHPMs8AiSyyzwiprrLPBJltss8Mue+xzwCFHHHPCKWecc8ElV1xzwy13/OYP9zzwyBPPvPDKG+988MkX3/zwKwAGGWKYEUYZY5wJJplimhlmmWOeBRZZYpkVVlljnQ022WKbHXbZY58DDjnimBNOOeOcCy654pobbrnjN3+454FHnnjmhVfeeOeDT7745odf//slwCBDDDPCKGOMM8EkU0wzwyxzzLPAIksss8Iqa6yzwSZbbLPDLnvsc8AhRxxzwilnnHPBJVdcc8Mtd/zmD/c88MgTz7zwyhvvfPDJF9/88OvPXwIMMsQwI4wyxjgTTDLFNDPMMsc8CyyyxDIrrLLGOhtsssU2O+yyxz4HHHLEMSeccsY5F1xyxTU33HLHb/5wzwOPPPHMC6+88c4Hn3zxzQ+//volwCBDDDPCKGOMM8EkU0wzwyxzzLPAIksss8Iqa6yzwSZbbLPDLnvsc8AhRxxzwilnnHPBJVdcc8Mtd/zmD/c88MgTz7zwyhvvfPDJF9/88P/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM8654JIrrrnhljt+84d7HnjkiWdeeOWNdz745Itvfvj19y8BBhlimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjnAsuueKaG2654zd/uOeBR5545oVX3njng0+++OaHX//8EmCQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM8654JIrrrnhlv8CkVFZCg== + + + AQAAAACAAACuAgAADwAAAA==eF7j5BwFo2CoAABgzxgf + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perTrue.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perTrue.vtu new file mode 100644 index 000000000..adeddd7cb --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_x_perTrue.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAYgAAJhYAAA==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 + + + AQAAAACAAACAGAAAPgQAAA==eF412BGjAggChdG3u81OuxMEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEwYMHQRAEQRAEQRAEA+/MlfMb7hf4+l2QIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM8654JIrrrnhljvueeA3f3jkiWdeeOWNdz745Itvfvj1r18CDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjvsssc+BxxyxDEnnHLGORdccsU1N9xyxz0P/OYPjzzxzAuvvPHOB5988c0Pv/79S4BBhhhmhFHGGGeCSaaYZoZZ5phngUWWWGaFVdZYZ4NNtthmh1322OeAQ4445oRTzjjngkuuuOaGW+6454Hf/OGRJ5554ZU33vngky+++eHXf34JMMgQw4wwyhjjTDDJFNPMMMsc8yywyBLLrLDKGutssMkW2+ywyx77HHDIEceccMoZ51xwyRXX3HDLHfc88Js/PPLEMy+88sY7H3zyxTc//AqAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZodd9tjngEOOOOaEU84454JLrrjmhlvuuOeB3/zhkSeeeeGVN9754JMvvvnh1x+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki2122GWPfQ445IhjTjjljHMuuOSKa2645Y57HvjNHx554pkXXnnjnQ8++eKbH37995cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5xxzgWXXHHNDbfccc8Dv/nDI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGedccMkV19xwyx33PPCbPzzyxDMvvPLGOx988sU3P/zn8AcYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445YxzLrjkimtuuOWOex74zR8eeeKZF155450PPvnimx9+/e+XAIMMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaeccc4Fl1xxzQ233HHPA7/5wyNPPPPCK2+888EnX3zzw6///xJgkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhlDPOueCSK6654ZY77nngN3945IlnXnjljXc++OSLb3749dcvAQYZYpgRRhljnAkmmWKaGWaZY54FFllimRVWWWOdDTbZYpsddtljnwMOOeKYE04545wLLrnimhtuueOeB37zh0eeeOaFV95454NPvvjmh/+E/gCDDDHMCKOMMc4Ek0wxzQyzzDHPvwEDBI18 + + + AQAAAACAAAAQAwAAEAAAAA==eF7j5BwFo2AUwAAAR84bkQ== + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perFalse.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perFalse.vtu new file mode 100644 index 000000000..690af021c --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perFalse.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==eF51nUGO5VgRRf8WWAvMexWshbXADmDGgEEJJinkQc2cKnlQSCCnW0+4jCx5CajTir7yiXs9+eTN0CH7yPb7HYrX7/Xy1+8/r7/95POp5fc1h/ql5X/5vP4VOGuo3wJ/BM4eOEfgnIFzhfz1+s3n9ddff1/efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIS9vb8Eb86nl9zWH+qXlT2/krKF+C/wROHvgHIFzBs4V8tfrT3/85fravPl8avl9zaF+aXl585w11G+BPwJnD5wjcM7AuUJe99t7uN+YTy2/rznULy1/3m/krKF+C/wROHvgHIFzBs4V8v7+Lm8+n1p+X3OoX1pe3jxnDfVb4I/A2QPnCJwzcK6Q13P6vXnz+dTy+5pD/dLy8uY5a6jfAn8Ezh44R+CcgXOF/PX6z78/r+bN51PL72sO9UvLy5vnrKF+C/wROHvgHIFzBs4V8nq/fTRvPp9afl9zqF9aXt48Zw31W+CPwNkD5wicM3CukL9ev/28fm7efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIdf///PnWheYTy2/rznULy0vb56zhvot8Efg7IFzBM4ZOFfIX68/fF7/bd58PrX8vuZQv7S8vHnOGuq3wB+BswfOEThn4Fwhr/X0R/Pm86nl9zWH+qXl5c1z1lC/Bf4InD1wjsA5A+cK+ev1j7//cv2vefP51PL7mkP90vLy5jlrqN8CfwTOHjhH4JyBc4W8voec4NT3EOZTy+9rDvVLy8ub56yhfgv8ETh74ByBcwbOFXL9vv5XefP51PL7mkP90vLyxvy+1lC/Bf4InD1wjsA5A+cKua77Of7zT09vzKeW3z/NoX5p+dMbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTymzKH+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv3hvzqeVPb6xfWv70Rs4a6rfAH4GzB84ROGfgXCFX/43efD61vLz5+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv9ObzqeXlzdcvLX/eb+SsoX4L/BE4e+AcgXMGzhVyfj+VN59PLS9vvn5peXnznDXUb4E/AmcPnCNwzsC5Qq7+G735fGp5efP1S8vLm+esoX4L/BE4e+AcgXMGzhVy9d/ozedTy8ubr19aXt48Zw31W+CPwNkD5wicM3CukKv/Rm8+n1pe3nz90vLy5jlrqN8CfwTOHjhH4JyBc4Vc/Td68/nU8vLm65eWlzfPWUP9FvgjcPbAOQLnDJwr5OwrcF1gPrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpDXdYGj/hu9Mb9/nkP90vLy5jlrqN8CfwTOHjhH4JyBc4Vc151/gTfm7L99gTfWs//2Bd7IYf/tC7yRz/5bcdh/+wJv5LD/Vhz23778+vP9va76S/Lmc/bf5M3Xs/8mb57D/pu8eT77b/LmOey/yZvnsP9Gb2/gsP9Gb2/gsP9Gb2/4+9l/ozfWs/9Gb+Sw/0Zv5LD/Rm/M2X+TN5+z/yZvvp79N3nzHPbf5M3z2X+TN89h/03ePIf9N95v7+Cw/8b77R0c9t94vyl/3m/ksP/G+4189t94v5HD/hvvN3LYf5O3530hbz5n/03efD37b/LmOey/yZvns/8mb57D/pu8eQ77b3xOv4PD/huf0+/gsP/G51R5efMc9t/4nJLP/hufU3LYf+NzSg77b/L27C/Jm8/Zf5M3X8/+m7x5Dvtv8ub57L/Jm+ew/yZvnsP+G99vH+Cw/8b32wc47L/x/faBv5/9N77fWM/+G99v5LD/xvcbOey/8f3GnP03efM5+2/y5uvZf5M3z2H/Td48n/03efMc9t/kzXPYf+O6MMBh/43rwgCH/TeuCwN/P/tvXBdYz/4b1wVy2H/jukAO+29cF5iz/yZvPmf/Td58Pftv8uY57L/Jm+ez/yZvnsP+m7x5DvtvXE9/gMP+G9fTH+Cw/8b1VHl58xz237ieks/+G9dTcth/43pKDvtv8vbsL8mbz9l/kzdfz/6bvHkO+2/y5vnsv8mb57D/Jm+ew/6bvD37S/Lmc/bf5M3Xs//G7yHksP/G7yHks/8mb57D/pu8eQ77b/JWv6c3n7P/Jm++nv03efMc9t/kzfPZf5M3z2H/Td48h/03enu9fve53v4T3phPLb9/mkP90vKnN3LWUL8F/gicPXCOwDkD5wq5+m/05vOp5TdlDvVLy8ub56yhfgv8ETh74ByBcwbOFXL137w35lPLn95Yv7T86Y2cNdRvgT8CZw+cI3DOwLlCrv4bvfl8anl58/VLy8ub56yhfgv8ETh74ByBcwbOFXL13/z9xnxqeXnz9UvLn/cbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTy8ubrl5aXN89ZQ/0W+CNw9sA5AucMnCvk6r/Rm8+nlpc3X7+0vLx5zhrqt8AfgbMHzhE4Z+BcIVf/jd58PrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpCr/0ZvPp9aXt58/dLy8uY5a6jfAn8Ezh44R+CcgXOFXP03evP51PLy5uuXlpc3z1lD/Rb4I3D2wDkC5wycK+Tqv9Gbz6eWlzdfv7S8vHnOGuq3wB+BswfOEThn4Fwhr+tq3nw+tfz+eQ71S8vLm+esoX4L/BE4e+AcgXMGzhVyXfXvr09vzDn/9hXeWM/5t6/wRg7n377CG/mcfysO59++whs5nH8rDuffvv768/29rua75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+jtzdwOP9Gb2/gcP6N3t7w93P+jd5Yz/k3eiOH82/0Rg7n3+iNOeff5M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH/j/fYODuffeL+9g8P5N95vyp/3Gzmcf+P9Rj7n33i/kcP5N95v5HD+Td54X5Q3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jc/pd3A4/8bn9Ds4nH/jc6q8vHkO59/4nJLP+Tc+p+Rw/o3PKTmcf5O36i/Rm885/yZvvp7zb/LmOZx/kzfP5/ybvHkO59/kzXM4/8b32wc4nH/j++0DHM6/8f32gb+f8298v7Ge8298v5HD+Te+38jh/Bvfb8w5/yZvPuf8m7z5es6/yZvncP5N3jyf82/y5jmcf5M3z+H8G9eFAQ7n37guDHA4/8Z1YeDv5/wb1wXWc/6N6wI5nH/jukAO59+4LjDn/Ju8+Zzzb/Lm6zn/Jm+ew/k3efN8zr/Jm+dw/k3ePIfzb1xPf4DD+Teupz/A4fwb11Pl5c1zOP/G9ZR8zr9xPSWH829cT8nh/Ju8Pee75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+Tt+ov0ZvPOf8mb76e82/8HkIO59/4PYR8zr/Jm+dw/k3ePIfzb/JWv6c3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jd7qmuGN+dTy5yfr+3+P++lN+f3J8xdmeFP+9Kb8/uT5CzO8KX96U35/8r+Xp3/O+3tdnS8gbz6fWl6fvn5peXnzHJ6/IG+ePwKH5y/Im+fw/AV58znPX6A35lPL69PXLy1/eiOH5y/QG/kjcHj+Ar2Rw/MX6I1573eXN59PLa9PX9/7JuXNc3j+grx5fv/+fX/y/AV585y+zt2f6T3O8xd4vzGfWl6fvn5p+fN+I4fnL/B+I38EDs9f4P1GDs9f4P3GnP/dU3nzOc9fmPF71vP8BXnzHJ6/IG+ez/MX5M1zeP6CvHnOFXL1354c9d+e+dTy+vT1S8vLm+fw/AU+p+SPwOH5C3xOyTkD5wo5z1+QN5/z/AV58/U8f0HePIfnL8ib5/P8BXnzHJ6/IG+ew/MX+H77AEf9t2c+tbw+ff3S8vLmOTx/ge838kfg8PwFvt/I4fkLfL8x5/kL8uZznr8gb76e5y/Im+fw/AV583yevyBvnsPzF+TNc3j+AteFAQ7PX+C6MMCZQz3PX+C6QA7PX+C6QD7PX+C6QA7PX+C6QM4Vcp6/IG8+5/kL8ubref6CvHkOz1+QN8/n+Qvy5jk8f0HePIfnL3A9/dG8+XxqeX36+qXl5c1zeP4C11PyR+Dw/AWup+ScgXOFnOcvyJvPef6CvPl6nr8gb57D8xfkzfN5/oK8eQ7PX5A3z+H5C/JW/aUnh+cvyBvz+vT1PH+B30PI4fkL/B5CPs9fkDfP4fkL8uY5PH9B3ur3T476b898avnzk/VLy8ub5/D8BXljXt48h+cvyJvn8PwF/vMw13XPxX2DN+bcf/qt8Z713H/6Dd7I4f7Tb/BGPvefFof7T7/BGzncf1qcK+TcfypvPuf+U3nz9dx/Km+ew/2n8ub53H8qb57D/afy5jncf0pvb+Bw/ym9vYHD/af09oa/n/tP6Y313H9Kb+Rw/ym9kcP9p/TGnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN48h/tPeb+9g8P9p7zf3sHh/lPeb+/4+7n/lPcb67n/lPcbOdx/yvuNHO4/5f3GnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN485wo595/yOWXO/ad8TlnP/ad8Tsnh/lM+p+Rz/ymfU3K4/5TPKTncfypv1V+iN59z/6m8+XruP5U3z+H+U3nzfO4/lTfP4f5TefMc7j/l++0DHO4/5fvtAxzuP+X77QN/P/ef8v3Geu4/5fuNHO4/5fuNHO4/5fuN+ev1f33QNPp4XnWdQa4dSRFF3xZYi3vuVbAFWAJrgSUwY8AIJh7kAAmkslAiGdEof7ZTpBOllEtA/kV0qG7EqUnpnb46bV29/+t1tOPlhw/fr58+/vB+//vHX75ff/z4IeUl8Nf7dUG+Bv779+uf4GmQ7+Af4JngWeDZ4DnAXy/792tvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA/z1+s379Z/QW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wB/vX732+/Xt9Bbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAH+9/vyn79d/Q285L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D/PX694/frx16y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOB2ndBbzkvg9+sL8jVw6y33NMh38A/wTPAs8GzwHOB+/fpX369/SG/KS+D3qwvyNfBnb+ppkO/gH+CZ4Fng2eA5wF+vX7xff/ioveW8BH5bLsjXwK233NMg38E/wDPBs8CzwXOAW2+foDflJfBnb5qvgT97U0+DfAf/AM8EzwLPBs8Bbp9D/hJ6y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOD2fvsM7zflJXDrLc/XwJ/vN/U0yHfwD/BM8CzwbPAc4PbfWTX0lvMSuPWW52vg1lvuaZDv4B/gmeBZ4NngOcDt5/RL6C3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA2+feH0NvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9x+v72F3nJeArfe8nwN3HrLPQ3yHfwDPBM8CzwbPAf46/X+MfjDT6G3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23VCbzkvgd+vL8jXwK233NMg38E/wDPBs8CzwXOA+2Wfi5+9KS+B368uyNfAn72pp0G+g3+AZ4JngWeD5wD3+Zv2lvMS+G25IF8Dt95yT4N8B/8AzwTPAs8GzwHu87e8N+Ul8Gdvmq+BP3tTT4N8B/8AzwTPAs8GzwHu8zftLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zXw5/tNPQ3yHfwDPBM8CzwbPAe4z9+0t5yXwK23PF8Dt95yT4N8B/8AzwTPAs8GzwHuzwntLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23XE4/M37U35/fqCfA3cess9DfId/AM8EzwLPBs8B7hff/vr9+tf0pvyEvj96oJ8DfzZm3oa5Dv4B3gmeBZ4NngOcJ+/aW85L4HflgvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/y3tTXgJ/9qb5GvizN/U0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/f8veb8hK49Zbna+DP95t6GuQ7+Ad4JngWeDZ4DnCfv2lvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9znb9pbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+pr3lvARuveX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/aW85L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D3Odv2lvOS+DWW56vgVtvuadBvoN/gGeCZ4Fng+cA9/mb9pbzErj1ludr4NZb7mmQ7+Af4JngWeDZ4DnAff6mveW8BG695fkauPWWexrkO/gHeCZ4Fng2eA5wn79pbzkvgVtveb4Gbr3lngb5Dv4BngmeBZ4NngPc52/aW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wC364Tecl4Cv19fkK+BW2+5p0G+g3+AZ4JngWeD5wDXq0lvykvg9/2CfA382Zvz513zHfwDPBM8CzwbPAe4z9+MW285L4Hf9wvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/e3p8/vbkJfD7fkG+Bv7sTT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuadBvoN/gGeCZ4Fng+cA9/nb0+Pztycvgd/3C/I18Of7TT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuUefJ95b7h/gmeBZ4NngOcDj3+e+cz5/e/IS+H2/IB//XqD1lnsa5Dv4498vue8TPAs88f/j3nf6/5Q+f3t6fP725CXw+35BvgZuveWeBvkO/gGeCZ4Fng2eA9znb0+Pz9+evAR+3y/I18Ctt9zTIN/BP8AzwbPAs8FzgPv87enx+duTl8Dv+wX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/PT0+f3vyEvh9vyBfA7feck+DfAf/AM8EzwLPBs8B7vO3p8fnb09eAr/vF+Rr4NZb7mmQ7+Af4JngWeDZ4DnAff729Pj87clL4Pf9gnwN3HrLPQ3yHfwDPBM8CzwbPAe4z9+eHp+/PXkJ/L5fkK+BW2+5p0G+g3+AZ4JngWeD5wD3+dvT4/O3Jy+B3/cL8jVw6y33NMh38A/wTPAs8GzwHOB2HfH4/O3JS+D3/YJ8Ddx6yz0N8j1w6y33TPAs8GzwHOB+3T/Hb9Kbct0/tc81un/6Jr05f/amHv29+ya9qV/3T82j+6dv0pt6dP/UPLp/+vbz6/tzne1Xem851/1T7y3P6/6p95Z7dP/Ue8v9un/qveUe3T/13nKP7p9qb5/Eo/un2tsn8ej+qfb2Sf78un+qvWle90+1N/Xo/qn2ph7dP9XelOv+qfeWc90/9d7yvO6fem+5R/dPvbfcr/un3lvu0f1T7y336P6pvt8+i0f3T/X99lk8un+q7zfnz/ebenT/VN9v6tf9U32/qUf3T/X9ph7dP/Xenu8L7y3nun/qveV53T/13nKPfl723nK/7p96b7lH90+9t9yj+6f6c/pFPLp/qj+nX8Sj+6f6c+rcess9un+qP6fq1/1T/TlVj+6f6s+penT/1Huz+ZL2lnPdP/Xe8rzun3pvuUf3T7233K/7p95b7tH9U+8t9+j+qf5+exOP7p/q77c38ej+qf5+e5M/v+6f6u83zev+qf5+U4/un+rvN/Xo/qn+flOu+6feW851/9R7y/O6f+q95R7dP/Xecr/un3pvuUf3T7233KP7p/pcGOLR/VN9Lgzx6P6pPheG/Pl1/1SfC5rX/VN9LqhH90/1uaAe3T/V54Jy3T/13nKu+6feW57X/VPvLffo/qn3lvt1/9R7yz26f+q95R7dP9Xn6Tfx6P6pPk+/iUf3T/V56tx6yz26f6rPU/Xr/qk+T9Wj+6f6PFWP7p96b8/9Su8t57p/6r3led0/9d5yj+6fem+5X/dPvbfco/un3lvu0f1T783mS9pbznX/1HvL87p/qp9D1KP7p/o5RP26f+q95R7dP/Xeco/un3pv9s+1t5zr/qn3lud1/9R7yz06n/becr/un3pvuUf3T7233KP7p9rb6/XD/5+3z96Ul8DvVxfka+DP3tTTIN/BP8AzwbPAs8FzgPv8TXvLeQn8tlyQr4Fbb7mnQb6Df4BngmeBZ4PnAPf5W96b8hL4szfN18CfvamnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+lr/flJfArbc8XwN/vt/U0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLuZ5/6r3leT3/1HvLPXr+qfeW+/X8U+8t9+j5p95b7tHzT/W5MMSj55/qc2GIR88/1efCkD+/nn+qzwXN6/mn+lxQj55/qs8F9ej5p/pcUK7nn3pvOdfzT723PK/nn3pvuUfPP/Xecr+ef+q95R49/9R7yz16/qk+T7+Jx+dv2pty6y3P18Ctt9yj55/q81T9Azx6/qk+T9WzwXOA6/mn3lvO9fxT7y3P6/mn3lvu0fNPvbfcr+efem+5R88/9d5yj55/6r3ZfEl7y7mef+q95Xk9/1Q/h6hHzz/VzyHq1/NPvbfco+efem+5R88/9d7sn2tvOS+B368vyNfArbfc0yCv5596b7lHzz/13nKPnn/qveXcr3sv9av0ply//+2r9KZ5/f63r9Kbehrk9fvfvkpv6tHvf/sqvalHv//NPPr9b19/fn1/rrPvN/Pecq7f/+a95Xn9/jfvLffo9795b7lfv//Ne8s9+v1v3lvu0e9/094+ffwfkHMVtHhedZ0xjnU5EUZ7C6wF8n8VbAGWwFpgCWQERJBM4ACJkS6Bg0ECeQwGjwePvAT091Wp5K/q3OSpD6Wj4ei9fj0VTH3716/Pv7/88vP545effT7ffPn24iXwj8/ngfka+O8/n7+Dp8F8B/8AzwTPAs8GzwH+8fG73359/iKeP37JeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4B8fb8+/hW45L4Fbt3y+Bn6/39TTYL6Df4BngmeBZ4PnAP/4sP9/2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA2+f0u9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgH98/PMfn0/olvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcDt99v3oVvOS+DWLZ+vgVu33NNgvoN/gGeCZ4Fng+cA//j4+efzr9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNv3wgjdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B/jHx28+n/+GbjkvgVu3fL4Gbt1yT4P5Dv4BngmeBZ4NngPcvk9/CN1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwH+MfHn//09fkxdMt5Cdy65fM1cOuWexrMd/AP8EzwLPBs8Bzg9nfIDt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuD0ndMt5Cfz9+YH5Grh1yz0N5jv4B3gmeBZ4NngOcH9+/auvz3+km/IS+PvTA/M18LubehrMd/AP8EzwLPBs8Bzg9nfvH75ot5yXwF/LA/M1cOuWexrMd/AP8EzwLPBs8Bzg1u0b6Ka8BH530/ka+N1NPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+7f8/aa8BG7d8vka+P1+U0+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+zftlvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7jv37Rbzkvg1i2fr4Fbt9zTYL6Df4BngmeBZ4PnAPf9m3bLeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4L5/0245L4Fbt3y+Bm7dck+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5we07olvMS+PvzA/M1cOuWexrMd/AP8EzwLPBs8Bzg+kzpprwE/r4+MF8Dv7s5f18bzHfwD/BM8CzwbPAc4L5/M27dcl4Cf18fmK+BW7fc02C+g3+AZ4JngWeD5wD3/dvt8f3bzUvg7+sD8zXwu5t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gGeCZ4Fng2eA9z3b7fH9283L4G/rw/M18Dv95t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gEe/V7ybrlng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzgvn+7Pb5/u3kJ/H19YL4Gbt1yT4P5Dv4BngmeBZ4NngPc92+3x/dvNy+Bv68PzNfArVvuaTDfwT/AM8GzwLPBc4D7/u32+P7t5iXw9/WB+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv90e37/dvAT+vj4wXwO3brmnwXwH/wDPBM8CzwbPAe77t9vj+7ebl8Df1wfma+DWLfc0mO/gH+CZ4Fng2eA5wH3/dnt8/3bzEvj7+sB8Ddy65Z4G8x38AzwTPAs8GzwHuO/fbo/v325eAn9fH5ivgVu33NNgvoN/gGeCZ4Fng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzg9hzx+P7t5iXw9/WB+Rq4dcs9DeZ74NYt90zwLPBs8Bzg/tjn+O6mvAT+/vTAfA387qaeBvMd/AM88ff33U09GzwHuO/ftFvOS+Cv5YH5Grh1yz0N5jv4B3gmeBZ4NngOcN+/5d2Ul8DvbjpfA7+7qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN/H6/qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4Il/d1u33LPBc4D7/k275bwEbt3y+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv2m3nJfArVs+XwO3brmnwXwH/wDPBM8CzwbPAe77N+2W8xK4dcvna+DWLfc0mO/gH+CZ4Fng2eA5wH3/pt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuO/ftFvOS+DWLZ+vgVu33NNgvoN/gCfuS6xb7tngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7j/e5d2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNtzxOP7N+2m/P35gfkauHXLPQ3mO/gHeOKe27rlng2eA9yfX3x+3/4o3ZSXwN+fHpivgd/d1NNgvoN/gGeCZ4Fng+cA9/2bdst5Cfy1PDBfA7duuafBfAf/AM8EzwLPBs8B7vu3vJvyEvjdTedr4Hc39TSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479/y95vyErh1y+dr4Pf7TT0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479+0W85L4NYtn6+BW7fc02C+g3+AZ4JngWeD5wD3/Zt2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgPv+TbvlvARu3fL5Grh1yz0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnA7TmhW85L4O/PD8zXwK1b7mkw38E/wDPBs8CzwXOA+/P+d+H+J92Ul8Dfnx6Yr4Hf3dTTYL6Df4BngmeBZ4PnAPf9m3bLeQn8tTwwXwO3brmnwXwH/wDPBM8CzwbPAe77t7yb8hL43U3na+B3N/Xo/QXtpv4BHr2/oN3Uo/cXtJtyvb/g3XJeArdu+XwN3LrlHr2/4N1y/wCP3l/wbrlH7y94t5zr/QV9vykvgVu3fL4Gfr/f1KP3F/T9pv4BHr2/oO839ej9BX2/Kdf7C94t53p/wbvl83p/wbvlHr2/4N1yv95f8G65R+8veLfco/cX9HP6nXh8/6bdlFu3fL4Gbt1yj95f0M+p+gd49P6Cfk7Vo/cX9HOqXO8veLec6/0F75bP6/0F75Z79P6Cd8v9en/Bu+Uevb/g3XKP3l/Q32/fi8f3b9pNuXXL52vg1i336P0F/f2m/gEevb+gv9/Uo/cX9Pebcr2/4N1yrvcXvFs+r/cXvFvu0fsL3i336/0F75Z79P6Cd8s9en9BvxeGePT+gn4vDPHo/QX9Xhjyz6/3F/R7Qef1/oJ+L6hngkfvL+j3gnr0/oJ3s/2Sdsu53l/wbvm83l/wbrlH7y94t9yv9xe8W+7R+wveLffo/QX9Pv1BPL5/027KrVs+XwO3brlH7y/o96n6B3j0/oJ+n6pH7y/o96lyvb/g3XKu9xe8Wz6v9xe8W+7R+wveLffr/QXvlnv0/oJ3yz16f8G72X5Ju+Vc7y94t3xe7y/o3yHq0fsL+neI+vX+gnfLPXp/wbvlHr2/4N3sf9duOS+Bvz8/MF8Dt265R+8veLfcP8AzwaP3F7xb7jnA/Xn/u3A/STflJfD3pwfma+B3N/Xo/YWfpJv6B3gmePT+wk/STT0HuN5f8G45L4G/lgfma+DWLffo/QXvlvsHePT+gnfLPXp/wbvlXO8vaDflJfC7m87XwO9u6tH7C9pN/QM8en9Bu6lH7y9oN+V6f8G75bwEbt3y+Rq4dcs9en/Bu+X+AR69v+Ddco/eX/BuOdf7C/p+U14Ct275fA38fr+pR+8v6PtN/QM8en9B32/q0fsL+n5TrvcXvFvO9f6Cd8vn9f6Cd8s9en/Bu+V+vb/g3XKP3l/wbrlH7y/o5/Q78fj+Tbspt275fA3cuuUevb+gn1P1D/Do/QX9nKpH7y/o51S53l/wbjnX+wveLZ/X+wveLffo/QXvlvv1/oJ3yz16f8G75R69v6C/374Xj+/ftJty65bP18CtW+7R+wv6+039Azx6f0F/v6lH7y/o7zflen/Bu+Vc7y94t3xe7y94t9yj9xe8W+7X+wveLffo/QXvlnv0/oJ+Lwzx6P0F/V4Y4tH7C/q9MOSfX+8v6PeCzuv9Bf1eUM8Ej95f0O8F9ej9Be9m+yXj/wcPgkTdeF51mLGtFDEURd0CtVDAVvFbgBKoBUogI9gIEgIHZCZwABLIGFkYIyOXgHatx2rmvvOSpz26e6S9mp0Z+enpNtfLq/v8urx8cZu/lzt+isLDfRLks/C39/kKngL5Cv4Gng6eAZ4JngU8hDevb/P75LlefB6FW29+Pgu33nxPgXwFfwNPB88AzwTPAh7Ch/e3+SO9+TwKt978fBZuvfmeAvkK/gaeDp4BngmeBTyE799uM6U3n0fh1pufz8KtN99TIF/B38DTwTPAM8GzgNss6c3nUfj+nCCfhVtvvqdAvoK/gaeDZ4BngmcBP8869XbmUfjeCfJZ+LG3B9+7QL6Cv4Gng2eAZ4JnAQ/h2X3e/c9Zbz6PwvdOkM/CrTffUyBfwd/A08EzwDPBs4Bbbx+htzOPwvdOkM/Cj72dPQXyFfwNPB08AzwTPAu4vYd8kt58HoXvnSCfhVtvvqdAvoK/gaeDZ4BngmcBt+vts/Tm8yh87wT5LPx4vZ09BfIV/A08HTwDPBM8C3gI9vuOnqs8D623M987QT4Lt958T4F8BX8DTwfPAM8Ez/n5dv6ffpHefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbf33m/Sm8+j8L0T5LNw6833FMhX8DfwdPAM8EzwLOB2f/shvfk8Ct87QT4Lt958T4F8BX8DTwfPAM8EzwIewvP7/JTefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbfnQjt5rhefR+F7J8hn4dab7ymQr+Bv4OngGeCZ4FnAQ7DzpWPucf525FH43gnyWbj15nsK5Cv4G3g6eAZ4JngW8Mf529HzOH878ih87wT5LNx68z0F8hX8DTwdPAM8EzwL+OP87eh5nL8deRS+d4J8Fm69+Z4C+Qr+Bp4OngGeCZ4F/HH+dvQ8zt+OPArfO0E+C7fefE+BfAV/A08HzwDPBM8CbnO+D17l+9bbme+dIK/v39ab7ymQr8KtN9/TwTPAo33R/gcuOnQL + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAACAQAAAfA0AAA==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 + + + AQAAAACAAAAgEAAA4QIAAA==eF411xGDAgYAQOG2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiA4OAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/DH2SIYUb4H7j+A2A= + + + AQAAAACAAAAEAgAADgAAAA==eF7j5BwFIx0AAFRsEiU= + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perTrue.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perTrue.vtu new file mode 100644 index 000000000..e130eeef7 --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_y_perTrue.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==eF51nUGO5VgRRf8WWAvMexWshbXADmDGgEEJJinkQc2cKnlQSCCnW0+4jCx5CajTir7yiXs9+eTN0CH7yPb7HYrX7/Xy1+8/r7/95POp5fc1h/ql5X/5vP4VOGuo3wJ/BM4eOEfgnIFzhfz1+s3n9ddff1/efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIS9vb8Eb86nl9zWH+qXlT2/krKF+C/wROHvgHIFzBs4V8tfrT3/85fravPl8avl9zaF+aXl585w11G+BPwJnD5wjcM7AuUJe99t7uN+YTy2/rznULy1/3m/krKF+C/wROHvgHIFzBs4V8v7+Lm8+n1p+X3OoX1pe3jxnDfVb4I/A2QPnCJwzcK6Q13P6vXnz+dTy+5pD/dLy8uY5a6jfAn8Ezh44R+CcgXOF/PX6z78/r+bN51PL72sO9UvLy5vnrKF+C/wROHvgHIFzBs4V8nq/fTRvPp9afl9zqF9aXt48Zw31W+CPwNkD5wicM3CukL9ev/28fm7efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIdf///PnWheYTy2/rznULy0vb56zhvot8Efg7IFzBM4ZOFfIX68/fF7/bd58PrX8vuZQv7S8vHnOGuq3wB+BswfOEThn4Fwhr/X0R/Pm86nl9zWH+qXl5c1z1lC/Bf4InD1wjsA5A+cK+ev1j7//cv2vefP51PL7mkP90vLy5jlrqN8CfwTOHjhH4JyBc4W8voec4NT3EOZTy+9rDvVLy8ub56yhfgv8ETh74ByBcwbOFXL9vv5XefP51PL7mkP90vLyxvy+1lC/Bf4InD1wjsA5A+cKua77Of7zT09vzKeW3z/NoX5p+dMbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTymzKH+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv3hvzqeVPb6xfWv70Rs4a6rfAH4GzB84ROGfgXCFX/43efD61vLz5+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv9ObzqeXlzdcvLX/eb+SsoX4L/BE4e+AcgXMGzhVyfj+VN59PLS9vvn5peXnznDXUb4E/AmcPnCNwzsC5Qq7+G735fGp5efP1S8vLm+esoX4L/BE4e+AcgXMGzhVy9d/ozedTy8ubr19aXt48Zw31W+CPwNkD5wicM3CukKv/Rm8+n1pe3nz90vLy5jlrqN8CfwTOHjhH4JyBc4Vc/Td68/nU8vLm65eWlzfPWUP9FvgjcPbAOQLnDJwr5OwrcF1gPrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpDXdYGj/hu9Mb9/nkP90vLy5jlrqN8CfwTOHjhH4JyBc4Vc151/gTfm7L99gTfWs//2Bd7IYf/tC7yRz/5bcdh/+wJv5LD/Vhz23778+vP9va76S/Lmc/bf5M3Xs/8mb57D/pu8eT77b/LmOey/yZvnsP9Gb2/gsP9Gb2/gsP9Gb2/4+9l/ozfWs/9Gb+Sw/0Zv5LD/Rm/M2X+TN5+z/yZvvp79N3nzHPbf5M3z2X+TN89h/03ePIf9N95v7+Cw/8b77R0c9t94vyl/3m/ksP/G+4189t94v5HD/hvvN3LYf5O3530hbz5n/03efD37b/LmOey/yZvns/8mb57D/pu8eQ77b3xOv4PD/huf0+/gsP/G51R5efMc9t/4nJLP/hufU3LYf+NzSg77b/L27C/Jm8/Zf5M3X8/+m7x5Dvtv8ub57L/Jm+ew/yZvnsP+G99vH+Cw/8b32wc47L/x/faBv5/9N77fWM/+G99v5LD/xvcbOey/8f3GnP03efM5+2/y5uvZf5M3z2H/Td48n/03efMc9t/kzXPYf+O6MMBh/43rwgCH/TeuCwN/P/tvXBdYz/4b1wVy2H/jukAO+29cF5iz/yZvPmf/Td58Pftv8uY57L/Jm+ez/yZvnsP+m7x5DvtvXE9/gMP+G9fTH+Cw/8b1VHl58xz237ieks/+G9dTcth/43pKDvtv8vbsL8mbz9l/kzdfz/6bvHkO+2/y5vnsv8mb57D/Jm+ew/6bvD37S/Lmc/bf5M3Xs//G7yHksP/G7yHks/8mb57D/pu8eQ77b/JWv6c3n7P/Jm++nv03efMc9t/kzfPZf5M3z2H/Td48h/03enu9fve53v4T3phPLb9/mkP90vKnN3LWUL8F/gicPXCOwDkD5wq5+m/05vOp5TdlDvVLy8ub56yhfgv8ETh74ByBcwbOFXL137w35lPLn95Yv7T86Y2cNdRvgT8CZw+cI3DOwLlCrv4bvfl8anl58/VLy8ub56yhfgv8ETh74ByBcwbOFXL13/z9xnxqeXnz9UvLn/cbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTy8ubrl5aXN89ZQ/0W+CNw9sA5AucMnCvk6r/Rm8+nlpc3X7+0vLx5zhrqt8AfgbMHzhE4Z+BcIVf/jd58PrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpCr/0ZvPp9aXt58/dLy8uY5a6jfAn8Ezh44R+CcgXOFXP03evP51PLy5uuXlpc3z1lD/Rb4I3D2wDkC5wycK+Tqv9Gbz6eWlzdfv7S8vHnOGuq3wB+BswfOEThn4Fwhr+tq3nw+tfz+eQ71S8vLm+esoX4L/BE4e+AcgXMGzhVyXfXvr09vzDn/9hXeWM/5t6/wRg7n377CG/mcfysO59++whs5nH8rDuffvv768/29rua75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+jtzdwOP9Gb2/gcP6N3t7w93P+jd5Yz/k3eiOH82/0Rg7n3+iNOeff5M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH/j/fYODuffeL+9g8P5N95vyp/3Gzmcf+P9Rj7n33i/kcP5N95v5HD+Td54X5Q3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jc/pd3A4/8bn9Ds4nH/jc6q8vHkO59/4nJLP+Tc+p+Rw/o3PKTmcf5O36i/Rm885/yZvvp7zb/LmOZx/kzfP5/ybvHkO59/kzXM4/8b32wc4nH/j++0DHM6/8f32gb+f8298v7Ge8298v5HD+Te+38jh/Bvfb8w5/yZvPuf8m7z5es6/yZvncP5N3jyf82/y5jmcf5M3z+H8G9eFAQ7n37guDHA4/8Z1YeDv5/wb1wXWc/6N6wI5nH/jukAO59+4LjDn/Ju8+Zzzb/Lm6zn/Jm+ew/k3efN8zr/Jm+dw/k3ePIfzb1xPf4DD+Teupz/A4fwb11Pl5c1zOP/G9ZR8zr9xPSWH829cT8nh/Ju8Pee75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+Tt+ov0ZvPOf8mb76e82/8HkIO59/4PYR8zr/Jm+dw/k3ePIfzb/JWv6c3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jd7qmuGN+dTy5yfr+3+P++lN+f3J8xdmeFP+9Kb8/uT5CzO8KX96U35/8r+Xp3/O+3tdnS8gbz6fWl6fvn5peXnzHJ6/IG+ePwKH5y/Im+fw/AV58znPX6A35lPL69PXLy1/eiOH5y/QG/kjcHj+Ar2Rw/MX6I1573eXN59PLa9PX9/7JuXNc3j+grx5fv/+fX/y/AV585y+zt2f6T3O8xd4vzGfWl6fvn5p+fN+I4fnL/B+I38EDs9f4P1GDs9f4P3GnP/dU3nzOc9fmPF71vP8BXnzHJ6/IG+ez/MX5M1zeP6CvHnOFXL1354c9d+e+dTy+vT1S8vLm+fw/AU+p+SPwOH5C3xOyTkD5wo5z1+QN5/z/AV58/U8f0HePIfnL8ib5/P8BXnzHJ6/IG+ew/MX+H77AEf9t2c+tbw+ff3S8vLmOTx/ge838kfg8PwFvt/I4fkLfL8x5/kL8uZznr8gb76e5y/Im+fw/AV583yevyBvnsPzF+TNc3j+AteFAQ7PX+C6MMCZQz3PX+C6QA7PX+C6QD7PX+C6QA7PX+C6QM4Vcp6/IG8+5/kL8ubref6CvHkOz1+QN8/n+Qvy5jk8f0HePIfnL3A9/dG8+XxqeX36+qXl5c1zeP4C11PyR+Dw/AWup+ScgXOFnOcvyJvPef6CvPl6nr8gb57D8xfkzfN5/oK8eQ7PX5A3z+H5C/JW/aUnh+cvyBvz+vT1PH+B30PI4fkL/B5CPs9fkDfP4fkL8uY5PH9B3ur3T476b898avnzk/VLy8ub5/D8BXljXt48h+cvyJvn8PwF/vMw13XPxX2DN+bcf/qt8Z713H/6Dd7I4f7Tb/BGPvefFof7T7/BGzncf1qcK+TcfypvPuf+U3nz9dx/Km+ew/2n8ub53H8qb57D/afy5jncf0pvb+Bw/ym9vYHD/af09oa/n/tP6Y313H9Kb+Rw/ym9kcP9p/TGnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN48h/tPeb+9g8P9p7zf3sHh/lPeb+/4+7n/lPcb67n/lPcbOdx/yvuNHO4/5f3GnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN485wo595/yOWXO/ad8TlnP/ad8Tsnh/lM+p+Rz/ymfU3K4/5TPKTncfypv1V+iN59z/6m8+XruP5U3z+H+U3nzfO4/lTfP4f5TefMc7j/l++0DHO4/5fvtAxzuP+X77QN/P/ef8v3Geu4/5fuNHO4/5fuNHO4/5fuN+ev1f33QNPp4XnWdQa4dSRFF3xZYi3vuVbAFWAJrgSUwY8AIJh7kAAmkslAiGdEof7ZTpBOllEtA/kV0qG7EqUnpnb46bV29/+t1tOPlhw/fr58+/vB+//vHX75ff/z4IeUl8Nf7dUG+Bv779+uf4GmQ7+Af4JngWeDZ4DnAXy/792tvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA/z1+s379Z/QW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wB/vX732+/Xt9Bbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAH+9/vyn79d/Q285L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D/PX694/frx16y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOB2ndBbzkvg9+sL8jVw6y33NMh38A/wTPAs8GzwHOB+/fpX369/SG/KS+D3qwvyNfBnb+ppkO/gH+CZ4Fng2eA5wF+vX7xff/ioveW8BH5bLsjXwK233NMg38E/wDPBs8CzwXOAW2+foDflJfBnb5qvgT97U0+DfAf/AM8EzwLPBs8Bbp9D/hJ6y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOD2fvsM7zflJXDrLc/XwJ/vN/U0yHfwD/BM8CzwbPAc4PbfWTX0lvMSuPWW52vg1lvuaZDv4B/gmeBZ4NngOcDt5/RL6C3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA2+feH0NvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9x+v72F3nJeArfe8nwN3HrLPQ3yHfwDPBM8CzwbPAf46/X+MfjDT6G3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23VCbzkvgd+vL8jXwK233NMg38E/wDPBs8CzwXOA+2Wfi5+9KS+B368uyNfAn72pp0G+g3+AZ4JngWeD5wD3+Zv2lvMS+G25IF8Dt95yT4N8B/8AzwTPAs8GzwHu87e8N+Ul8Gdvmq+BP3tTT4N8B/8AzwTPAs8GzwHu8zftLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zXw5/tNPQ3yHfwDPBM8CzwbPAe4z9+0t5yXwK23PF8Dt95yT4N8B/8AzwTPAs8GzwHuzwntLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23XE4/M37U35/fqCfA3cess9DfId/AM8EzwLPBs8B7hff/vr9+tf0pvyEvj96oJ8DfzZm3oa5Dv4B3gmeBZ4NngOcJ+/aW85L4HflgvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/y3tTXgJ/9qb5GvizN/U0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/f8veb8hK49Zbna+DP95t6GuQ7+Ad4JngWeDZ4DnCfv2lvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9znb9pbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+pr3lvARuveX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/aW85L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D3Odv2lvOS+DWW56vgVtvuadBvoN/gGeCZ4Fng+cA9/mb9pbzErj1ludr4NZb7mmQ7+Af4JngWeDZ4DnAff6mveW8BG695fkauPWWexrkO/gHeCZ4Fng2eA5wn79pbzkvgVtveb4Gbr3lngb5Dv4BngmeBZ4NngPc52/aW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wC364Tecl4Cv19fkK+BW2+5p0G+g3+AZ4JngWeD5wDXq0lvykvg9/2CfA382Zvz513zHfwDPBM8CzwbPAe4z9+MW285L4Hf9wvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/e3p8/vbkJfD7fkG+Bv7sTT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuadBvoN/gGeCZ4Fng+cA9/nb0+Pztycvgd/3C/I18Of7TT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuUefJ95b7h/gmeBZ4NngOcDj3+e+cz5/e/IS+H2/IB//XqD1lnsa5Dv4498vue8TPAs88f/j3nf6/5Q+f3t6fP725CXw+35BvgZuveWeBvkO/gGeCZ4Fng2eA9znb0+Pz9+evAR+3y/I18Ctt9zTIN/BP8AzwbPAs8FzgPv87enx+duTl8Dv+wX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/PT0+f3vyEvh9vyBfA7feck+DfAf/AM8EzwLPBs8B7vO3p8fnb09eAr/vF+Rr4NZb7mmQ7+Af4JngWeDZ4DnAff729Pj87clL4Pf9gnwN3HrLPQ3yHfwDPBM8CzwbPAe4z9+eHp+/PXkJ/L5fkK+BW2+5p0G+g3+AZ4JngWeD5wD3+dvT4/O3Jy+B3/cL8jVw6y33NMh38A/wTPAs8GzwHOB2HfH4/O3JS+D3/YJ8Ddx6yz0N8j1w6y33TPAs8GzwHOB+3T/Hb9Kbct0/tc81un/6Jr05f/amHv29+ya9qV/3T82j+6dv0pt6dP/UPLp/+vbz6/tzne1Xem851/1T7y3P6/6p95Z7dP/Ue8v9un/qveUe3T/13nKP7p9qb5/Eo/un2tsn8ej+qfb2Sf78un+qvWle90+1N/Xo/qn2ph7dP9XelOv+qfeWc90/9d7yvO6fem+5R/dPvbfcr/un3lvu0f1T7y336P6pvt8+i0f3T/X99lk8un+q7zfnz/ebenT/VN9v6tf9U32/qUf3T/X9ph7dP/Xenu8L7y3nun/qveV53T/13nKPfl723nK/7p96b7lH90+9t9yj+6f6c/pFPLp/qj+nX8Sj+6f6c+rcess9un+qP6fq1/1T/TlVj+6f6s+penT/1Huz+ZL2lnPdP/Xe8rzun3pvuUf3T7233K/7p95b7tH9U+8t9+j+qf5+exOP7p/q77c38ej+qf5+e5M/v+6f6u83zev+qf5+U4/un+rvN/Xo/qn+flOu+6feW851/9R7y/O6f+q95R7dP/Xecr/un3pvuUf3T7233KP7p/pcGOLR/VN9Lgzx6P6pPheG/Pl1/1SfC5rX/VN9LqhH90/1uaAe3T/V54Jy3T/13nKu+6feW57X/VPvLffo/qn3lvt1/9R7yz26f+q95R7dP9Xn6Tfx6P6pPk+/iUf3T/V56tx6yz26f6rPU/Xr/qk+T9Wj+6f6PFWP7p96b8/9Su8t57p/6r3led0/9d5yj+6fem+5X/dPvbfco/un3lvu0f1T783mS9pbznX/1HvL87p/qp9D1KP7p/o5RP26f+q95R7dP/Xeco/un3pv9s+1t5zr/qn3lud1/9R7yz06n/becr/un3pvuUf3T7233KP7p9rb6/XD/5+3z96Ul8DvVxfka+DP3tTTIN/BP8AzwbPAs8FzgPv8TXvLeQn8tlyQr4Fbb7mnQb6Df4BngmeBZ4PnAPf5W96b8hL4szfN18CfvamnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+lr/flJfArbc8XwN/vt/U0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLuZ5/6r3leT3/1HvLPXr+qfeW+/X8U+8t9+j5p95b7tHzT/W5MMSj55/qc2GIR88/1efCkD+/nn+qzwXN6/mn+lxQj55/qs8F9ej5p/pcUK7nn3pvOdfzT723PK/nn3pvuUfPP/Xecr+ef+q95R49/9R7yz16/qk+T7+Jx+dv2pty6y3P18Ctt9yj55/q81T9Azx6/qk+T9WzwXOA6/mn3lvO9fxT7y3P6/mn3lvu0fNPvbfcr+efem+5R88/9d5yj55/6r3ZfEl7y7mef+q95Xk9/1Q/h6hHzz/VzyHq1/NPvbfco+efem+5R88/9d7sn2tvOS+B368vyNfArbfc0yCv5596b7lHzz/13nKPnn/qveXcr3sv9av0ply//+2r9KZ5/f63r9Kbehrk9fvfvkpv6tHvf/sqvalHv//NPPr9b19/fn1/rrPvN/Pecq7f/+a95Xn9/jfvLffo9795b7lfv//Ne8s9+v1v3lvu0e9/094+ffwfkHMVtHhedZ0xjnU5EUZ7C6wF8n8VbAGWwFpgCWQERJBM4ACJkS6Bg0ECeQwGjwePvAT091Wp5K/q3OSpD6Wj4ei9fj0VTH3716/Pv7/88vP545effT7ffPn24iXwj8/ngfka+O8/n7+Dp8F8B/8AzwTPAs8GzwH+8fG73359/iKeP37JeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4B8fb8+/hW45L4Fbt3y+Bn6/39TTYL6Df4BngmeBZ4PnAP/4sP9/2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA2+f0u9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgH98/PMfn0/olvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcDt99v3oVvOS+DWLZ+vgVu33NNgvoN/gGeCZ4Fng+cA//j4+efzr9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNv3wgjdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B/jHx28+n/+GbjkvgVu3fL4Gbt1yT4P5Dv4BngmeBZ4NngPcvk9/CN1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwH+MfHn//09fkxdMt5Cdy65fM1cOuWexrMd/AP8EzwLPBs8Bzg9nfIDt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuD0ndMt5Cfz9+YH5Grh1yz0N5jv4B3gmeBZ4NngOcH9+/auvz3+km/IS+PvTA/M18LubehrMd/AP8EzwLPBs8Bzg9nfvH75ot5yXwF/LA/M1cOuWexrMd/AP8EzwLPBs8Bzg1u0b6Ka8BH530/ka+N1NPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+7f8/aa8BG7d8vka+P1+U0+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+zftlvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7jv37Rbzkvg1i2fr4Fbt9zTYL6Df4BngmeBZ4PnAPf9m3bLeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4L5/0245L4Fbt3y+Bm7dck+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5we07olvMS+PvzA/M1cOuWexrMd/AP8EzwLPBs8Bzg+kzpprwE/r4+MF8Dv7s5f18bzHfwD/BM8CzwbPAc4L5/M27dcl4Cf18fmK+BW7fc02C+g3+AZ4JngWeD5wD3/dvt8f3bzUvg7+sD8zXwu5t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gGeCZ4Fng2eA9z3b7fH9283L4G/rw/M18Dv95t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gEe/V7ybrlng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzgvn+7Pb5/u3kJ/H19YL4Gbt1yT4P5Dv4BngmeBZ4NngPc92+3x/dvNy+Bv68PzNfArVvuaTDfwT/AM8GzwLPBc4D7/u32+P7t5iXw9/WB+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv90e37/dvAT+vj4wXwO3brmnwXwH/wDPBM8CzwbPAe77t9vj+7ebl8Df1wfma+DWLfc0mO/gH+CZ4Fng2eA5wH3/dnt8/3bzEvj7+sB8Ddy65Z4G8x38AzwTPAs8GzwHuO/fbo/v325eAn9fH5ivgVu33NNgvoN/gGeCZ4Fng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzg9hzx+P7t5iXw9/WB+Rq4dcs9DeZ74NYt90zwLPBs8Bzg/tjn+O6mvAT+/vTAfA387qaeBvMd/AM88ff33U09GzwHuO/ftFvOS+Cv5YH5Grh1yz0N5jv4B3gmeBZ4NngOcN+/5d2Ul8DvbjpfA7+7qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN/H6/qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4Il/d1u33LPBc4D7/k275bwEbt3y+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv2m3nJfArVs+XwO3brmnwXwH/wDPBM8CzwbPAe77N+2W8xK4dcvna+DWLfc0mO/gH+CZ4Fng2eA5wH3/pt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuO/ftFvOS+DWLZ+vgVu33NNgvoN/gCfuS6xb7tngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7j/e5d2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNtzxOP7N+2m/P35gfkauHXLPQ3mO/gHeOKe27rlng2eA9yfX3x+3/4o3ZSXwN+fHpivgd/d1NNgvoN/gGeCZ4Fng+cA9/2bdst5Cfy1PDBfA7duuafBfAf/AM8EzwLPBs8B7vu3vJvyEvjdTedr4Hc39TSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479/y95vyErh1y+dr4Pf7TT0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479+0W85L4NYtn6+BW7fc02C+g3+AZ4JngWeD5wD3/Zt2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgPv+TbvlvARu3fL5Grh1yz0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnA7TmhW85L4O/PD8zXwK1b7mkw38E/wDPBs8CzwXOA+/P+d+H+J92Ul8Dfnx6Yr4Hf3dTTYL6Df4BngmeBZ4PnAPf9m3bLeQn8tTwwXwO3brmnwXwH/wDPBM8CzwbPAe77t7yb8hL43U3na+B3N/Xo/QXtpv4BHr2/oN3Uo/cXtJtyvb/g3XJeArdu+XwN3LrlHr2/4N1y/wCP3l/wbrlH7y94t5zr/QV9vykvgVu3fL4Gfr/f1KP3F/T9pv4BHr2/oO839ej9BX2/Kdf7C94t53p/wbvl83p/wbvlHr2/4N1yv95f8G65R+8veLfco/cX9HP6nXh8/6bdlFu3fL4Gbt1yj95f0M+p+gd49P6Cfk7Vo/cX9HOqXO8veLec6/0F75bP6/0F75Z79P6Cd8v9en/Bu+Uevb/g3XKP3l/Q32/fi8f3b9pNuXXL52vg1i336P0F/f2m/gEevb+gv9/Uo/cX9Pebcr2/4N1yrvcXvFs+r/cXvFvu0fsL3i336/0F75Z79P6Cd8s9en9BvxeGePT+gn4vDPHo/QX9Xhjyz6/3F/R7Qef1/oJ+L6hngkfvL+j3gnr0/oJ3s/2Sdsu53l/wbvm83l/wbrlH7y94t9yv9xe8W+7R+wveLffo/QX9Pv1BPL5/027KrVs+XwO3brlH7y/o96n6B3j0/oJ+n6pH7y/o96lyvb/g3XKu9xe8Wz6v9xe8W+7R+wveLffr/QXvlnv0/oJ3yz16f8G72X5Ju+Vc7y94t3xe7y/o3yHq0fsL+neI+vX+gnfLPXp/wbvlHr2/4N3sf9duOS+Bvz8/MF8Dt265R+8veLfcP8AzwaP3F7xb7jnA/Xn/u3A/STflJfD3pwfma+B3N/Xo/YWfpJv6B3gmePT+wk/STT0HuN5f8G45L4G/lgfma+DWLffo/QXvlvsHePT+gnfLPXp/wbvlXO8vaDflJfC7m87XwO9u6tH7C9pN/QM8en9Bu6lH7y9oN+V6f8G75bwEbt3y+Rq4dcs9en/Bu+X+AR69v+Ddco/eX/BuOdf7C/p+U14Ct275fA38fr+pR+8v6PtN/QM8en9B32/q0fsL+n5TrvcXvFvO9f6Cd8vn9f6Cd8s9en/Bu+V+vb/g3XKP3l/wbrlH7y/o5/Q78fj+Tbspt275fA3cuuUevb+gn1P1D/Do/QX9nKpH7y/o51S53l/wbjnX+wveLZ/X+wveLffo/QXvlvv1/oJ3yz16f8G75R69v6C/374Xj+/ftJty65bP18CtW+7R+wv6+039Azx6f0F/v6lH7y/o7zflen/Bu+Vc7y94t3xe7y94t9yj9xe8W+7X+wveLffo/QXvlnv0/oJ+Lwzx6P0F/V4Y4tH7C/q9MOSfX+8v6PeCzuv9Bf1eUM8Ej95f0O8F9ej9Be9m+yXj/wcPgkTdeF51mLGtFDEURd0CtVDAVvFbgBKoBUogI9gIEgIHZCZwABLIGFkYIyOXgHatx2rmvvOSpz26e6S9mp0Z+enpNtfLq/v8urx8cZu/lzt+isLDfRLks/C39/kKngL5Cv4Gng6eAZ4JngU8hDevb/P75LlefB6FW29+Pgu33nxPgXwFfwNPB88AzwTPAh7Ch/e3+SO9+TwKt978fBZuvfmeAvkK/gaeDp4BngmeBTyE799uM6U3n0fh1pufz8KtN99TIF/B38DTwTPAM8GzgNss6c3nUfj+nCCfhVtvvqdAvoK/gaeDZ4BngmcBP8869XbmUfjeCfJZ+LG3B9+7QL6Cv4Gng2eAZ4JnAQ/h2X3e/c9Zbz6PwvdOkM/CrTffUyBfwd/A08EzwDPBs4Bbbx+htzOPwvdOkM/Cj72dPQXyFfwNPB08AzwTPAu4vYd8kt58HoXvnSCfhVtvvqdAvoK/gaeDZ4BngmcBt+vts/Tm8yh87wT5LPx4vZ09BfIV/A08HTwDPBM8C3gI9vuOnqs8D623M987QT4Lt958T4F8BX8DTwfPAM8Ez/n5dv6ffpHefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbf33m/Sm8+j8L0T5LNw6833FMhX8DfwdPAM8EzwLOB2f/shvfk8Ct87QT4Lt958T4F8BX8DTwfPAM8EzwIewvP7/JTefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbfnQjt5rhefR+F7J8hn4dab7ymQr+Bv4OngGeCZ4FnAQ7DzpWPucf525FH43gnyWbj15nsK5Cv4G3g6eAZ4JngW8Mf529HzOH878ih87wT5LNx68z0F8hX8DTwdPAM8EzwL+OP87eh5nL8deRS+d4J8Fm69+Z4C+Qr+Bp4OngGeCZ4F/HH+dvQ8zt+OPArfO0E+C7fefE+BfAV/A08HzwDPBM8CbnO+D17l+9bbme+dIK/v39ab7ymQr8KtN9/TwTPAo33R/gcuOnQL + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAACASQAAiA8AAA==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 + + + AQAAAACAAABgEgAAQAMAAA==eF411xGXAogCgNHZt+3b9pwgCIIgCIIgCIIgCIIgCAaCIAiCIAiCIAiCIAiCIAiCIAiCIAiCYCAIgiAIgiAIFubuJ/c3fIGv34IMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAq/WWWNdTbYZIttdthlj30OOOSIY0445YxzLrjkimtuuOWOex545Ik/PPPCK2+888EnX3zzw68/fgkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsus8JtV1lhng0222GaHXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUee+MMzL7zyxjsffPLFNz/8+t8vAQYZYpgRRhljnAkmmWKaGWaZY54FFllimRV+s8oa62ywyRbb7LDLHvsccMgRx5xwyhnnXHDJFdfccMsd9zzwyBN/eOaFV95454NPvvjmh19//hJgkCGGGWGUMcaZYJIppplhljnmWWCRJZZZ4TerrLHOBptssc0Ou+yxzwGHHHHMCaeccc4Fl1xxzQ233HHPA4888YdnXnjljXc++OSLb374FQCDDDHMCKOMMc4Ek0wxzQyzzDHPAossscwKv1lljXU22GSLbXbYZY99DjjkiGNOOOWMcy645IprbrjljnseeOSJPzzzwitvvPPBJ19888Ovv34JMMgQw4wwyhjjTDDJFNPMMMsc8yywyBLLrPCbVdZYZ4NNtthmh1322OeAQ4445oRTzjjngkuuuOaGW+6454FHnvjDMy+88sY7H3zyxTc//Pr/LwEGGWKYEUYZY5wJJplimhlmmWOeBRZZYpkVfrPKGutssMkW2+ywyx77HHDIEceccMoZ51xwyRXX3HDLHfc88MgTf3jmhVfeeOeDT7745odff/8SYJAhhhlhlDHGmWCSKaaZYZY55llgkSWWWeE3q6yxzgabbLHNDrvssc8BhxxxzAmnnHHOBZdccc0Nt9xxzwOPPPGHZ1545Y13Pvjki29++N/wBxhkiGFGGGWMcSaYZIppZphljnkWWGSJZVb4zSprrLPBJltss8Mue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI0/84ZkXXnnjnQ8++eKbH37980uAQYYYZoRRxhhngkmmmOa/1h0mPQ== + + + AQAAAACAAABMAgAADwAAAA==eF7j5BwFo4A6AADLgxSt + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perFalse.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perFalse.vtu new file mode 100644 index 000000000..5cba040dd --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perFalse.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==eF51nUGO5VgRRf8WWAvMexWshbXADmDGgEEJJinkQc2cKnlQSCCnW0+4jCx5CajTir7yiXs9+eTN0CH7yPb7HYrX7/Xy1+8/r7/95POp5fc1h/ql5X/5vP4VOGuo3wJ/BM4eOEfgnIFzhfz1+s3n9ddff1/efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIS9vb8Eb86nl9zWH+qXlT2/krKF+C/wROHvgHIFzBs4V8tfrT3/85fravPl8avl9zaF+aXl585w11G+BPwJnD5wjcM7AuUJe99t7uN+YTy2/rznULy1/3m/krKF+C/wROHvgHIFzBs4V8v7+Lm8+n1p+X3OoX1pe3jxnDfVb4I/A2QPnCJwzcK6Q13P6vXnz+dTy+5pD/dLy8uY5a6jfAn8Ezh44R+CcgXOF/PX6z78/r+bN51PL72sO9UvLy5vnrKF+C/wROHvgHIFzBs4V8nq/fTRvPp9afl9zqF9aXt48Zw31W+CPwNkD5wicM3CukL9ev/28fm7efD61/L7mUL+0vLx5zhrqt8AfgbMHzhE4Z+BcIdf///PnWheYTy2/rznULy0vb56zhvot8Efg7IFzBM4ZOFfIX68/fF7/bd58PrX8vuZQv7S8vHnOGuq3wB+BswfOEThn4Fwhr/X0R/Pm86nl9zWH+qXl5c1z1lC/Bf4InD1wjsA5A+cK+ev1j7//cv2vefP51PL7mkP90vLy5jlrqN8CfwTOHjhH4JyBc4W8voec4NT3EOZTy+9rDvVLy8ub56yhfgv8ETh74ByBcwbOFXL9vv5XefP51PL7mkP90vLyxvy+1lC/Bf4InD1wjsA5A+cKua77Of7zT09vzKeW3z/NoX5p+dMbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTymzKH+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv3hvzqeVPb6xfWv70Rs4a6rfAH4GzB84ROGfgXCFX/43efD61vLz5+qXl5c1z1lC/Bf4InD1wjsA5A+cKufpv9ObzqeXlzdcvLX/eb+SsoX4L/BE4e+AcgXMGzhVyfj+VN59PLS9vvn5peXnznDXUb4E/AmcPnCNwzsC5Qq7+G735fGp5efP1S8vLm+esoX4L/BE4e+AcgXMGzhVy9d/ozedTy8ubr19aXt48Zw31W+CPwNkD5wicM3CukKv/Rm8+n1pe3nz90vLy5jlrqN8CfwTOHjhH4JyBc4Vc/Td68/nU8vLm65eWlzfPWUP9FvgjcPbAOQLnDJwr5OwrcF1gPrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpDXdYGj/hu9Mb9/nkP90vLy5jlrqN8CfwTOHjhH4JyBc4Vc151/gTfm7L99gTfWs//2Bd7IYf/tC7yRz/5bcdh/+wJv5LD/Vhz23778+vP9va76S/Lmc/bf5M3Xs/8mb57D/pu8eT77b/LmOey/yZvnsP9Gb2/gsP9Gb2/gsP9Gb2/4+9l/ozfWs/9Gb+Sw/0Zv5LD/Rm/M2X+TN5+z/yZvvp79N3nzHPbf5M3z2X+TN89h/03ePIf9N95v7+Cw/8b77R0c9t94vyl/3m/ksP/G+4189t94v5HD/hvvN3LYf5O3530hbz5n/03efD37b/LmOey/yZvns/8mb57D/pu8eQ77b3xOv4PD/huf0+/gsP/G51R5efMc9t/4nJLP/hufU3LYf+NzSg77b/L27C/Jm8/Zf5M3X8/+m7x5Dvtv8ub57L/Jm+ew/yZvnsP+G99vH+Cw/8b32wc47L/x/faBv5/9N77fWM/+G99v5LD/xvcbOey/8f3GnP03efM5+2/y5uvZf5M3z2H/Td48n/03efMc9t/kzXPYf+O6MMBh/43rwgCH/TeuCwN/P/tvXBdYz/4b1wVy2H/jukAO+29cF5iz/yZvPmf/Td58Pftv8uY57L/Jm+ez/yZvnsP+m7x5DvtvXE9/gMP+G9fTH+Cw/8b1VHl58xz237ieks/+G9dTcth/43pKDvtv8vbsL8mbz9l/kzdfz/6bvHkO+2/y5vnsv8mb57D/Jm+ew/6bvD37S/Lmc/bf5M3Xs//G7yHksP/G7yHks/8mb57D/pu8eQ77b/JWv6c3n7P/Jm++nv03efMc9t/kzfPZf5M3z2H/Td48h/03enu9fve53v4T3phPLb9/mkP90vKnN3LWUL8F/gicPXCOwDkD5wq5+m/05vOp5TdlDvVLy8ub56yhfgv8ETh74ByBcwbOFXL137w35lPLn95Yv7T86Y2cNdRvgT8CZw+cI3DOwLlCrv4bvfl8anl58/VLy8ub56yhfgv8ETh74ByBcwbOFXL13/z9xnxqeXnz9UvLn/cbOWuo3wJ/BM4eOEfgnIFzhVz9N3rz+dTy8ubrl5aXN89ZQ/0W+CNw9sA5AucMnCvk6r/Rm8+nlpc3X7+0vLx5zhrqt8AfgbMHzhE4Z+BcIVf/jd58PrW8vPn6peXlzXPWUL8F/gicPXCOwDkD5wq5+m/05vOp5eXN1y8tL2+es4b6LfBH4OyBcwTOGThXyNV/ozefTy0vb75+aXl585w11G+BPwJnD5wjcM7AuUKu/hu9+XxqeXnz9UvLy5vnrKF+C/wROHvgHIFzBs4VcvXf6M3nU8vLm69fWl7ePGcN9Vvgj8DZA+cInDNwrpCr/0ZvPp9aXt58/dLy8uY5a6jfAn8Ezh44R+CcgXOFXP03evP51PLy5uuXlpc3z1lD/Rb4I3D2wDkC5wycK+Tqv9Gbz6eWlzdfv7S8vHnOGuq3wB+BswfOEThn4Fwhr+tq3nw+tfz+eQ71S8vLm+esoX4L/BE4e+AcgXMGzhVyXfXvr09vzDn/9hXeWM/5t6/wRg7n377CG/mcfysO59++whs5nH8rDuffvv768/29rua75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+jtzdwOP9Gb2/gcP6N3t7w93P+jd5Yz/k3eiOH82/0Rg7n3+iNOeff5M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH/j/fYODuffeL+9g8P5N95vyp/3Gzmcf+P9Rj7n33i/kcP5N95v5HD+Td54X5Q3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jc/pd3A4/8bn9Ds4nH/jc6q8vHkO59/4nJLP+Tc+p+Rw/o3PKTmcf5O36i/Rm885/yZvvp7zb/LmOZx/kzfP5/ybvHkO59/kzXM4/8b32wc4nH/j++0DHM6/8f32gb+f8298v7Ge8298v5HD+Te+38jh/Bvfb8w5/yZvPuf8m7z5es6/yZvncP5N3jyf82/y5jmcf5M3z+H8G9eFAQ7n37guDHA4/8Z1YeDv5/wb1wXWc/6N6wI5nH/jukAO59+4LjDn/Ju8+Zzzb/Lm6zn/Jm+ew/k3efN8zr/Jm+dw/k3ePIfzb1xPf4DD+Teupz/A4fwb11Pl5c1zOP/G9ZR8zr9xPSWH829cT8nh/Ju8Pee75M3nnH+TN1/P+Td58xzOv8mb53P+Td48h/Nv8uY5nH+Tt+ov0ZvPOf8mb76e82/8HkIO59/4PYR8zr/Jm+dw/k3ePIfzb/JWv6c3n3P+Td58Peff5M1zOP8mb57P+Td58xzOv8mb53D+jd7qmuGN+dTy5yfr+3+P++lN+f3J8xdmeFP+9Kb8/uT5CzO8KX96U35/8r+Xp3/O+3tdnS8gbz6fWl6fvn5peXnzHJ6/IG+ePwKH5y/Im+fw/AV58znPX6A35lPL69PXLy1/eiOH5y/QG/kjcHj+Ar2Rw/MX6I1573eXN59PLa9PX9/7JuXNc3j+grx5fv/+fX/y/AV585y+zt2f6T3O8xd4vzGfWl6fvn5p+fN+I4fnL/B+I38EDs9f4P1GDs9f4P3GnP/dU3nzOc9fmPF71vP8BXnzHJ6/IG+ez/MX5M1zeP6CvHnOFXL1354c9d+e+dTy+vT1S8vLm+fw/AU+p+SPwOH5C3xOyTkD5wo5z1+QN5/z/AV58/U8f0HePIfnL8ib5/P8BXnzHJ6/IG+ew/MX+H77AEf9t2c+tbw+ff3S8vLmOTx/ge838kfg8PwFvt/I4fkLfL8x5/kL8uZznr8gb76e5y/Im+fw/AV583yevyBvnsPzF+TNc3j+AteFAQ7PX+C6MMCZQz3PX+C6QA7PX+C6QD7PX+C6QA7PX+C6QM4Vcp6/IG8+5/kL8ubref6CvHkOz1+QN8/n+Qvy5jk8f0HePIfnL3A9/dG8+XxqeX36+qXl5c1zeP4C11PyR+Dw/AWup+ScgXOFnOcvyJvPef6CvPl6nr8gb57D8xfkzfN5/oK8eQ7PX5A3z+H5C/JW/aUnh+cvyBvz+vT1PH+B30PI4fkL/B5CPs9fkDfP4fkL8uY5PH9B3ur3T476b898avnzk/VLy8ub5/D8BXljXt48h+cvyJvn8PwF/vMw13XPxX2DN+bcf/qt8Z713H/6Dd7I4f7Tb/BGPvefFof7T7/BGzncf1qcK+TcfypvPuf+U3nz9dx/Km+ew/2n8ub53H8qb57D/afy5jncf0pvb+Bw/ym9vYHD/af09oa/n/tP6Y313H9Kb+Rw/ym9kcP9p/TGnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN48h/tPeb+9g8P9p7zf3sHh/lPeb+/4+7n/lPcb67n/lPcbOdx/yvuNHO4/5f3GnPtP5c3n3H8qb76e+0/lzXO4/1TePJ/7T+XNc7j/VN485wo595/yOWXO/ad8TlnP/ad8Tsnh/lM+p+Rz/ymfU3K4/5TPKTncfypv1V+iN59z/6m8+XruP5U3z+H+U3nzfO4/lTfP4f5TefMc7j/l++0DHO4/5fvtAxzuP+X77QN/P/ef8v3Geu4/5fuNHO4/5fuNHO4/5fuN+ev1f33QNPp4XnWdQa4dSRFF3xZYi3vuVbAFWAJrgSUwY8AIJh7kAAmkslAiGdEof7ZTpBOllEtA/kV0qG7EqUnpnb46bV29/+t1tOPlhw/fr58+/vB+//vHX75ff/z4IeUl8Nf7dUG+Bv779+uf4GmQ7+Af4JngWeDZ4DnAXy/792tvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA/z1+s379Z/QW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wB/vX732+/Xt9Bbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAH+9/vyn79d/Q285L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D/PX694/frx16y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOB2ndBbzkvg9+sL8jVw6y33NMh38A/wTPAs8GzwHOB+/fpX369/SG/KS+D3qwvyNfBnb+ppkO/gH+CZ4Fng2eA5wF+vX7xff/ioveW8BH5bLsjXwK233NMg38E/wDPBs8CzwXOAW2+foDflJfBnb5qvgT97U0+DfAf/AM8EzwLPBs8Bbp9D/hJ6y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOD2fvsM7zflJXDrLc/XwJ/vN/U0yHfwD/BM8CzwbPAc4PbfWTX0lvMSuPWW52vg1lvuaZDv4B/gmeBZ4NngOcDt5/RL6C3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA2+feH0NvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9x+v72F3nJeArfe8nwN3HrLPQ3yHfwDPBM8CzwbPAf46/X+MfjDT6G3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23VCbzkvgd+vL8jXwK233NMg38E/wDPBs8CzwXOA+2Wfi5+9KS+B368uyNfAn72pp0G+g3+AZ4JngWeD5wD3+Zv2lvMS+G25IF8Dt95yT4N8B/8AzwTPAs8GzwHu87e8N+Ul8Gdvmq+BP3tTT4N8B/8AzwTPAs8GzwHu8zftLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zXw5/tNPQ3yHfwDPBM8CzwbPAe4z9+0t5yXwK23PF8Dt95yT4N8B/8AzwTPAs8GzwHuzwntLeclcOstz9fArbfc0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLeQncesvzNXDrLfc0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/ftLecl8CttzxfA7feck+DfAf/AM8EzwLPBs8B7vM37S3nJXDrLc/XwK233NMg38E/wDPBs8CzwXOA23XE4/M37U35/fqCfA3cess9DfId/AM8EzwLPBs8B7hff/vr9+tf0pvyEvj96oJ8DfzZm3oa5Dv4B3gmeBZ4NngOcJ+/aW85L4HflgvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/y3tTXgJ/9qb5GvizN/U0yHfwD/BM8CzwbPAc4D5/095yXgK33vJ8Ddx6yz0N8h38AzwTPAs8GzwHuM/f8veb8hK49Zbna+DP95t6GuQ7+Ad4JngWeDZ4DnCfv2lvOS+BW295vgZuveWeBvkO/gGeCZ4Fng2eA9znb9pbzkvg1luer4Fbb7mnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+pr3lvARuveX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/aW85L4Fbb3m+Bm695Z4G+Q7+AZ4JngWeDZ4D3Odv2lvOS+DWW56vgVtvuadBvoN/gGeCZ4Fng+cA9/mb9pbzErj1ludr4NZb7mmQ7+Af4JngWeDZ4DnAff6mveW8BG695fkauPWWexrkO/gHeCZ4Fng2eA5wn79pbzkvgVtveb4Gbr3lngb5Dv4BngmeBZ4NngPc52/aW85L4NZbnq+BW2+5p0G+g3+AZ4JngWeD5wC364Tecl4Cv19fkK+BW2+5p0G+g3+AZ4JngWeD5wDXq0lvykvg9/2CfA382Zvz513zHfwDPBM8CzwbPAe4z9+MW285L4Hf9wvyNXDrLfc0yHfwD/BM8CzwbPAc4D5/e3p8/vbkJfD7fkG+Bv7sTT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuadBvoN/gGeCZ4Fng+cA9/nb0+Pztycvgd/3C/I18Of7TT0N8h38AzwTPAs8GzwHuM/fnh6fvz15Cfy+X5CvgVtvuUefJ95b7h/gmeBZ4NngOcDj3+e+cz5/e/IS+H2/IB//XqD1lnsa5Dv4498vue8TPAs88f/j3nf6/5Q+f3t6fP725CXw+35BvgZuveWeBvkO/gGeCZ4Fng2eA9znb0+Pz9+evAR+3y/I18Ctt9zTIN/BP8AzwbPAs8FzgPv87enx+duTl8Dv+wX5Grj1lnsa5Dv4B3gmeBZ4NngOcJ+/PT0+f3vyEvh9vyBfA7feck+DfAf/AM8EzwLPBs8B7vO3p8fnb09eAr/vF+Rr4NZb7mmQ7+Af4JngWeDZ4DnAff729Pj87clL4Pf9gnwN3HrLPQ3yHfwDPBM8CzwbPAe4z9+eHp+/PXkJ/L5fkK+BW2+5p0G+g3+AZ4JngWeD5wD3+dvT4/O3Jy+B3/cL8jVw6y33NMh38A/wTPAs8GzwHOB2HfH4/O3JS+D3/YJ8Ddx6yz0N8j1w6y33TPAs8GzwHOB+3T/Hb9Kbct0/tc81un/6Jr05f/amHv29+ya9qV/3T82j+6dv0pt6dP/UPLp/+vbz6/tzne1Xem851/1T7y3P6/6p95Z7dP/Ue8v9un/qveUe3T/13nKP7p9qb5/Eo/un2tsn8ej+qfb2Sf78un+qvWle90+1N/Xo/qn2ph7dP9XelOv+qfeWc90/9d7yvO6fem+5R/dPvbfcr/un3lvu0f1T7y336P6pvt8+i0f3T/X99lk8un+q7zfnz/ebenT/VN9v6tf9U32/qUf3T/X9ph7dP/Xenu8L7y3nun/qveV53T/13nKPfl723nK/7p96b7lH90+9t9yj+6f6c/pFPLp/qj+nX8Sj+6f6c+rcess9un+qP6fq1/1T/TlVj+6f6s+penT/1Huz+ZL2lnPdP/Xe8rzun3pvuUf3T7233K/7p95b7tH9U+8t9+j+qf5+exOP7p/q77c38ej+qf5+e5M/v+6f6u83zev+qf5+U4/un+rvN/Xo/qn+flOu+6feW851/9R7y/O6f+q95R7dP/Xecr/un3pvuUf3T7233KP7p/pcGOLR/VN9Lgzx6P6pPheG/Pl1/1SfC5rX/VN9LqhH90/1uaAe3T/V54Jy3T/13nKu+6feW57X/VPvLffo/qn3lvt1/9R7yz26f+q95R7dP9Xn6Tfx6P6pPk+/iUf3T/V56tx6yz26f6rPU/Xr/qk+T9Wj+6f6PFWP7p96b8/9Su8t57p/6r3led0/9d5yj+6fem+5X/dPvbfco/un3lvu0f1T783mS9pbznX/1HvL87p/qp9D1KP7p/o5RP26f+q95R7dP/Xeco/un3pv9s+1t5zr/qn3lud1/9R7yz06n/becr/un3pvuUf3T7233KP7p9rb6/XD/5+3z96Ul8DvVxfka+DP3tTTIN/BP8AzwbPAs8FzgPv8TXvLeQn8tlyQr4Fbb7mnQb6Df4BngmeBZ4PnAPf5W96b8hL4szfN18CfvamnQb6Df4BngmeBZ4PnAPf5m/aW8xK49Zbna+DWW+5pkO/gH+CZ4Fng2eA5wH3+lr/flJfArbc8XwN/vt/U0yDfwT/AM8GzwLPBc4D7/E17y3kJ3HrL8zVw6y33NMh38A/wTPAs8GzwHOA+f9Pecl4Ct97yfA3cess9DfId/AM8EzwLPBs8B7jP37S3nJfArbc8XwO33nJPg3wH/wDPBM8CzwbPAe7zN+0t5yVw6y3P18Ctt9zTIN/BP8AzwbPAs8FzgPv8TXvLuZ5/6r3leT3/1HvLPXr+qfeW+/X8U+8t9+j5p95b7tHzT/W5MMSj55/qc2GIR88/1efCkD+/nn+qzwXN6/mn+lxQj55/qs8F9ej5p/pcUK7nn3pvOdfzT723PK/nn3pvuUfPP/Xecr+ef+q95R49/9R7yz16/qk+T7+Jx+dv2pty6y3P18Ctt9yj55/q81T9Azx6/qk+T9WzwXOA6/mn3lvO9fxT7y3P6/mn3lvu0fNPvbfcr+efem+5R88/9d5yj55/6r3ZfEl7y7mef+q95Xk9/1Q/h6hHzz/VzyHq1/NPvbfco+efem+5R88/9d7sn2tvOS+B368vyNfArbfc0yCv5596b7lHzz/13nKPnn/qveXcr3sv9av0ply//+2r9KZ5/f63r9Kbehrk9fvfvkpv6tHvf/sqvalHv//NPPr9b19/fn1/rrPvN/Pecq7f/+a95Xn9/jfvLffo9795b7lfv//Ne8s9+v1v3lvu0e9/094+ffwfkHMVtHhedZ0xjnU5EUZ7C6wF8n8VbAGWwFpgCWQERJBM4ACJkS6Bg0ECeQwGjwePvAT091Wp5K/q3OSpD6Wj4ei9fj0VTH3716/Pv7/88vP545effT7ffPn24iXwj8/ngfka+O8/n7+Dp8F8B/8AzwTPAs8GzwH+8fG73359/iKeP37JeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4B8fb8+/hW45L4Fbt3y+Bn6/39TTYL6Df4BngmeBZ4PnAP/4sP9/2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA2+f0u9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgH98/PMfn0/olvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcDt99v3oVvOS+DWLZ+vgVu33NNgvoN/gGeCZ4Fng+cA//j4+efzr9At5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNv3wgjdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B/jHx28+n/+GbjkvgVu3fL4Gbt1yT4P5Dv4BngmeBZ4NngPcvk9/CN1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwH+MfHn//09fkxdMt5Cdy65fM1cOuWexrMd/AP8EzwLPBs8Bzg9nfIDt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuD0ndMt5Cfz9+YH5Grh1yz0N5jv4B3gmeBZ4NngOcH9+/auvz3+km/IS+PvTA/M18LubehrMd/AP8EzwLPBs8Bzg9nfvH75ot5yXwF/LA/M1cOuWexrMd/AP8EzwLPBs8Bzg1u0b6Ka8BH530/ka+N1NPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+7f8/aa8BG7d8vka+P1+U0+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5w379pt5yXwK1bPl8Dt265p8F8B/8AzwTPAs8GzwHu+zftlvMSuHXL52vg1i33NJjv4B/gmeBZ4NngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7jv37Rbzkvg1i2fr4Fbt9zTYL6Df4BngmeBZ4PnAPf9m3bLeQncuuXzNXDrlnsazHfwD/BM8CzwbPAc4L5/0245L4Fbt3y+Bm7dck+D+Q7+AZ4JngWeDZ4D3Pdv2i3nJXDrls/XwK1b7mkw38E/wDPBs8CzwXOA+/5Nu+W8BG7d8vkauHXLPQ3mO/gHeCZ4Fng2eA5we07olvMS+PvzA/M1cOuWexrMd/AP8EzwLPBs8Bzg+kzpprwE/r4+MF8Dv7s5f18bzHfwD/BM8CzwbPAc4L5/M27dcl4Cf18fmK+BW7fc02C+g3+AZ4JngWeD5wD3/dvt8f3bzUvg7+sD8zXwu5t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gGeCZ4Fng2eA9z3b7fH9283L4G/rw/M18Dv95t6Gsx38A/wTPAs8GzwHOC+f7s9vn+7eQn8fX1gvgZu3XJPg/kO/gEe/V7ybrlng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzgvn+7Pb5/u3kJ/H19YL4Gbt1yT4P5Dv4BngmeBZ4NngPc92+3x/dvNy+Bv68PzNfArVvuaTDfwT/AM8GzwLPBc4D7/u32+P7t5iXw9/WB+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv90e37/dvAT+vj4wXwO3brmnwXwH/wDPBM8CzwbPAe77t9vj+7ebl8Df1wfma+DWLfc0mO/gH+CZ4Fng2eA5wH3/dnt8/3bzEvj7+sB8Ddy65Z4G8x38AzwTPAs8GzwHuO/fbo/v325eAn9fH5ivgVu33NNgvoN/gGeCZ4Fng+cA9/3b7fH9281L4O/rA/M1cOuWexrMd/AP8EzwLPBs8Bzg9hzx+P7t5iXw9/WB+Rq4dcs9DeZ74NYt90zwLPBs8Bzg/tjn+O6mvAT+/vTAfA387qaeBvMd/AM88ff33U09GzwHuO/ftFvOS+Cv5YH5Grh1yz0N5jv4B3gmeBZ4NngOcN+/5d2Ul8DvbjpfA7+7qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN/H6/qafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4Il/d1u33LPBc4D7/k275bwEbt3y+Rq4dcs9DeY7+Ad4JngWeDZ4DnDfv2m3nJfArVs+XwO3brmnwXwH/wDPBM8CzwbPAe77N+2W8xK4dcvna+DWLfc0mO/gH+CZ4Fng2eA5wH3/pt1yXgK3bvl8Ddy65Z4G8x38AzwTPAs8GzwHuO/ftFvOS+DWLZ+vgVu33NNgvoN/gCfuS6xb7tngOcB9/6bdcl4Ct275fA3cuuWeBvMd/AM8EzwLPBs8B7j/e5d2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgNtzxOP7N+2m/P35gfkauHXLPQ3mO/gHeOKe27rlng2eA9yfX3x+3/4o3ZSXwN+fHpivgd/d1NNgvoN/gGeCZ4Fng+cA9/2bdst5Cfy1PDBfA7duuafBfAf/AM8EzwLPBs8B7vu3vJvyEvjdTedr4Hc39TSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479/y95vyErh1y+dr4Pf7TT0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnAff+m3XJeArdu+XwN3LrlngbzHfwDPBM8CzwbPAe479+0W85L4NYtn6+BW7fc02C+g3+AZ4JngWeD5wD3/Zt2y3kJ3Lrl8zVw65Z7Gsx38A/wTPAs8GzwHOC+f9NuOS+BW7d8vgZu3XJPg/kO/gGeCZ4Fng2eA9z3b9ot5yVw65bP18CtW+5pMN/BP8AzwbPAs8FzgPv+TbvlvARu3fL5Grh1yz0N5jv4B3gmeBZ4NngOcN+/abecl8CtWz5fA7duuafBfAf/AM8EzwLPBs8B7vs37ZbzErh1y+dr4NYt9zSY7+Af4JngWeDZ4DnA7TmhW85L4O/PD8zXwK1b7mkw38E/wDPBs8CzwXOA+/P+d+H+J92Ul8Dfnx6Yr4Hf3dTTYL6Df4BngmeBZ4PnAPf9m3bLeQn8tTwwXwO3brmnwXwH/wDPBM8CzwbPAe77t7yb8hL43U3na+B3N/Xo/QXtpv4BHr2/oN3Uo/cXtJtyvb/g3XJeArdu+XwN3LrlHr2/4N1y/wCP3l/wbrlH7y94t5zr/QV9vykvgVu3fL4Gfr/f1KP3F/T9pv4BHr2/oO839ej9BX2/Kdf7C94t53p/wbvl83p/wbvlHr2/4N1yv95f8G65R+8veLfco/cX9HP6nXh8/6bdlFu3fL4Gbt1yj95f0M+p+gd49P6Cfk7Vo/cX9HOqXO8veLec6/0F75bP6/0F75Z79P6Cd8v9en/Bu+Uevb/g3XKP3l/Q32/fi8f3b9pNuXXL52vg1i336P0F/f2m/gEevb+gv9/Uo/cX9Pebcr2/4N1yrvcXvFs+r/cXvFvu0fsL3i336/0F75Z79P6Cd8s9en9BvxeGePT+gn4vDPHo/QX9Xhjyz6/3F/R7Qef1/oJ+L6hngkfvL+j3gnr0/oJ3s/2Sdsu53l/wbvm83l/wbrlH7y94t9yv9xe8W+7R+wveLffo/QX9Pv1BPL5/027KrVs+XwO3brlH7y/o96n6B3j0/oJ+n6pH7y/o96lyvb/g3XKu9xe8Wz6v9xe8W+7R+wveLffr/QXvlnv0/oJ3yz16f8G72X5Ju+Vc7y94t3xe7y/o3yHq0fsL+neI+vX+gnfLPXp/wbvlHr2/4N3sf9duOS+Bvz8/MF8Dt265R+8veLfcP8AzwaP3F7xb7jnA/Xn/u3A/STflJfD3pwfma+B3N/Xo/YWfpJv6B3gmePT+wk/STT0HuN5f8G45L4G/lgfma+DWLffo/QXvlvsHePT+gnfLPXp/wbvlXO8vaDflJfC7m87XwO9u6tH7C9pN/QM8en9Bu6lH7y9oN+V6f8G75bwEbt3y+Rq4dcs9en/Bu+X+AR69v+Ddco/eX/BuOdf7C/p+U14Ct275fA38fr+pR+8v6PtN/QM8en9B32/q0fsL+n5TrvcXvFvO9f6Cd8vn9f6Cd8s9en/Bu+V+vb/g3XKP3l/wbrlH7y/o5/Q78fj+Tbspt275fA3cuuUevb+gn1P1D/Do/QX9nKpH7y/o51S53l/wbjnX+wveLZ/X+wveLffo/QXvlvv1/oJ3yz16f8G75R69v6C/374Xj+/ftJty65bP18CtW+7R+wv6+039Azx6f0F/v6lH7y/o7zflen/Bu+Vc7y94t3xe7y94t9yj9xe8W+7X+wveLffo/QXvlnv0/oJ+Lwzx6P0F/V4Y4tH7C/q9MOSfX+8v6PeCzuv9Bf1eUM8Ej95f0O8F9ej9Be9m+yXj/wcPgkTdeF51mLGtFDEURd0CtVDAVvFbgBKoBUogI9gIEgIHZCZwABLIGFkYIyOXgHatx2rmvvOSpz26e6S9mp0Z+enpNtfLq/v8urx8cZu/lzt+isLDfRLks/C39/kKngL5Cv4Gng6eAZ4JngU8hDevb/P75LlefB6FW29+Pgu33nxPgXwFfwNPB88AzwTPAh7Ch/e3+SO9+TwKt978fBZuvfmeAvkK/gaeDp4BngmeBTyE799uM6U3n0fh1pufz8KtN99TIF/B38DTwTPAM8GzgNss6c3nUfj+nCCfhVtvvqdAvoK/gaeDZ4BngmcBP8869XbmUfjeCfJZ+LG3B9+7QL6Cv4Gng2eAZ4JnAQ/h2X3e/c9Zbz6PwvdOkM/CrTffUyBfwd/A08EzwDPBs4Bbbx+htzOPwvdOkM/Cj72dPQXyFfwNPB08AzwTPAu4vYd8kt58HoXvnSCfhVtvvqdAvoK/gaeDZ4BngmcBt+vts/Tm8yh87wT5LPx4vZ09BfIV/A08HTwDPBM8C3gI9vuOnqs8D623M987QT4Lt958T4F8BX8DTwfPAM8Ez/n5dv6ffpHefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbf33m/Sm8+j8L0T5LNw6833FMhX8DfwdPAM8EzwLOB2f/shvfk8Ct87QT4Lt958T4F8BX8DTwfPAM8EzwIewvP7/JTefB6F750gn4Vbb76nQL6Cv4Gng2eAZ4JnAbfnQjt5rhefR+F7J8hn4dab7ymQr+Bv4OngGeCZ4FnAQ7DzpWPucf525FH43gnyWbj15nsK5Cv4G3g6eAZ4JngW8Mf529HzOH878ih87wT5LNx68z0F8hX8DTwdPAM8EzwL+OP87eh5nL8deRS+d4J8Fm69+Z4C+Qr+Bp4OngGeCZ4F/HH+dvQ8zt+OPArfO0E+C7fefE+BfAV/A08HzwDPBM8CbnO+D17l+9bbme+dIK/v39ab7ymQr8KtN9/TwTPAo33R/gcuOnQL + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgKwAAUggAAA==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 + + + AQAAAACAAADICgAAAgIAAA==eF4txRGUIgoAAMD+/e69IAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAgWFoIgCBaCIFgIgiA4aEYmGPgIOeyIo4457oSTTjntjLPOOe+Ciy657Iqrrrnuhptuue2Ou+6574GHHnnsiaeeee6Fl1557Y233nnvg7/87aNPPvviH199892/fvjpl98O/Pcp6JDDjjjqmONOOOmU084465zzLrjoksuuuOqa62646Zbb7rjrnvseeOiRx5546pnnXnjpldfeeOud9z74y98++uSzL/7x1Tff/euHn3757cCfT0GHHHbEUcccd8JJp5x2xlnnnHfBRZdcdsVV11x3w0233HbHXffc98BDjzz2xFPPPPfCS6+89sZb77z3wV/+9tEnn33xj6+++e5fP/z0y28H/v8UdMhhRxx1zHEnnHTKaWecdc55F1x0yWVXXHXNdTfcdMttd9x1z30PPPTIY0889cxzL7z0ymtvvPXOex/85W8fffLZF//46pvv/vXDT7/8diAohxx2xFHHHHfCSaecdsZZ55x3wUWXXHbFVddcd8NNt9x2x1333PfAQ4889sRTzzz3wkuvvPbGW++898Ff/vbRJ5998Y+vvvnuXz/89MtvB/5+CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbvofDZKllw== + + + AQAAAACAAABZAQAADQAAAA==eF7j5BwFNAEANB4MIg== + + + + + diff --git a/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perTrue.vtu b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perTrue.vtu new file mode 100644 index 000000000..c6b422844 --- /dev/null +++ b/python/tests/reference/Geom/get_grain_boundaries_4g12x15x20_z_perTrue.vtu @@ -0,0 +1,35 @@ + + + + + + + + + + + BAAAAACAAACAGQAA9g4AADYOAADfDQAA8QIAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgMgAAngkAAA==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 + + + AQAAAACAAACIDAAASwIAAA==eF4txRGUKggAAMD+Xf9eEARBEARBEARBEARBsBAEQRAsBEEQBEEQBEEQBEEQBEGwEARBEARBEARBEARBECwcNCMTDHyEHHbEUcccd8JJp5x2xlnnnHfBRZf85bIrrrrmur/dcNMtt91x1z33PfDQI4898dQzz73w0iv/eO2Nt95574OPPvnsi6+++e6Hn3757V8H/nwKOuSwI4465rgTTjrltDPOOue8Cy665C+XXXHVNdf97Yabbrntjrvuue+Bhx557ImnnnnuhZde+cdrb7z1znsffPTJZ1989c13P/z0y2//OvDPp6BDDjviqGOOO+GkU04746xzzrvgokv+ctkVV11z3d9uuOmW2+646577HnjokceeeOqZ51546ZV/vPbGW++898FHn3z2xVfffPfDT7/89q8D/34KOuSwI4465rgTTjrltDPOOue8Cy665C+XXXHVNdf97Yabbrntjrvuue+Bhx557ImnnnnuhZde+cdrb7z1znsffPTJZ1989c13P/z0y2//OhCUQw474qhjjjvhpFNOO+Osc8674KJL/nLZFVddc93fbrjpltvuuOue+x546JHHnnjqmedeeOmVf7z2xlvvvPfBR5989sVX33z3w0+//PavA38/BR1y2BFHHXPcCSedctoZZ51z3gUXXfKXy6646prr/nbDTbfcdsdd99z3wEOPPPbEU88898JLr/zjtTfeeue9Dz765LMvvvrmux9++uW3fx3471PQIYcdcdQxx51w0imnnXHWOeddcNH/Axqgw5E= + + + AQAAAACAAACRAQAADgAAAA==eF7j5BwFgwoAABPXDho= + + + + + diff --git a/python/tests/test_Geom.py b/python/tests/test_Geom.py index 0f4c1a952..8c44daba7 100644 --- a/python/tests/test_Geom.py +++ b/python/tests/test_Geom.py @@ -363,3 +363,12 @@ class TestGeom: grid = np.ones(3,dtype=int)*64 geom = Geom.from_minimal_surface(grid,np.ones(3),surface,threshold) assert np.isclose(np.count_nonzero(geom.material==1)/np.prod(geom.grid),.5,rtol=1e-3) + + @pytest.mark.parametrize('periodic',[True,False]) + @pytest.mark.parametrize('direction',['x','y','z']) + def test_get_grain_boundaries(self,periodic,direction,reference_dir): + geom=Geom.load(reference_dir/'get_grain_boundaries_4g12x15x20.vtr') + current=geom.get_grain_boundaries(periodic,direction) + reference=VTK.load(reference_dir/f'get_grain_boundaries_4g12x15x20_{direction}_per{periodic}.vtu') + assert current == reference + From c2be41b9f6e4c3779c24a6e54aea5c5d019a8101 Mon Sep 17 00:00:00 2001 From: "f.basile" Date: Wed, 25 Nov 2020 12:53:29 +0100 Subject: [PATCH 21/22] remove import vtk because unused --- python/damask/_geom.py | 1 - 1 file changed, 1 deletion(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index c0383062b..04903f89b 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -6,7 +6,6 @@ from os import path import numpy as np import h5py from scipy import ndimage,spatial -import vtk from . import environment from . import VTK From 3c1f1af009f3a89103e092efb907ad315e5bc37c Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Fri, 27 Nov 2020 20:16:06 +0100 Subject: [PATCH 22/22] more then one direction in file --- python/damask/_geom.py | 42 ++++++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/python/damask/_geom.py b/python/damask/_geom.py index 04903f89b..784fd3139 100644 --- a/python/damask/_geom.py +++ b/python/damask/_geom.py @@ -840,36 +840,38 @@ class Geom: origin = self.origin, comments = self.comments+[util.execution_stamp('Geom','vicinity_offset')], ) - - def get_grain_boundaries(self,periodic=True,direction='x'): + + + def get_grain_boundaries(self,periodic=True,directions='xyz'): """ - Create mesh in VTK to show grain boundaries as feature edges. + Create VTK unstructured grid containing grain boundaries. Parameters ---------- - periodic : Boolean, optional + periodic : bool, optional Show boundaries across periodicity. Defaults to True. - direction : string - Show grain boundaries only across a certain direction. ['x','y','z'] + direction : string, optional + Directions to consider ('x','y','z'). Defaults to 'xyz'. """ - coord=grid_filters.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') # offset (for connectivity) o = [[0, self.grid[0]+1, np.prod(self.grid[:2]+1)+self.grid[0]+1, np.prod(self.grid[:2]+1)], [0, np.prod(self.grid[:2]+1), np.prod(self.grid[:2]+1)+1, 1], [0, 1, self.grid[0]+1+1, self.grid[0]+1]] + + connectivity = [] + for i,d in enumerate(['x','y','z']): + if d not in directions.lower(): continue + 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 - d_s=ord(direction)-120 # x=0, y=1, z=2 - mask = self.material != np.roll(self.material,1,d_s) - for d in [0,1,2]: - extra_layer = np.take(mask,[0],d) if d_s == d else np.zeros_like(np.take(mask,[0],d),bool) - mask = np.concatenate((mask,extra_layer),d) - if d_s == 0 and not periodic: mask[0,:,:] = mask[-1,:,:] = False - if d_s == 1 and not periodic: mask[:,0,:] = mask[:,-1,:] = False - if d_s == 2 and not periodic: mask[:,:,0] = mask[:,:,-1] = False - base_nodes = np.argwhere(mask.flatten(order='F')).reshape(-1,1) - connectivity = np.block([base_nodes + o[d_s][d] for d in range(4)]) - return VTK.from_unstructuredGrid(coord,connectivity,'QUAD') - - + 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.node_coord0(self.grid,self.size,self.origin).reshape(-1,3,order='F') + return VTK.from_unstructuredGrid(coords,np.vstack(connectivity),'QUAD')