From 6e7a70b643af6f02f5f95066249de1c4175d4cfa Mon Sep 17 00:00:00 2001 From: Kursat Yurt Date: Sat, 2 Jul 2022 17:40:57 +0200 Subject: [PATCH 01/31] Add write_block_vector_gradient_data --- cyprecice/cyprecice.pyx | 57 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 52dc6f03..2df67819 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1211,6 +1211,63 @@ cdef class Interface: self.thisptr.readScalarData (data_id, vertex_id, _value) return _value +def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): + """ + Writes vector data given as block. This function writes values of specified vertices to a dataID. + Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number + of vertices and D = dimensions of geometry + + Parameters + ---------- + data_id : int + Data ID to write to. + vertex_ids : array_like + Indices of the vertices. + gradientValues : array_like + Gradient values differentiated in the spacial direction (dx, dy) for 2D space, (dx, dy, dz) for 3D space + + Notes + ----- + Previous calls: + count of available elements at values matches the configured dimension + count of available elements at vertex_ids matches the given size + initialize() has been called + Data with dataID has attribute hasGradient = true + + Examples + -------- + Write block vector data for a 2D problem with 5 vertices: + >>> data_id = 1 + >>> vertex_ids = [1, 2, 3, 4, 5] + >>> values = np.array([[v1_x, v1_y], [v2_x, v2_y], [v3_x, v3_y], [v4_x, v4_y], [v5_x, v5_y]]) + >>> interface.write_block_vector_data(data_id, vertex_ids, values) + + Write block vector data for a 3D (D=3) problem with 5 (N=5) vertices: + >>> data_id = 1 + >>> vertex_ids = [1, 2, 3, 4, 5] + >>> values = np.array([[v1_x, v1_y, v1_z], [v2_x, v2_y, v2_z], [v3_x, v3_y, v3_z], [v4_x, v4_y, v4_z], [v5_x, v5_y, v5_z]]) + >>> interface.write_block_vector_data(data_id, vertex_ids, values) + """ + check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") + check_array_like(values, "values", "write_block_vector_gradient_data") + + if not isinstance(values, np.ndarray): + values = np.asarray(values) + + if len(values) > 0: + size, dimensions = values.shape + assert dimensions == self.get_dimensions(), "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) + if len(values) == 0: + size = 0 + + cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) + cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) + + assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions()) + assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) + + self.thisptr.writeBlockVectorGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) + def set_mesh_access_region (self, mesh_id, bounding_box): """ This function is required if you don't want to use the mapping schemes in preCICE, but rather From 9e358479af947c6e31e8bd52b9bfd10a00c59661 Mon Sep 17 00:00:00 2001 From: Kursat Yurt Date: Sat, 2 Jul 2022 17:43:02 +0200 Subject: [PATCH 02/31] Add gradient related API --- cyprecice/SolverInterface.pxd | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/cyprecice/SolverInterface.pxd b/cyprecice/SolverInterface.pxd index dd3368c9..3ae8db3a 100644 --- a/cyprecice/SolverInterface.pxd +++ b/cyprecice/SolverInterface.pxd @@ -101,6 +101,18 @@ cdef extern from "precice/SolverInterface.hpp" namespace "precice": void readScalarData (const int dataID, const int valueIndex, double& value) const + # Gradient related API + + bool isGradientDataRequired(int dataID) const; + + void writeBlockVectorGradientData(int dataID, int size, const int* valueIndices, const double* gradientValues); + + void writeScalarGradientData(int dataID, int valueIndex, const double* gradientValues); + + void writeVectorGradientData(int dataID, int valueIndex, const double* gradientValues); + + void writeBlockScalarGradientData(int dataID, int size, const int* valueIndices, const double* gradientValues); + # direct mesh access void setMeshAccessRegion (const int meshID, const double* boundingBox) const From 9f02b68d82fb6717b296cfcb33de7e61de5a2742 Mon Sep 17 00:00:00 2001 From: Kursat Yurt Date: Sat, 2 Jul 2022 18:23:41 +0200 Subject: [PATCH 03/31] Add rest of the API calls --- cyprecice/cyprecice.pyx | 190 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 175 insertions(+), 15 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 2df67819..3429d2a5 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1211,11 +1211,11 @@ cdef class Interface: self.thisptr.readScalarData (data_id, vertex_id, _value) return _value -def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): + def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): """ - Writes vector data given as block. This function writes values of specified vertices to a dataID. + Writes vector gradient data given as block. This function writes values of specified vertices to a dataID. Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number - of vertices and D = dimensions of geometry + of vertices and D = dimensions of geometry squared. Parameters ---------- @@ -1229,23 +1229,23 @@ def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues) Notes ----- Previous calls: - count of available elements at values matches the configured dimension - count of available elements at vertex_ids matches the given size - initialize() has been called + Count of available elements at values matches the configured dimension + Count of available elements at vertex_ids matches the given size + Initialize() has been called Data with dataID has attribute hasGradient = true Examples -------- - Write block vector data for a 2D problem with 5 vertices: + Write block gradient vector data for a 2D problem with 2 vertices: >>> data_id = 1 - >>> vertex_ids = [1, 2, 3, 4, 5] - >>> values = np.array([[v1_x, v1_y], [v2_x, v2_y], [v3_x, v3_y], [v4_x, v4_y], [v5_x, v5_y]]) - >>> interface.write_block_vector_data(data_id, vertex_ids, values) + >>> vertex_ids = [1, 2] + >>> gradientValues = np.array([[v1x_dx, v1y_dx,v1x_dy, v1y_dy], [v2x_dx, v2y_dx,v2x_dy, v2y_dy]]) + >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) - Write block vector data for a 3D (D=3) problem with 5 (N=5) vertices: + Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 - >>> vertex_ids = [1, 2, 3, 4, 5] - >>> values = np.array([[v1_x, v1_y, v1_z], [v2_x, v2_y, v2_z], [v3_x, v3_y, v3_z], [v4_x, v4_y, v4_z], [v5_x, v5_y, v5_z]]) + >>> vertex_ids = [1, 2] + >>> values = np.array([[v1x_dx, v1y_dx, v1z_dx, v1x_dy, v1y_dy, v1z_dy, v1x_dz, v1y_dz, v1z_dz], [v2x_dx, v2y_dx, v2z_dx, v2x_dy, v2y_dy, v2z_dy, v2x_dz, v2y_dz, v2z_dz]]) >>> interface.write_block_vector_data(data_id, vertex_ids, values) """ check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") @@ -1256,18 +1256,178 @@ def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues) if len(values) > 0: size, dimensions = values.shape - assert dimensions == self.get_dimensions(), "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) + assert dimensions == self.get_dimensions() * self.get_dimensions(), "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions() * self.get_dimensions()) if len(values) == 0: size = 0 cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions()) + assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions() * self.get_dimensions()) assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) self.thisptr.writeBlockVectorGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) + def write_scalar_gradient_data (self, data_id, vertex_id, gradientValues): + """ + Writes scalar gradient data to a vertex + This function writes the corresponding gradient matrix value of a specified vertex to a dataID. + + The gradients need to be provided in the following format: + + The 2D-format of gradientValues is (v_dx, v_dy) vector corresponding to the data block v = (v) + differentiated respectively in x-direction dx and y-direction dy + + The 3D-format of gradientValues is (v_dx, v_dy, v_dz) vector + corresponding to the data block v = (v) differentiated respectively in spatial directions x-direction dx and y-direction dy and z-direction dz + + Parameters + ---------- + data_id : int + ID to write to. + vertex_id : int + Index of the vertex. + gradientValue : array_like + A vector of the gradient values. + + Notes + ----- + Count of available elements at value matches the configured dimension + Vertex with dataID exists and contains data + Data with dataID has attribute hasGradient = true + + Previous calls: + initialize() has been called + + Examples + -------- + Write scalar data for a 2D problem with 5 vertices: + >>> data_id = 1 + >>> vertex_id = 5 + >>> gradientValue = [v5_dx,v5_dy] + >>> interface.write_scalar_gradient_data(data_id, vertex_id, gradientValue) + """ + + check_array_like(gradientValues, "gradientValues", "write_scalar_gradient_data") + + if not isinstance(gradientValues, np.ndarray): + gradientValues = np.asarray(gradientValues) + + cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) + + assert _gradientValues.size == self.get_dimensions(), "Vector data provided for vertex {} in write_scalar_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions()) + + self.thisptr.writeScalarGradientData (data_id, size, vertex_id, _gradientValues.data) + + def write_vector_gradient_data (self, data_id, vertex_id, gradientValues): + """ + Writes vector gradient data to a vertex + This function writes the corresponding gradient matrix value of a specified vertex to a dataID. + + The gradients need to be provided in the following format: + + The 2D-format of \p gradientValues is (vx_dx, vy_dx, vx_dy, vy_dy) vector corresponding to the data block v = (vx, vy) + differentiated respectively in x-direction dx and y-direction dy + + The 3D-format of \p gradientValues is (vx_dx, vy_dx, vz_dx, vx_dy, vy_dy, vz_dy, vx_dz, vy_dz, vz_dz) vector + corresponding to the data block v = (vx, vy, vz) differentiated respectively in spatial directions x-direction dx and y-direction dy and z-direction dz + + Parameters + ---------- + data_id : int + ID to write to. + vertex_id : int + Index of the vertex. + gradientValue : array_like + A vector of the gradient values. + + Notes + ----- + Count of available elements at value matches the configured dimension + Vertex with dataID exists and contains data + Data with dataID has attribute hasGradient = true + + Previous calls: + initialize() has been called + + Examples + -------- + Write scalar data for a 2D problem with 5 vertices: + >>> data_id = 1 + >>> vertex_id = 5 + >>> gradientValue = [v5x_dx, v5y_dx, v5x_dy,v5y_dy] + >>> interface.write_vector_gradient_data(data_id, vertex_id, gradientValue) + """ + + check_array_like(gradientValues, "gradientValues", "write_vector_gradient_data") + + if not isinstance(gradientValues, np.ndarray): + gradientValues = np.asarray(gradientValues) + + cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) + + assert _gradientValues.size == self.get_dimensions()* self.get_dimensions(), "Vector data provided for vertex {} in write_scalar_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions() * self.get_dimensions()) + + self.thisptr.writeVectorGradientData (data_id, size, vertex_id, _gradientValues.data) + + def write_block_scalar_gradient_data (self, data_id, vertex_ids, gradientValues): + """ + Writes scalar gradient data given as block. This function writes values of specified vertices to a dataID. + Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number + of vertices and D = dimensions of geometry. + + Parameters + ---------- + data_id : int + Data ID to write to. + vertex_ids : array_like + Indices of the vertices. + gradientValues : array_like + Gradient values differentiated in the spacial direction (dx, dy) for 2D space, (dx, dy, dz) for 3D space + + Notes + ----- + Previous calls: + Count of available elements at values matches the configured dimension + Count of available elements at vertex_ids matches the given size + Initialize() has been called + Data with dataID has attribute hasGradient = true + + Examples + -------- + Write block gradient vector data for a 2D problem with 2 vertices: + >>> data_id = 1 + >>> vertex_ids = [1, 2] + >>> gradientValues = np.array([[v1_dx, v1_dy],[v2_dx, v2_dy]]) + >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) + + Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: + >>> data_id = 1 + >>> vertex_ids = [1, 2] + >>> values = np.array([[v1_dx, v1_dy, v1x_dz], [v2_dx. v2_dy, v2_dz]]) + >>> interface.write_block_scalar_data(data_id, vertex_ids, values) + """ + check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") + check_array_like(values, "values", "write_block_vector_gradient_data") + + if not isinstance(values, np.ndarray): + values = np.asarray(values) + + if len(values) > 0: + size, dimensions = values.shape + assert dimensions == self.get_dimensions() , "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) + if len(values) == 0: + size = 0 + + cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) + cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) + + assert _gradientValues.size == size * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions()) + assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) + + self.thisptr.writeBlockScalarGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) + + def set_mesh_access_region (self, mesh_id, bounding_box): """ This function is required if you don't want to use the mapping schemes in preCICE, but rather From bd7d0315c7db73b996a7879944c05ef645ca5a5c Mon Sep 17 00:00:00 2001 From: Kursat Date: Mon, 4 Jul 2022 12:30:27 +0200 Subject: [PATCH 04/31] Typo and indentation fixes --- cyprecice/cyprecice.pyx | 44 ++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 3429d2a5..26ae6ab8 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1211,7 +1211,7 @@ cdef class Interface: self.thisptr.readScalarData (data_id, vertex_id, _value) return _value - def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): + def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): """ Writes vector gradient data given as block. This function writes values of specified vertices to a dataID. Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number @@ -1249,21 +1249,21 @@ cdef class Interface: >>> interface.write_block_vector_data(data_id, vertex_ids, values) """ check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") - check_array_like(values, "values", "write_block_vector_gradient_data") + check_array_like(gradientValues, "gradientValues", "write_block_vector_gradient_data") - if not isinstance(values, np.ndarray): - values = np.asarray(values) + if not isinstance(gradientValues, np.ndarray): + gradientValues = np.asarray(gradientValues) - if len(values) > 0: - size, dimensions = values.shape + if len(gradientValues) > 0: + size, dimensions = gradientValues.shape assert dimensions == self.get_dimensions() * self.get_dimensions(), "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions() * self.get_dimensions()) - if len(values) == 0: + if len(gradientValues) == 0: size = 0 cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions() * self.get_dimensions()) + assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions() * self.get_dimensions()) assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) self.thisptr.writeBlockVectorGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) @@ -1317,9 +1317,9 @@ cdef class Interface: assert _gradientValues.size == self.get_dimensions(), "Vector data provided for vertex {} in write_scalar_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions()) - self.thisptr.writeScalarGradientData (data_id, size, vertex_id, _gradientValues.data) + self.thisptr.writeScalarGradientData(data_id, vertex_id, _gradientValues.data) - def write_vector_gradient_data (self, data_id, vertex_id, gradientValues): + def write_vector_gradient_data (self, data_id, vertex_id, gradientValues): """ Writes vector gradient data to a vertex This function writes the corresponding gradient matrix value of a specified vertex to a dataID. @@ -1368,9 +1368,9 @@ cdef class Interface: assert _gradientValues.size == self.get_dimensions()* self.get_dimensions(), "Vector data provided for vertex {} in write_scalar_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions() * self.get_dimensions()) - self.thisptr.writeVectorGradientData (data_id, size, vertex_id, _gradientValues.data) + self.thisptr.writeVectorGradientData(data_id, vertex_id, _gradientValues.data) - def write_block_scalar_gradient_data (self, data_id, vertex_ids, gradientValues): + def write_block_scalar_gradient_data (self, data_id, vertex_ids, gradientValues): """ Writes scalar gradient data given as block. This function writes values of specified vertices to a dataID. Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number @@ -1407,23 +1407,23 @@ cdef class Interface: >>> values = np.array([[v1_dx, v1_dy, v1x_dz], [v2_dx. v2_dy, v2_dz]]) >>> interface.write_block_scalar_data(data_id, vertex_ids, values) """ - check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") - check_array_like(values, "values", "write_block_vector_gradient_data") + check_array_like(vertex_ids, "vertex_ids", "write_block_scalar_gradient_data") + check_array_like(gradientValues, "gradientValues", "write_block_sclar_gradient_data") - if not isinstance(values, np.ndarray): - values = np.asarray(values) + if not isinstance(gradientValues, np.ndarray): + gradientValues = np.asarray(gradientValues) - if len(values) > 0: - size, dimensions = values.shape - assert dimensions == self.get_dimensions() , "Dimensions of vector data in write_block_vector_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) - if len(values) == 0: + if len(gradientValues) > 0: + size, dimensions = gradientValues.shape + assert dimensions == self.get_dimensions() , "Dimensions of vector data in write_block_scalar_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) + if len(gradientValues) == 0: size = 0 cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == size * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_values.size, size * self.get_dimensions()) - assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) + assert _gradientValues.size == size * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions()) + assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_scalar_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) self.thisptr.writeBlockScalarGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) From dc6237caabd67c33fdb48b06ca43543bd194e7dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Wed, 13 Jul 2022 14:11:12 +0200 Subject: [PATCH 05/31] Change values to gradientValues --- cyprecice/cyprecice.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 26ae6ab8..fd33c98a 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1245,8 +1245,8 @@ cdef class Interface: Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] - >>> values = np.array([[v1x_dx, v1y_dx, v1z_dx, v1x_dy, v1y_dy, v1z_dy, v1x_dz, v1y_dz, v1z_dz], [v2x_dx, v2y_dx, v2z_dx, v2x_dy, v2y_dy, v2z_dy, v2x_dz, v2y_dz, v2z_dz]]) - >>> interface.write_block_vector_data(data_id, vertex_ids, values) + >>> gradientValues = np.array([[v1x_dx, v1y_dx, v1z_dx, v1x_dy, v1y_dy, v1z_dy, v1x_dz, v1y_dz, v1z_dz], [v2x_dx, v2y_dx, v2z_dx, v2x_dy, v2y_dy, v2z_dy, v2x_dz, v2y_dz, v2z_dz]]) + >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) """ check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") check_array_like(gradientValues, "gradientValues", "write_block_vector_gradient_data") From 6ac64b8b33d26964b2a3dbfccaa8c33cd7ddacd6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Wed, 13 Jul 2022 14:12:28 +0200 Subject: [PATCH 06/31] Update cyprecice/cyprecice.pyx Co-authored-by: David Schneider --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index fd33c98a..428aa17f 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1215,7 +1215,7 @@ cdef class Interface: """ Writes vector gradient data given as block. This function writes values of specified vertices to a dataID. Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number - of vertices and D = dimensions of geometry squared. + of vertices and D = number of gradient components. Parameters ---------- From 76ec77958aa397f4a378255c4e43785ffe7549f6 Mon Sep 17 00:00:00 2001 From: Kursat Date: Wed, 13 Jul 2022 18:58:53 +0200 Subject: [PATCH 07/31] Add is_gradient_data_required method --- cyprecice/cyprecice.pyx | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 428aa17f..e2438031 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1427,6 +1427,32 @@ cdef class Interface: self.thisptr.writeBlockScalarGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) + def is_gradient_data_required(self,data_id): + """ + Returns true if gradient data is required for a dataID. + Parameters + ---------- + data_id : int + Data ID to check. + + Returns + ------- + bool + True if gradient data is required for a dataID. + + Notes + ----- + Previous calls: + initialize() has been called + + Examples + -------- + Check if gradient data is required for a dataID: + >>> data_id = 1 + >>> interface.is_gradient_data_required(data_id) + """ + return self.thisptr.isGradientDataRequired(data_id) + def set_mesh_access_region (self, mesh_id, bounding_box): """ From 7f021a38974d1c871a9274a715644937f9aaf01a Mon Sep 17 00:00:00 2001 From: Kursat Date: Wed, 13 Jul 2022 20:03:49 +0200 Subject: [PATCH 08/31] Add write_tests --- test/SolverInterface.cpp | 51 +++++++++++++++++ test/test_bindings_module.py | 104 +++++++++++++++++++++++++++++++++++ 2 files changed, 155 insertions(+) diff --git a/test/SolverInterface.cpp b/test/SolverInterface.cpp index c23fbf7a..fcf7da4a 100644 --- a/test/SolverInterface.cpp +++ b/test/SolverInterface.cpp @@ -4,6 +4,7 @@ #include std::vector fake_read_write_buffer; +std::vector fake_gradient_buffer; int fake_dimensions; int fake_mesh_id; std::vector fake_ids; @@ -395,6 +396,56 @@ void SolverInterface:: getMeshVerticesAndIDs } } +bool SolverInterface::isGradientDataRequired(int dataID) const +{ + return 0; +} + +void SolverInterface::writeBlockVectorGradientData( + int dataID, + int size, + const int *valueIndices, + const double *gradientValues) +{ + fake_gradient_buffer.clear(); + for (int i = 0; i < size * this->getDimensions() * this->getDimensions(); i++) { + fake_gradient_buffer.push_back(gradientValues[i]); + } +} + +void SolverInterface::writeScalarGradientData( + int dataID, + int valueIndex, + const double *gradientValues) +{ + fake_gradient_buffer.clear(); + for (int i = 0; i < this->getDimensions(); i++) { + fake_gradient_buffer.push_back(gradientValues[i]); + } +} +void SolverInterface::writeBlockScalarGradientData( + int dataID, + int size, + const int *valueIndices, + const double *gradientValues) +{ + fake_gradient_buffer.clear(); + for (int i = 0; i < size * this->getDimensions(); i++) { + fake_gradient_buffer.push_back(gradientValues[i]); + } +} + +void SolverInterface::writeVectorGradientData( + int dataID, + int valueIndex, + const double *gradientValues) +{ + fake_gradient_buffer.clear(); + for (int i = 0; i < this->getDimensions() * this->getDimensions(); i++) { + fake_gradient_buffer.push_back(gradientValues[i]); + } +} + std::string getVersionInformation() { std::string dummy ("dummy"); diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index 407a1e97..c6d532fa 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -409,3 +409,107 @@ def test_get_mesh_vertices_and_ids(self): fake_ids, fake_coordinates = solver_interface.get_mesh_vertices_and_ids(fake_mesh_id) self.assertTrue(np.array_equal(fake_ids, vertex_ids)) self.assertTrue(np.array_equal(fake_coordinates, coordinates)) + + def test_is_gradient_data_required(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + fake_bool = 0 # compare to output in test/SolverInterface.cpp + fake_data_id = 0 + self.assertEqual(fake_bool, solver_interface.is_gradient_data_required(fake_data_id)) + + def test_write_block_scalar_gradient_data(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = np.array([[1, 2, 3], [6, 7, 8], [9, 10, 11]]) + solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) + + def test_write_block_scalar_gradient_data_single_float(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = [8.0, 9.0, 10.0] + with self.assertRaises(TypeError): + solver_interface.write_block_scalar_gradient_data(1, 1, write_data) + + def test_write_block_scalar_gradient_data_empty(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = np.array([]) + solver_interface.write_block_scalar_gradient_data(1, [], write_data) + + def test_write_block_scalar_data_non_contiguous(self): + """ + Tests behaviour of solver interface, if a non contiguous array is passed to the interface. + + Note: Check whether np.ndarray is contiguous via np.ndarray.flags. + """ + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + dummy_array = np.random.rand(3, 9) + write_data = dummy_array[:, 3:6] + assert write_data.flags["C_CONTIGUOUS"] is False + solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) + + def test_write_scalar_data(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = [3, 4, 5] + solver_interface.write_scalar_gradient_data(1, 1, write_data) + + def test_write_block_vector__gradient_data(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = np.array([[3, 7, 8, 3, 4, 5, 6, 7, 8], [7, 6, 5, 1, 2, 3, 7, 6, 5]], dtype=np.double) + solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + + def test_write_block_vector_gradient_data_empty(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = np.array([]) + solver_interface.write_block_vector_gradient_data(1, [], write_data) + + def test_write_block_vector_gradient_data_list(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = [[3, 7, 8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7, 6, 5]] + solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + + def test_write_block_vector_gradient_data_tuple(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = ((1, 2, 3, 4, 5, 6, 3, 7, 8), (1, 2, 3, 4, 5, 6, 7, 6, 5)) + solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + + def test_read_write_block_vector_gradient_data_mixed(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = [(1, 2, 3, 4, 5, 6, 3, 7, 8), (4, 5, 6, 7, 8, 9, 7, 6, 5)] + solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + + def test_write_block_vector_gradient_data_non_contiguous(self): + """ + Tests behaviour of solver interface, if a non contiguous array is passed to the interface. + + Note: Check whether np.ndarray is contiguous via np.ndarray.flags. + """ + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + dummy_array = np.random.rand(3, 15) + write_data = dummy_array[:, 2:11] + assert write_data.flags["C_CONTIGUOUS"] is False + vertex_ids = np.arange(3) + solver_interface.write_block_vector_gradient_data(1, vertex_ids, write_data) + + def test_write_vector_gradient_data(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = np.arange(0, 9, dtype=np.double) + solver_interface.write_vector_gradient_data(1, 1, write_data) + + def test_write_vector_data_list(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = [1, 2, 3, 4, 5, 6, 7, 8, 9] + solver_interface.write_vector_gradient_data(1, 1, write_data) + + def test_write_vector_data_tuple(self): + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + write_data = (1, 2, 3, 9, 8, 7, 6, 5, 4) + solver_interface.write_vector_gradient_data(1, 1, write_data) + + def test_write_vector_gradient_data_non_contiguous(self): + """ + Tests behaviour of solver interface, if a non contiguous array is passed to the interface. + + Note: Check whether np.ndarray is contiguous via np.ndarray.flags. + """ + solver_interface = precice.Interface("test", "dummy.xml", 0, 1) + dummy_array = np.random.rand(9, 3) + write_data = dummy_array[:, 1] + assert write_data.flags["C_CONTIGUOUS"] is False + solver_interface.write_vector_gradient_data(1, 1, write_data) From 5fd02592dd321da56fcc84d77f4b56353388b156 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 10:46:27 +0200 Subject: [PATCH 09/31] Change doc of isGradientRequired --- cyprecice/cyprecice.pyx | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index e2438031..78b6dcd4 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1429,7 +1429,7 @@ cdef class Interface: def is_gradient_data_required(self,data_id): """ - Returns true if gradient data is required for a dataID. + Checks if the given data set requires gradient data. We check if the data object has been intialized with the gradient flag. Parameters ---------- data_id : int @@ -1440,11 +1440,6 @@ cdef class Interface: bool True if gradient data is required for a dataID. - Notes - ----- - Previous calls: - initialize() has been called - Examples -------- Check if gradient data is required for a dataID: From 32b3144db4a4b10d33ed7e7a3c99b21d0bd9a1c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:39:01 +0200 Subject: [PATCH 10/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 78b6dcd4..12ed42eb 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1213,7 +1213,7 @@ cdef class Interface: def write_block_vector_gradient_data (self, data_id, vertex_ids, gradientValues): """ - Writes vector gradient data given as block. This function writes values of specified vertices to a dataID. + Writes vector gradient data given as block. This function writes gradient values of specified vertices to a dataID. Values are provided as a block of continuous memory. Values are stored in a numpy array [N x D] where N = number of vertices and D = number of gradient components. From d90ee9571df70f9d8d90bb84fb7b2d2107576599 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:39:24 +0200 Subject: [PATCH 11/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 12ed42eb..085b249e 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1240,7 +1240,7 @@ cdef class Interface: >>> data_id = 1 >>> vertex_ids = [1, 2] >>> gradientValues = np.array([[v1x_dx, v1y_dx,v1x_dy, v1y_dy], [v2x_dx, v2y_dx,v2x_dy, v2y_dy]]) - >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) + >>> interface.write_block_vector_gradient_data(data_id, vertex_ids, gradientValues) Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 From 89a6bca94615a88f750112218de710bfc234d7e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:39:31 +0200 Subject: [PATCH 12/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 085b249e..a9e85b6f 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1246,7 +1246,7 @@ cdef class Interface: >>> data_id = 1 >>> vertex_ids = [1, 2] >>> gradientValues = np.array([[v1x_dx, v1y_dx, v1z_dx, v1x_dy, v1y_dy, v1z_dy, v1x_dz, v1y_dz, v1z_dz], [v2x_dx, v2y_dx, v2z_dx, v2x_dy, v2y_dy, v2z_dy, v2x_dz, v2y_dz, v2z_dz]]) - >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) + >>> interface.write_block_vector_gradient_data(data_id, vertex_ids, gradientValues) """ check_array_like(vertex_ids, "vertex_ids", "write_block_vector_gradient_data") check_array_like(gradientValues, "gradientValues", "write_block_vector_gradient_data") From b0af3f270cf43e586a2a8974b09e32d3b2a742f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:39:48 +0200 Subject: [PATCH 13/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index a9e85b6f..69caa93e 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1239,7 +1239,7 @@ cdef class Interface: Write block gradient vector data for a 2D problem with 2 vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] - >>> gradientValues = np.array([[v1x_dx, v1y_dx,v1x_dy, v1y_dy], [v2x_dx, v2y_dx,v2x_dy, v2y_dy]]) + >>> gradientValues = np.array([[v1x_dx, v1y_dx, v1x_dy, v1y_dy], [v2x_dx, v2y_dx, v2x_dy, v2y_dy]]) >>> interface.write_block_vector_gradient_data(data_id, vertex_ids, gradientValues) Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: From 7d6bfef93c536fa1604683c8d7af491c843a5032 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:40:29 +0200 Subject: [PATCH 14/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 1 + 1 file changed, 1 insertion(+) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 69caa93e..68814306 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1430,6 +1430,7 @@ cdef class Interface: def is_gradient_data_required(self,data_id): """ Checks if the given data set requires gradient data. We check if the data object has been intialized with the gradient flag. + Parameters ---------- data_id : int From 6dba6be603bbf39d6021efd974540fd48d87c350 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:40:52 +0200 Subject: [PATCH 15/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 68814306..821f3199 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1422,7 +1422,7 @@ cdef class Interface: cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == size * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions()) + assert _gradientValues.size == size * self.get_dimensions(), "Scalar gradient data is not provided for all vertices in write_block_scalar_gradient_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions()) assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_scalar_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) self.thisptr.writeBlockScalarGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) From fd805b4040a0a2a357077bb8eee911df6489a86f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:41:04 +0200 Subject: [PATCH 16/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 821f3199..01c3c777 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1415,7 +1415,7 @@ cdef class Interface: if len(gradientValues) > 0: size, dimensions = gradientValues.shape - assert dimensions == self.get_dimensions() , "Dimensions of vector data in write_block_scalar_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) + assert dimensions == self.get_dimensions() , "Dimensions of scalar gradient data provided in write_block_scalar_gradient_data does not match with dimensions in problem definition. Provided dimensions: {}, expected dimensions: {}".format(dimensions, self.get_dimensions()) if len(gradientValues) == 0: size = 0 From ccf1b02d86fc02a7624ee76144834a5b8d547dbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:41:14 +0200 Subject: [PATCH 17/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 01c3c777..a11024ae 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1366,7 +1366,7 @@ cdef class Interface: cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == self.get_dimensions()* self.get_dimensions(), "Vector data provided for vertex {} in write_scalar_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions() * self.get_dimensions()) + assert _gradientValues.size == self.get_dimensions() * self.get_dimensions(), "Dimensions of vector gradient data provided for vertex {} in write_vector_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, self.get_dimensions() * self.get_dimensions()) self.thisptr.writeVectorGradientData(data_id, vertex_id, _gradientValues.data) From 90fe22e8f9b3d72a54a92e20f76cfc5a07aad7ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:41:22 +0200 Subject: [PATCH 18/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index a11024ae..e3e4d1ec 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1399,7 +1399,7 @@ cdef class Interface: >>> data_id = 1 >>> vertex_ids = [1, 2] >>> gradientValues = np.array([[v1_dx, v1_dy],[v2_dx, v2_dy]]) - >>> interface.write_block_vector_data(data_id, vertex_ids, gradientValues) + >>> interface.write_block_scalar_gradient_data(data_id, vertex_ids, gradientValues) Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 From 96a8b28c535f54b6dd2b14cf2701d6089f61cbc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:41:37 +0200 Subject: [PATCH 19/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index e3e4d1ec..f9c75a7b 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1263,7 +1263,7 @@ cdef class Interface: cdef np.ndarray[int, ndim=1] _vertex_ids = np.ascontiguousarray(vertex_ids, dtype=np.int32) cdef np.ndarray[double, ndim=1] _gradientValues = np.ascontiguousarray(gradientValues.flatten(), dtype=np.double) - assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Vector data is not provided for all vertices in write_block_vector_data. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions() * self.get_dimensions()) + assert _gradientValues.size == size * self.get_dimensions() * self.get_dimensions(), "Dimension of vector gradient data provided in write_block_vector_gradient_data does not match problem definition. Check length of input data provided. Provided size: {}, expected size: {}".format(_gradientValues.size, size * self.get_dimensions() * self.get_dimensions()) assert _vertex_ids.size == size, "Vertex IDs are of incorrect length in write_block_vector_gradient_data. Check length of vertex ids input. Provided size: {}, expected size: {}".format(_vertex_ids.size, size) self.thisptr.writeBlockVectorGradientData (data_id, size, _vertex_ids.data, _gradientValues.data) From 0f5339b8f88fc01e86afe8e7f2cd6903f5b90f54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:41:52 +0200 Subject: [PATCH 20/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index f9c75a7b..3cbc979e 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1304,7 +1304,7 @@ cdef class Interface: Write scalar data for a 2D problem with 5 vertices: >>> data_id = 1 >>> vertex_id = 5 - >>> gradientValue = [v5_dx,v5_dy] + >>> gradientValue = [v5_dx, v5_dy] >>> interface.write_scalar_gradient_data(data_id, vertex_id, gradientValue) """ From 7668918c550bea4c6459d3569a414ec5a455f22c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:42:07 +0200 Subject: [PATCH 21/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 3cbc979e..ab3c456c 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1401,11 +1401,11 @@ cdef class Interface: >>> gradientValues = np.array([[v1_dx, v1_dy],[v2_dx, v2_dy]]) >>> interface.write_block_scalar_gradient_data(data_id, vertex_ids, gradientValues) - Write block vector data for a 3D (D=3) problem with 2 (N=2) vertices: + Write block scalar data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] >>> values = np.array([[v1_dx, v1_dy, v1x_dz], [v2_dx. v2_dy, v2_dz]]) - >>> interface.write_block_scalar_data(data_id, vertex_ids, values) + >>> interface.write_block_scalar_gradient_data(data_id, vertex_ids, values) """ check_array_like(vertex_ids, "vertex_ids", "write_block_scalar_gradient_data") check_array_like(gradientValues, "gradientValues", "write_block_sclar_gradient_data") From adcf87dedfe8ee08b83c963a5711167bf84f3ed5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:42:24 +0200 Subject: [PATCH 22/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index ab3c456c..4e413556 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1395,7 +1395,7 @@ cdef class Interface: Examples -------- - Write block gradient vector data for a 2D problem with 2 vertices: + Write block gradient scalar data for a 2D problem with 2 vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] >>> gradientValues = np.array([[v1_dx, v1_dy],[v2_dx, v2_dy]]) From 5e8626ec2e091aff7424daf7c7bc65d2cd50365d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:42:35 +0200 Subject: [PATCH 23/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 4e413556..22056228 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1398,7 +1398,7 @@ cdef class Interface: Write block gradient scalar data for a 2D problem with 2 vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] - >>> gradientValues = np.array([[v1_dx, v1_dy],[v2_dx, v2_dy]]) + >>> gradientValues = np.array([[v1_dx, v1_dy], [v2_dx, v2_dy]]) >>> interface.write_block_scalar_gradient_data(data_id, vertex_ids, gradientValues) Write block scalar data for a 3D (D=3) problem with 2 (N=2) vertices: From e810b15341dc5668ef8f27f4518d36f8ae3b2458 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:42:50 +0200 Subject: [PATCH 24/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 22056228..5693b8ae 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1352,7 +1352,7 @@ cdef class Interface: Examples -------- - Write scalar data for a 2D problem with 5 vertices: + Write scalar data for a 2D problem: >>> data_id = 1 >>> vertex_id = 5 >>> gradientValue = [v5x_dx, v5y_dx, v5x_dy,v5y_dy] From e250476d239dbbd370875d69a5ceb6083fcdaeec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 20:43:01 +0200 Subject: [PATCH 25/31] Update cyprecice/cyprecice.pyx Co-authored-by: Ishaan Desai --- cyprecice/cyprecice.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index 5693b8ae..b010ddfc 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1301,7 +1301,7 @@ cdef class Interface: Examples -------- - Write scalar data for a 2D problem with 5 vertices: + Write scalar data for a 2D problem: >>> data_id = 1 >>> vertex_id = 5 >>> gradientValue = [v5_dx, v5_dy] From dcf790fdd92e0f07463517ba0c9b38059e71a89a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?K=C3=BCr=C5=9Fat=20Yurt?= <57598663+kursatyurt@users.noreply.github.com> Date: Thu, 14 Jul 2022 22:53:48 +0200 Subject: [PATCH 26/31] Add asserttions to tests --- test/test_bindings_module.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index c6d532fa..188e2b40 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -420,17 +420,20 @@ def test_write_block_scalar_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([[1, 2, 3], [6, 7, 8], [9, 10, 11]]) solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_scalar_gradient_data_single_float(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [8.0, 9.0, 10.0] with self.assertRaises(TypeError): solver_interface.write_block_scalar_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_scalar_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([]) solver_interface.write_block_scalar_gradient_data(1, [], write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_scalar_data_non_contiguous(self): """ @@ -443,36 +446,43 @@ def test_write_block_scalar_data_non_contiguous(self): write_data = dummy_array[:, 3:6] assert write_data.flags["C_CONTIGUOUS"] is False solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_scalar_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [3, 4, 5] solver_interface.write_scalar_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_vector__gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([[3, 7, 8, 3, 4, 5, 6, 7, 8], [7, 6, 5, 1, 2, 3, 7, 6, 5]], dtype=np.double) solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_vector_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([]) solver_interface.write_block_vector_gradient_data(1, [], write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_vector_gradient_data_list(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [[3, 7, 8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7, 6, 5]] solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_vector_gradient_data_tuple(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = ((1, 2, 3, 4, 5, 6, 3, 7, 8), (1, 2, 3, 4, 5, 6, 7, 6, 5)) solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_read_write_block_vector_gradient_data_mixed(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [(1, 2, 3, 4, 5, 6, 3, 7, 8), (4, 5, 6, 7, 8, 9, 7, 6, 5)] solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_block_vector_gradient_data_non_contiguous(self): """ @@ -486,21 +496,25 @@ def test_write_block_vector_gradient_data_non_contiguous(self): assert write_data.flags["C_CONTIGUOUS"] is False vertex_ids = np.arange(3) solver_interface.write_block_vector_gradient_data(1, vertex_ids, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_vector_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.arange(0, 9, dtype=np.double) solver_interface.write_vector_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_vector_data_list(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [1, 2, 3, 4, 5, 6, 7, 8, 9] solver_interface.write_vector_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_vector_data_tuple(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = (1, 2, 3, 9, 8, 7, 6, 5, 4) solver_interface.write_vector_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) def test_write_vector_gradient_data_non_contiguous(self): """ @@ -513,3 +527,4 @@ def test_write_vector_gradient_data_non_contiguous(self): write_data = dummy_array[:, 1] assert write_data.flags["C_CONTIGUOUS"] is False solver_interface.write_vector_gradient_data(1, 1, write_data) + self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) From 23601795a2b0f7788c4011464e409cb7104224a6 Mon Sep 17 00:00:00 2001 From: Ishaan Desai Date: Fri, 15 Jul 2022 14:21:34 +0200 Subject: [PATCH 27/31] Minor fixes --- test/SolverInterface.cpp | 2 ++ test/test_bindings_module.py | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/test/SolverInterface.cpp b/test/SolverInterface.cpp index fcf7da4a..c06118af 100644 --- a/test/SolverInterface.cpp +++ b/test/SolverInterface.cpp @@ -39,6 +39,7 @@ SolverInterface:: SolverInterface std::iota(fake_bounding_box.begin(), fake_bounding_box.end(), 0); fake_coordinates.resize(n_fake_vertices*fake_dimensions); std::iota(fake_coordinates.begin(), fake_coordinates.end(), 0); + fake_gradient_buffer = std::vector(); } SolverInterface::SolverInterface( @@ -58,6 +59,7 @@ SolverInterface::SolverInterface( std::iota(fake_ids.begin(), fake_ids.end(), 0); fake_bounding_box.resize(fake_dimensions*2); std::iota(fake_bounding_box.begin(), fake_bounding_box.end(), 0); + fake_gradient_buffer = std::vector(); } SolverInterface::~SolverInterface() = default; diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index 188e2b40..ad72f9a3 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -454,7 +454,7 @@ def test_write_scalar_data(self): solver_interface.write_scalar_gradient_data(1, 1, write_data) self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) - def test_write_block_vector__gradient_data(self): + def test_write_block_vector_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([[3, 7, 8, 3, 4, 5, 6, 7, 8], [7, 6, 5, 1, 2, 3, 7, 6, 5]], dtype=np.double) solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) From 56643f7d11cf5b8e79c96fadc6488ecd31201f40 Mon Sep 17 00:00:00 2001 From: Kursat Date: Thu, 21 Jul 2022 12:09:16 +0200 Subject: [PATCH 28/31] Change gradient tests to read --- test/SolverInterface.cpp | 21 +++++------- test/test_bindings_module.py | 65 ++++++++++++++++++++++-------------- 2 files changed, 49 insertions(+), 37 deletions(-) diff --git a/test/SolverInterface.cpp b/test/SolverInterface.cpp index c06118af..08139a2f 100644 --- a/test/SolverInterface.cpp +++ b/test/SolverInterface.cpp @@ -4,7 +4,6 @@ #include std::vector fake_read_write_buffer; -std::vector fake_gradient_buffer; int fake_dimensions; int fake_mesh_id; std::vector fake_ids; @@ -39,7 +38,6 @@ SolverInterface:: SolverInterface std::iota(fake_bounding_box.begin(), fake_bounding_box.end(), 0); fake_coordinates.resize(n_fake_vertices*fake_dimensions); std::iota(fake_coordinates.begin(), fake_coordinates.end(), 0); - fake_gradient_buffer = std::vector(); } SolverInterface::SolverInterface( @@ -59,7 +57,6 @@ SolverInterface::SolverInterface( std::iota(fake_ids.begin(), fake_ids.end(), 0); fake_bounding_box.resize(fake_dimensions*2); std::iota(fake_bounding_box.begin(), fake_bounding_box.end(), 0); - fake_gradient_buffer = std::vector(); } SolverInterface::~SolverInterface() = default; @@ -409,9 +406,9 @@ void SolverInterface::writeBlockVectorGradientData( const int *valueIndices, const double *gradientValues) { - fake_gradient_buffer.clear(); + fake_read_write_buffer.clear(); for (int i = 0; i < size * this->getDimensions() * this->getDimensions(); i++) { - fake_gradient_buffer.push_back(gradientValues[i]); + fake_read_write_buffer.push_back(gradientValues[i]); } } @@ -420,9 +417,9 @@ void SolverInterface::writeScalarGradientData( int valueIndex, const double *gradientValues) { - fake_gradient_buffer.clear(); + fake_read_write_buffer.clear(); for (int i = 0; i < this->getDimensions(); i++) { - fake_gradient_buffer.push_back(gradientValues[i]); + fake_read_write_buffer.push_back(gradientValues[i]); } } void SolverInterface::writeBlockScalarGradientData( @@ -431,9 +428,9 @@ void SolverInterface::writeBlockScalarGradientData( const int *valueIndices, const double *gradientValues) { - fake_gradient_buffer.clear(); + fake_read_write_buffer.clear(); for (int i = 0; i < size * this->getDimensions(); i++) { - fake_gradient_buffer.push_back(gradientValues[i]); + fake_read_write_buffer.push_back(gradientValues[i]); } } @@ -442,9 +439,9 @@ void SolverInterface::writeVectorGradientData( int valueIndex, const double *gradientValues) { - fake_gradient_buffer.clear(); + fake_read_write_buffer.clear(); for (int i = 0; i < this->getDimensions() * this->getDimensions(); i++) { - fake_gradient_buffer.push_back(gradientValues[i]); + fake_read_write_buffer.push_back(gradientValues[i]); } } @@ -476,4 +473,4 @@ const std::string& actionReadIterationCheckpoint() } // namespace precice, constants -} // namespace precice +} // namespace precice \ No newline at end of file diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index ad72f9a3..8e2ec671 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -418,24 +418,27 @@ def test_is_gradient_data_required(self): def test_write_block_scalar_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = np.array([[1, 2, 3], [6, 7, 8], [9, 10, 11]]) + write_data = np.array([[1, 2, 3], [6, 7, 8], [9, 10, 11]], dtype=np.double) solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_block_scalar_gradient_data_single_float(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [8.0, 9.0, 10.0] with self.assertRaises(TypeError): solver_interface.write_block_scalar_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + with self.assertRaises(TypeError): + solver_interface.read_block_scalar_data(1, np.array(range(3))) def test_write_block_scalar_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([]) solver_interface.write_block_scalar_gradient_data(1, [], write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, []) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) - def test_write_block_scalar_data_non_contiguous(self): + def test_write_block_scalar_gradient_data_non_contiguous(self): """ Tests behaviour of solver interface, if a non contiguous array is passed to the interface. @@ -446,43 +449,50 @@ def test_write_block_scalar_data_non_contiguous(self): write_data = dummy_array[:, 3:6] assert write_data.flags["C_CONTIGUOUS"] is False solver_interface.write_block_scalar_gradient_data(1, np.array([1, 2, 3]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) - def test_write_scalar_data(self): + def test_write_scalar_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [3, 4, 5] + write_data = [3.0, 4.0, 5.0] solver_interface.write_scalar_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(3))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_block_vector_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([[3, 7, 8, 3, 4, 5, 6, 7, 8], [7, 6, 5, 1, 2, 3, 7, 6, 5]], dtype=np.double) solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_block_vector_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.array([]) solver_interface.write_block_vector_gradient_data(1, [], write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, []) + self.assertTrue(len(read_data) == 0) def test_write_block_vector_gradient_data_list(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [[3, 7, 8, 9, 10, 11, 12, 13, 14], [1, 2, 3, 4, 5, 6, 7, 6, 5]] + write_data = [[3.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0]] solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_block_vector_gradient_data_tuple(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = ((1, 2, 3, 4, 5, 6, 3, 7, 8), (1, 2, 3, 4, 5, 6, 7, 6, 5)) + write_data = ((1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 3.0, 7.0, 8.0), (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0)) solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_read_write_block_vector_gradient_data_mixed(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [(1, 2, 3, 4, 5, 6, 3, 7, 8), (4, 5, 6, 7, 8, 9, 7, 6, 5)] + write_data = [(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 3.0, 7.0, 8.0), (4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 7.0, 6.0, 5.0)] solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_block_vector_gradient_data_non_contiguous(self): """ @@ -496,25 +506,29 @@ def test_write_block_vector_gradient_data_non_contiguous(self): assert write_data.flags["C_CONTIGUOUS"] is False vertex_ids = np.arange(3) solver_interface.write_block_vector_gradient_data(1, vertex_ids, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(27))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_vector_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = np.arange(0, 9, dtype=np.double) solver_interface.write_vector_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_vector_data_list(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [1, 2, 3, 4, 5, 6, 7, 8, 9] + write_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] solver_interface.write_vector_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) - def test_write_vector_data_tuple(self): + def test_write_vector_gradient_data_tuple(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = (1, 2, 3, 9, 8, 7, 6, 5, 4) + write_data = (1.0, 2.0, 3.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0) solver_interface.write_vector_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) def test_write_vector_gradient_data_non_contiguous(self): """ @@ -527,4 +541,5 @@ def test_write_vector_gradient_data_non_contiguous(self): write_data = dummy_array[:, 1] assert write_data.flags["C_CONTIGUOUS"] is False solver_interface.write_vector_gradient_data(1, 1, write_data) - self.assertTrue(np.array_equal(write_data, solver_interface.fake_gradient_buffer)) + read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) + self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) From 1a4e20f8e80a7fb5bed30c3d2754c57a1e2300b7 Mon Sep 17 00:00:00 2001 From: Kursat Date: Thu, 21 Jul 2022 12:15:15 +0200 Subject: [PATCH 29/31] Typo fixes --- test/test_bindings_module.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index 8e2ec671..3b60c724 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -487,7 +487,7 @@ def test_write_block_vector_gradient_data_tuple(self): read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) - def test_read_write_block_vector_gradient_data_mixed(self): + def test_write_block_vector_gradient_data_mixed(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 3.0, 7.0, 8.0), (4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 7.0, 6.0, 5.0)] solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) @@ -516,7 +516,7 @@ def test_write_vector_gradient_data(self): read_data = solver_interface.read_block_scalar_data(1, np.array(range(9))) self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) - def test_write_vector_data_list(self): + def test_write_vector_gradient_data_list(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) write_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0] solver_interface.write_vector_gradient_data(1, 1, write_data) From 37e3f9a8ef6ee886b7e46991ab8ab84b4fc4d138 Mon Sep 17 00:00:00 2001 From: Ishaan Desai Date: Thu, 21 Jul 2022 13:22:09 +0200 Subject: [PATCH 30/31] Fixing test_write_block_scalar_gradient_data_single_float --- cyprecice/cyprecice.pyx | 2 +- test/test_bindings_module.py | 12 +++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/cyprecice/cyprecice.pyx b/cyprecice/cyprecice.pyx index b010ddfc..823dc27f 100644 --- a/cyprecice/cyprecice.pyx +++ b/cyprecice/cyprecice.pyx @@ -1404,7 +1404,7 @@ cdef class Interface: Write block scalar data for a 3D (D=3) problem with 2 (N=2) vertices: >>> data_id = 1 >>> vertex_ids = [1, 2] - >>> values = np.array([[v1_dx, v1_dy, v1x_dz], [v2_dx. v2_dy, v2_dz]]) + >>> values = np.array([[v1_dx, v1_dy, v1x_dz], [v2_dx, v2_dy, v2_dz]]) >>> interface.write_block_scalar_gradient_data(data_id, vertex_ids, values) """ check_array_like(vertex_ids, "vertex_ids", "write_block_scalar_gradient_data") diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index 3b60c724..757395de 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -425,11 +425,13 @@ def test_write_block_scalar_gradient_data(self): def test_write_block_scalar_gradient_data_single_float(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [8.0, 9.0, 10.0] - with self.assertRaises(TypeError): - solver_interface.write_block_scalar_gradient_data(1, 1, write_data) - with self.assertRaises(TypeError): - solver_interface.read_block_scalar_data(1, np.array(range(3))) + fake_dimension = 3 + n_fake_vertices = 3 + vertex_ids = np.arange(n_fake_vertices) + write_data = np.random.rand(fake_dimension, fake_dimension) + solver_interface.write_block_scalar_gradient_data(1, vertex_ids, write_data) + read_data = solver_interface.read_block_vector_data(1, vertex_ids) + self.assertTrue(np.array_equal(write_data, read_data)) def test_write_block_scalar_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) From 66e9339e0e1f1bbc22559358236b6cf3111d2511 Mon Sep 17 00:00:00 2001 From: Ishaan Desai Date: Thu, 21 Jul 2022 14:46:20 +0200 Subject: [PATCH 31/31] Further smoothing the gradient data tests --- test/test_bindings_module.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/test/test_bindings_module.py b/test/test_bindings_module.py index 757395de..e20094b6 100644 --- a/test/test_bindings_module.py +++ b/test/test_bindings_module.py @@ -426,9 +426,9 @@ def test_write_block_scalar_gradient_data(self): def test_write_block_scalar_gradient_data_single_float(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) fake_dimension = 3 - n_fake_vertices = 3 + n_fake_vertices = 4 vertex_ids = np.arange(n_fake_vertices) - write_data = np.random.rand(fake_dimension, fake_dimension) + write_data = np.random.rand(n_fake_vertices, fake_dimension) solver_interface.write_block_scalar_gradient_data(1, vertex_ids, write_data) read_data = solver_interface.read_block_vector_data(1, vertex_ids) self.assertTrue(np.array_equal(write_data, read_data)) @@ -456,17 +456,21 @@ def test_write_block_scalar_gradient_data_non_contiguous(self): def test_write_scalar_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = [3.0, 4.0, 5.0] + fake_dimension = 3 + write_data = np.random.rand(fake_dimension) solver_interface.write_scalar_gradient_data(1, 1, write_data) - read_data = solver_interface.read_block_scalar_data(1, np.array(range(3))) - self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) + read_data = solver_interface.read_vector_data(1, 1) + self.assertTrue(np.array_equiv(write_data, read_data)) def test_write_block_vector_gradient_data(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1) - write_data = np.array([[3, 7, 8, 3, 4, 5, 6, 7, 8], [7, 6, 5, 1, 2, 3, 7, 6, 5]], dtype=np.double) - solver_interface.write_block_vector_gradient_data(1, np.array([1, 2]), write_data) - read_data = solver_interface.read_block_scalar_data(1, np.array(range(18))) - self.assertTrue(np.array_equiv(np.array(write_data).flatten(), read_data.flatten())) + fake_dimension = 3 + n_fake_vertices = 4 + vertex_ids = np.arange(n_fake_vertices) + write_data = np.random.rand(n_fake_vertices, fake_dimension * fake_dimension) + solver_interface.write_block_vector_gradient_data(1, vertex_ids, write_data) + read_data = solver_interface.read_block_vector_data(1, np.array(range(n_fake_vertices * fake_dimension))) + self.assertTrue(np.array_equiv(write_data.flatten(), read_data.flatten())) def test_write_block_vector_gradient_data_empty(self): solver_interface = precice.Interface("test", "dummy.xml", 0, 1)