commit 01d8fbd7fcdfa2537c6a2bfecb74ab3335c1ebb7
parent caf09eacf828b7737354d072c266ce914d04b9ba
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Thu, 21 Feb 2019 14:25:09 +0100
Test the green function accessors
Diffstat:
19 files changed, 333 insertions(+), 21 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -41,6 +41,14 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${RCMAKE_SOURCE_DIR})
include(rcmake)
include(rcmake_runtime)
+include_directories(
+ ${Star2D_INCLUDE_DIR}
+ ${Star3D_INCLUDE_DIR}
+ ${StarSP_INCLUDE_DIR}
+ ${StarEnc_INCLUDE_DIR}
+ ${StarEnc2D_INCLUDE_DIR}
+ ${RSys_INCLUDE_DIR})
+
rcmake_append_runtime_dirs(_runtime_dirs RSys Star3D StarSP StarEnc StarEnc2D)
################################################################################
@@ -136,9 +144,13 @@ rcmake_setup_devel(sdis Stardis ${VERSION} sdis_version.h)
if(NOT NO_TEST)
find_package(Star3DUT REQUIRED 0.2.0)
+ add_library(sdis-test-utils STATIC
+ ${SDIS_SOURCE_DIR}/test_sdis_utils.h
+ ${SDIS_SOURCE_DIR}/test_sdis_utils.c)
+
function(build_test _name)
add_executable(${_name} ${SDIS_SOURCE_DIR}/${_name}.c)
- target_link_libraries(${_name} RSys sdis)
+ target_link_libraries(${_name} sdis-test-utils RSys sdis)
endfunction()
function(register_test _name)
diff --git a/src/sdis.h b/src/sdis.h
@@ -88,6 +88,13 @@ enum sdis_scene_dimension {
SDIS_SCENE_3D
};
+enum sdis_point_type {
+ SDIS_FRAGMENT,
+ SDIS_VERTEX,
+ SDIS_POINT_TYPES_COUNT__,
+ SDIS_POINT_NONE = SDIS_POINT_TYPES_COUNT__
+};
+
/* Random walk vertex, i.e. a spatiotemporal position at a given step of the
* random walk. */
struct sdis_rwalk_vertex {
@@ -236,25 +243,18 @@ typedef res_T
const size_t naccums[2], /* #accumulations in X and Y */
const struct sdis_accum* accums); /* List of row ordered accumulations */
-enum sdis_point_type {
- SDIS_FRAGMENT,
- SDIS_VERTEX,
- SDIS_POINT_TYPES_COUNT__,
- SDIS_POINT_NONE = SDIS_POINT_TYPES_COUNT__
-};
-
struct sdis_green_path {
- /* Internal data. Should not be accessed */
+ /* Internal data. Should not be accessed */
void* green__;
size_t id__;
};
#define SDIS_GREEN_PATH_NULL__ {NULL, 0}
-static const struct sdis_green_path SDIS_GREEN_PATH_NULL =
+static const struct sdis_green_path SDIS_GREEN_PATH_NULL =
SDIS_GREEN_PATH_NULL__;
struct sdis_point {
union {
- struct {
+ struct {
struct sdis_medium* medium;
struct sdis_rwalk_vertex vertex;
} mdmvert;
@@ -265,21 +265,25 @@ struct sdis_point {
} data;
enum sdis_point_type type;
};
-#define SDIS_POINT_NULL__ {{{NULL, SDIS_RWALK_VERTEX_NULL__}}, SDIS_POINT_NONE}
+#define SDIS_POINT_NULL__ { {{NULL, SDIS_RWALK_VERTEX_NULL__}}, SDIS_POINT_NONE}
static const struct sdis_point SDIS_POINT_NULL = SDIS_POINT_NULL__;
-/* Functor use to process the limit points of the green function */
+/* Functor used to process the paths registered agains the green function */
typedef res_T
(*sdis_process_green_path_T)
- (const struct sdis_green_path* path,
+ (struct sdis_green_path* path,
void* context);
+/* Functor used to process the power factor registered along a green path for a
+ * given medium */
typedef res_T
(*sdis_process_medium_power_term_T)
(struct sdis_medium* medium,
const double power_term,
void* context);
+/* Functor used to process the flux factor registered along a green path for a
+ * given interface side */
typedef res_T
(*sdis_process_interface_flux_term_T)
(struct sdis_interface* interf,
@@ -673,23 +677,48 @@ sdis_green_function_solve
const double time_range[2], /* Observation time */
struct sdis_estimator** estimator);
+/* Retrieve the number of valid paths used to estimate the green function. It
+ * is actually equal to the number of successful realisations. */
+SDIS_API res_T
+sdis_green_function_get_paths_count
+ (const struct sdis_green_function* green,
+ size_t* npaths);
+
+/* Retrieve the number of rejected paths during the estimation of the green
+ * function due to numerical issues and data inconsistency */
+SDIS_API res_T
+sdis_green_function_get_invalid_paths_count
+ (const struct sdis_green_function* green,
+ size_t* nfails);
+
+/* Iterate over all valid green function paths */
SDIS_API res_T
sdis_green_function_for_each_path
(struct sdis_green_function* green,
sdis_process_green_path_T func,
void* context);
+/* Retrieve the spatio-temporal end point of a path used to estimate the green
+ * function. Note that this point went back in time from the relative
+ * observation time 0. Its time is thus negative ; its absolute value
+ * represents the time spent by the path into the system. */
SDIS_API res_T
sdis_green_path_get_limit_point
(struct sdis_green_path* path,
struct sdis_point* pt);
+/* Iterate over all "power terms" associated to the path. Multiply each term
+ * by the power of their associated medium, that is assumed to be constant in
+ * time and space, gives the medium power registered along the path. */
SDIS_API res_T
sdis_green_path_for_each_power_term
(struct sdis_green_path* path,
sdis_process_medium_power_term_T func,
void* context);
+/* Iterate over all "flux terms" associated to the path. Multiply each term by
+ * the flux of their associated interface side, that is assumed to be constant
+ * in time and space, gives the interface side flux registered along the path. */
SDIS_API res_T
sdis_green_path_for_each_flux_term
(struct sdis_green_path* path,
@@ -788,11 +817,11 @@ sdis_solve_camera
* media must be constant in time and space too. Furthermore, note that only
* the interfaces/media that had a flux/volumic power during green estimation
* can update their flux/volumic power value for subsequent
- * sdis_green_function_solve invokations : other interfaces/media are
+ * sdis_green_function_solve invocations : other interfaces/media are
* definitely registered against the green function as interfaces/media with no
* flux/volumic power.
*
- * If the aforementionned assumptions are not ensured by the caller, the
+ * If the aforementioned assumptions are not ensured by the caller, the
* behavior of the estimated green function is undefined.
******************************************************************************/
SDIS_API res_T
diff --git a/src/sdis_green.c b/src/sdis_green.c
@@ -188,6 +188,9 @@ struct sdis_green_function {
struct htable_interf interfaces;
struct darray_green_path paths; /* List of paths used to estimate the green */
+ size_t npaths_valid;
+ size_t npaths_invalid;
+
ref_T ref;
struct sdis_device* dev;
};
@@ -491,6 +494,26 @@ error:
}
res_T
+sdis_green_function_get_paths_count
+ (const struct sdis_green_function* green, size_t* npaths)
+{
+ if(!green || !npaths) return RES_BAD_ARG;
+ ASSERT(green->npaths_valid != SIZE_MAX);
+ *npaths = green->npaths_valid;
+ return RES_OK;
+}
+
+res_T
+sdis_green_function_get_invalid_paths_count
+ (const struct sdis_green_function* green, size_t* nfails)
+{
+ if(!green || !nfails) return RES_BAD_ARG;
+ ASSERT(green->npaths_invalid != SIZE_MAX);
+ *nfails = green->npaths_invalid;
+ return RES_OK;
+}
+
+res_T
sdis_green_function_for_each_path
(struct sdis_green_function* green,
sdis_process_green_path_T func,
@@ -574,7 +597,7 @@ sdis_green_path_for_each_power_term
size_t i, n;
res_T res = RES_OK;
- if(path_handle || !func) {
+ if(!path_handle || !func) {
res = RES_BAD_ARG;
goto error;
}
@@ -611,7 +634,7 @@ sdis_green_path_for_each_flux_term
size_t i, n;
res_T res = RES_OK;
- if(path_handle || !func) {
+ if(!path_handle || !func) {
res = RES_BAD_ARG;
goto error;
}
@@ -659,6 +682,8 @@ green_function_create
htable_medium_init(dev->allocator, &green->media);
htable_interf_init(dev->allocator, &green->interfaces);
darray_green_path_init(dev->allocator, &green->paths);
+ green->npaths_valid = SIZE_MAX;
+ green->npaths_invalid = SIZE_MAX;
exit:
*out_green = green;
@@ -734,6 +759,23 @@ error:
}
res_T
+green_function_finalize(struct sdis_green_function* green)
+{
+ size_t i, n;
+
+ if(!green) return RES_BAD_ARG;
+
+ green->npaths_valid = 0;
+ n = darray_green_path_size_get(&green->paths);
+ FOR_EACH(i, 0, n) {
+ const struct green_path* path = darray_green_path_cdata_get(&green->paths)+i;
+ green->npaths_valid += path->limit_type != SDIS_POINT_NONE;
+ }
+ green->npaths_invalid = n - green->npaths_valid;
+ return RES_OK;
+}
+
+res_T
green_function_create_path
(struct sdis_green_function* green,
struct green_path_handle* handle)
@@ -902,3 +944,4 @@ error:
goto exit;
}
+
diff --git a/src/sdis_green.h b/src/sdis_green.h
@@ -41,6 +41,11 @@ green_function_merge_and_clear
(struct sdis_green_function* dst,
struct sdis_green_function* src);
+/* Finalize the green function state (e.g.: computes the #paths & #failures) */
+extern LOCAL_SYM res_T
+green_function_finalize
+ (struct sdis_green_function* green);
+
extern LOCAL_SYM res_T
green_function_create_path
(struct sdis_green_function* green,
diff --git a/src/sdis_solve_Xd.h b/src/sdis_solve_Xd.h
@@ -190,7 +190,7 @@ XD(solve_probe)
goto error;
}
}
-
+
#if SDIS_XD_DIMENSION == 2
if(scene_is_2d(scn) == 0) { res = RES_BAD_ARG; goto error; }
#else
@@ -280,6 +280,10 @@ XD(solve_probe)
res = green_function_merge_and_clear(green, greens[i]);
if(res != RES_OK) goto error;
}
+
+ /* Finalize the estimated green */
+ res = green_function_finalize(green);
+ if(res != RES_OK) goto error;
}
exit:
diff --git a/src/test_sdis_conducto_radiative.c b/src/test_sdis_conducto_radiative.c
@@ -416,6 +416,7 @@ main(int argc, char** argv)
/* Check green function */
OK(sdis_solve_probe_green_function(scn, N, pos, 1, -1, Tref, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator));
diff --git a/src/test_sdis_conducto_radiative_2d.c b/src/test_sdis_conducto_radiative_2d.c
@@ -421,6 +421,7 @@ main(int argc, char** argv)
/* Check green function */
OK(sdis_solve_probe_green_function(scn, 10000, pos, 1, -1, Tref, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator));
diff --git a/src/test_sdis_convection.c b/src/test_sdis_convection.c
@@ -290,6 +290,7 @@ main(int argc, char** argv)
if(IS_INF(time)) { /* Check green function */
OK(sdis_solve_probe_green_function(box_scn, N, pos, 1.0, 0, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
@@ -325,6 +326,7 @@ main(int argc, char** argv)
if(IS_INF(time)) { /* Check green function */
OK(sdis_solve_probe_green_function(square_scn, N, pos, 1.0, 0, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
diff --git a/src/test_sdis_convection_non_uniform.c b/src/test_sdis_convection_non_uniform.c
@@ -306,6 +306,7 @@ main(int argc, char** argv)
if(IS_INF(time)) { /* Check green function */
OK(sdis_solve_probe_green_function(box_scn, N, pos, 1.0, 0, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
@@ -339,6 +340,7 @@ main(int argc, char** argv)
if(IS_INF(time)) { /* Check green function */
OK(sdis_solve_probe_green_function(square_scn, N, pos, 1.0, 0, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
diff --git a/src/test_sdis_flux.c b/src/test_sdis_flux.c
@@ -200,13 +200,16 @@ solve(struct sdis_scene* scn, const double pos[])
printf("Green estimation time = %s\n", dump);
time_sub(&t1, &t2, &t1);
time_dump(&t1, TIME_ALL, NULL, dump, sizeof(dump));
- printf("Green solve time = %s\n\n", dump);
+ printf("Green solve time = %s\n", dump);
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator));
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
+
+ printf("\n");
}
/*******************************************************************************
diff --git a/src/test_sdis_solve_probe.c b/src/test_sdis_solve_probe.c
@@ -336,6 +336,7 @@ main(int argc, char** argv)
BA(sdis_green_function_solve(green, time_range, NULL));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
BA(sdis_green_function_ref_get(NULL));
diff --git a/src/test_sdis_solve_probe2.c b/src/test_sdis_solve_probe2.c
@@ -261,6 +261,7 @@ main(int argc, char** argv)
/* Check green */
OK(sdis_solve_probe_green_function(scn, N, pos, 1, -1, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
/* Release data */
diff --git a/src/test_sdis_solve_probe2_2d.c b/src/test_sdis_solve_probe2_2d.c
@@ -259,6 +259,7 @@ main(int argc, char** argv)
/* Check green function */
OK(sdis_solve_probe_green_function(scn, N, pos, 1.0, -1, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
/* Release data */
diff --git a/src/test_sdis_solve_probe3.c b/src/test_sdis_solve_probe3.c
@@ -317,6 +317,7 @@ main(int argc, char** argv)
/* Check green function */
OK(sdis_solve_probe_green_function(scn, N, pos, 1.0, -1, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
/* Release data */
diff --git a/src/test_sdis_solve_probe3_2d.c b/src/test_sdis_solve_probe3_2d.c
@@ -310,6 +310,7 @@ main(int argc, char** argv)
/* Check green function */
OK(sdis_solve_probe_green_function(scn, N, pos, 1.0, -1, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
/* Release data */
diff --git a/src/test_sdis_solve_probe_2d.c b/src/test_sdis_solve_probe_2d.c
@@ -218,6 +218,7 @@ main(int argc, char** argv)
OK(sdis_solve_probe_green_function(scn, N, pos, 1.0, 0, 0, &green));
OK(sdis_green_function_solve(green, time_range, &estimator2));
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator));
diff --git a/src/test_sdis_utils.c b/src/test_sdis_utils.c
@@ -0,0 +1,197 @@
+/* Copyright (C) 2016-2019 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "test_sdis_utils.h"
+#include <rsys/math.h>
+
+/*******************************************************************************
+ * Helper functions
+ ******************************************************************************/
+struct green_accum { double sum, sum2; };
+
+static res_T
+count_green_paths(struct sdis_green_path* path, void* ctx)
+{
+ CHK(path && ctx);
+ *((size_t*)ctx) += 1;
+ return RES_OK;
+}
+
+static res_T
+accum_power_terms(struct sdis_medium* mdm, const double power_term, void* ctx)
+{
+ struct sdis_solid_shader shader = SDIS_SOLID_SHADER_NULL;
+ struct sdis_rwalk_vertex vtx = SDIS_RWALK_VERTEX_NULL;
+ struct sdis_data* data = NULL;
+ double* power = ctx;
+
+ CHK(mdm && ctx);
+ CHK(sdis_medium_get_type(mdm) == SDIS_SOLID);
+
+ OK(sdis_solid_get_shader(mdm, &shader));
+ data = sdis_medium_get_data(mdm);
+ vtx.time = INF;
+
+ *power += power_term * shader.volumic_power(&vtx, data);
+ return RES_OK;
+}
+
+static res_T
+accum_flux_terms
+ (struct sdis_interface* interf,
+ const enum sdis_side side,
+ const double flux_term,
+ void* ctx)
+{
+ struct sdis_interface_shader shader = SDIS_INTERFACE_SHADER_NULL;
+ struct sdis_interface_fragment frag = SDIS_INTERFACE_FRAGMENT_NULL;
+ struct sdis_data* data = NULL;
+ double* flux = ctx;
+ double phi;
+
+ CHK(interf && ctx);
+
+ OK(sdis_interface_get_shader(interf, &shader));
+ data = sdis_interface_get_data(interf);
+ frag.time = INF;
+ frag.side = side;
+
+ phi = side == SDIS_FRONT
+ ? shader.front.flux(&frag, data)
+ : shader.back.flux(&frag, data);
+
+ *flux += flux_term * phi;
+ return RES_OK;
+}
+
+static res_T
+solve_green_path(struct sdis_green_path* path, void* ctx)
+{
+ struct sdis_point pt = SDIS_POINT_NULL;
+ struct sdis_rwalk_vertex vtx = SDIS_RWALK_VERTEX_NULL;
+ struct sdis_interface_fragment frag = SDIS_INTERFACE_FRAGMENT_NULL;
+ struct sdis_solid_shader solid = SDIS_SOLID_SHADER_NULL;
+ struct sdis_fluid_shader fluid = SDIS_FLUID_SHADER_NULL;
+ struct sdis_interface_shader interf = SDIS_INTERFACE_SHADER_NULL;
+ struct green_accum* acc = NULL;
+ struct sdis_data* data = NULL;
+ enum sdis_medium_type type;
+ double power = 0;
+ double flux = 0;
+ double temp = 0;
+ double weight = 0;
+ CHK(path && ctx);
+
+ acc = ctx;
+
+ BA(sdis_green_path_for_each_power_term(NULL, accum_power_terms, &power));
+ BA(sdis_green_path_for_each_power_term(path, NULL, &acc));
+ OK(sdis_green_path_for_each_power_term(path, accum_power_terms, &power));
+
+ BA(sdis_green_path_for_each_flux_term(NULL, accum_flux_terms, &flux));
+ BA(sdis_green_path_for_each_flux_term(path, NULL, &acc));
+ OK(sdis_green_path_for_each_flux_term(path, accum_flux_terms, &flux));
+
+ BA(sdis_green_path_get_limit_point(NULL, &pt));
+ BA(sdis_green_path_get_limit_point(path, NULL));
+ OK(sdis_green_path_get_limit_point(path, &pt));
+
+ switch(pt.type) {
+ case SDIS_FRAGMENT:
+ frag = pt.data.itfrag.fragment;
+ frag.time = INF;
+ OK(sdis_interface_get_shader(pt.data.itfrag.interface, &interf));
+ data = sdis_interface_get_data(pt.data.itfrag.interface);
+ temp = frag.side == SDIS_FRONT
+ ? interf.front.temperature(&frag, data)
+ : interf.back.temperature(&frag, data);
+ break;
+ case SDIS_VERTEX:
+ vtx = pt.data.mdmvert.vertex;
+ vtx.time = INF;
+ type = sdis_medium_get_type(pt.data.mdmvert.medium);
+ data = sdis_medium_get_data(pt.data.mdmvert.medium);
+ if(type == SDIS_FLUID) {
+ OK(sdis_fluid_get_shader(pt.data.mdmvert.medium, &fluid));
+ temp = fluid.temperature(&vtx, data);
+ } else {
+ OK(sdis_solid_get_shader(pt.data.mdmvert.medium, &solid));
+ temp = solid.temperature(&vtx, data);
+ }
+ break;
+ default: FATAL("Unreachable code.\n"); break;
+ }
+
+ weight = temp + power + flux;
+ acc->sum += weight;
+ acc->sum2 += weight*weight;
+
+ return RES_OK;
+}
+
+/*******************************************************************************
+ * Local function
+ ******************************************************************************/
+void
+check_green_function(struct sdis_green_function* green)
+{
+ double time_range[2];
+ struct sdis_estimator* estimator;
+ struct sdis_mc mc;
+ struct green_accum accum = {0, 0};
+ double E, V, SE;
+ size_t nreals;
+ size_t nfails;
+ size_t n;
+
+ time_range[0] = time_range[1] = INF;
+
+ OK(sdis_green_function_solve(green, time_range, &estimator));
+
+ BA(sdis_green_function_get_paths_count(NULL, &n));
+ BA(sdis_green_function_get_paths_count(green, NULL));
+ OK(sdis_green_function_get_paths_count(green, &n));
+ OK(sdis_estimator_get_realisation_count(estimator, &nreals));
+ CHK(n == nreals);
+
+ BA(sdis_green_function_get_invalid_paths_count(NULL, &n));
+ BA(sdis_green_function_get_invalid_paths_count(green, NULL));
+ OK(sdis_green_function_get_invalid_paths_count(green, &n));
+ OK(sdis_estimator_get_failure_count(estimator, &nfails));
+ CHK(n == nfails);
+
+ n = 0;
+ BA(sdis_green_function_for_each_path(NULL, count_green_paths, &n));
+ BA(sdis_green_function_for_each_path(green, NULL, &n));
+ OK(sdis_green_function_for_each_path(green, count_green_paths, &n));
+ CHK(n == nreals);
+
+ OK(sdis_green_function_for_each_path(green, solve_green_path, &accum));
+
+ E = accum.sum / (double)n;
+ V = MMAX(0, accum.sum2 / (double)n - E*E);
+ SE = sqrt(V/(double)n);
+ OK(sdis_estimator_get_temperature(estimator, &mc));
+
+ printf("Green: rebuild = %g +/- %g; solved = %g +/- %g\n",
+ E, SE, mc.E, mc.SE);
+
+ CHK(E + SE >= mc.E - mc.SE);
+ CHK(E - SE <= mc.E + mc.SE);
+
+ OK(sdis_estimator_ref_put(estimator));
+}
+
+
diff --git a/src/test_sdis_utils.h b/src/test_sdis_utils.h
@@ -285,5 +285,9 @@ check_memory_allocator(struct mem_allocator* allocator)
}
}
+extern LOCAL_SYM void
+check_green_function
+ (struct sdis_green_function* green);
+
#endif /* TEST_SDIS_UTILS_H */
diff --git a/src/test_sdis_volumic_power.c b/src/test_sdis_volumic_power.c
@@ -224,13 +224,16 @@ solve(struct sdis_scene* scn, const double pos[])
printf("Green estimation time = %s\n", dump);
time_sub(&t1, &t2, &t1);
time_dump(&t1, TIME_ALL, NULL, dump, sizeof(dump));
- printf("Green solve time = %s\n\n", dump);
+ printf("Green solve time = %s\n", dump);
+ check_green_function(green);
check_estimator_eq(estimator, estimator2);
OK(sdis_estimator_ref_put(estimator));
OK(sdis_estimator_ref_put(estimator2));
OK(sdis_green_function_ref_put(green));
+
+ printf("\n");
}
/*******************************************************************************
