commit fdc28a9f8151aea0a98ffc6d753c5297878bd90e
parent f577a0eb98ec3c3f59f7470e948bcbbc7c6c2125
Author: Christophe Coustet <christophe.coustet@meso-star.com>
Date: Thu, 7 Sep 2017 18:08:56 +0200
Remove dead code.
Solver's binary output was mostly useless (incomplete).
The only code using it was test code, that has been adapted.
Diffstat:
16 files changed, 67 insertions(+), 255 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -133,7 +133,7 @@ if(NOT NO_TEST)
function(build_test _name)
add_executable(${_name} ${SSOL_SOURCE_DIR}/${_name}.c)
target_link_libraries(${_name}
- solstice-solver solstice-test RSys Star3D StarSP)
+ solstice-solver RSys Star3D StarSP)
endfunction()
function(register_test _name)
@@ -145,13 +145,7 @@ if(NOT NO_TEST)
build_test(${_name})
register_test(${_name} ${_name})
endfunction()
-
- add_library(solstice-test STATIC
- ${SSOL_SOURCE_DIR}/test_ssol_geometries.h
- ${SSOL_SOURCE_DIR}/test_ssol_materials.h
- ${SSOL_SOURCE_DIR}/test_ssol_utils.h
- ${SSOL_SOURCE_DIR}/test_ssol_utils.c)
-
+
new_test(test_ssol_atmosphere)
new_test(test_ssol_by_receiver_integration)
new_test(test_ssol_camera)
diff --git a/src/ssol.h b/src/ssol.h
@@ -1202,7 +1202,6 @@ ssol_solve
struct ssp_rng* rng,
const size_t realisations_count,
const struct ssol_path_tracker* tracker, /* NULL<=>Do not record the paths */
- FILE* output, /* May be NULL <=> does not ouput ssol_receiver_data */
struct ssol_estimator** estimator);
SSOL_API res_T
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -514,31 +514,6 @@ point_get_id(const struct point* pt)
return pt->side == SSOL_FRONT ? (int32_t)inst_id : -(int32_t)inst_id;
}
-static FINLINE res_T
-point_dump
- (const struct point* pt,
- const size_t irealisation,
- const size_t isegment,
- FILE* stream)
-{
- struct ssol_receiver_data out;
- size_t n;
-
- if(!stream) return RES_OK;
-
- out.realization_id = irealisation;
- out.segment_id = (uint32_t)isegment;
- out.receiver_id = point_get_id(pt);
- out.wavelength = (float)pt->wl;
- f3_set_d3(out.pos, pt->pos);
- f3_set_d3(out.in_dir, pt->dir);
- f3_set_d3(out.normal, pt->N);
- f2_set(out.uv, pt->uv);
- out.weight = pt->outgoing_flux;
- n = fwrite(&out, sizeof(out), 1, stream);
- return n != 1 ? RES_IO_ERR : RES_OK;
-}
-
/*******************************************************************************
* Helper functions
******************************************************************************/
@@ -699,18 +674,13 @@ static res_T
update_mc
(struct point* pt,
const size_t irealisation,
- const size_t ibounce,
- struct thread_context* thread_ctx,
- FILE* output)
+ struct thread_context* thread_ctx)
{
struct mc_receiver_1side* mc_rcv1 = NULL;
struct mc_receiver_1side* mc_samp_x_rcv1 = NULL;
res_T res = RES_OK;
ASSERT(pt && thread_ctx && point_is_receiver(pt));
- res = point_dump(pt, irealisation, ibounce, output);
- if(res != RES_OK) goto error;
-
pt->partial_recv += pt->incoming_flux - pt->outgoing_flux;
/* Per receiver MC accumulation */
@@ -784,8 +754,7 @@ trace_radiative_path
struct s3d_scene_view* view_rt,
struct ranst_sun_dir* ran_sun_dir,
struct ranst_sun_wl* ran_sun_wl,
- const struct ssol_path_tracker* tracker, /* May be NULL */
- FILE* output) /* May be NULL */
+ const struct ssol_path_tracker* tracker) /* May be NULL */
{
struct path path;
struct ssol_medium in_medium = SSOL_MEDIUM_VACUUM;
@@ -872,7 +841,7 @@ trace_radiative_path
/* If receiver update MC results */
if(hit_receiver) {
hit_a_receiver = 1;
- res = update_mc(&pt, irealisation, depth, thread_ctx, output);
+ res = update_mc(&pt, irealisation, thread_ctx);
if(res != RES_OK) goto error;
} else {
pt.partial_other += pt.incoming_flux * pt.kabs_at_pt;
@@ -993,7 +962,6 @@ ssol_solve
struct ssp_rng* rng_state,
const size_t realisations_count,
const struct ssol_path_tracker* path_tracker,
- FILE* output,
struct ssol_estimator** out_estimator)
{
struct htable_receiver_iterator r_it, r_end;
@@ -1094,7 +1062,7 @@ ssol_solve
/* Execute a MC experiment */
res_local = trace_radiative_path((size_t)i, sampled_area_proxy, thread_ctx,
- scn, view_samp, view_rt, ran_sun_dir, ran_sun_wl, path_tracker, output);
+ scn, view_samp, view_rt, ran_sun_dir, ran_sun_wl, path_tracker);
if(res_local == RES_BAD_OP) {
if(ATOMIC_INCR(&nfailures) >= max_failures) {
diff --git a/src/test_ssol_by_receiver_integration.c b/src/test_ssol_by_receiver_integration.c
@@ -134,19 +134,19 @@ main(int argc, char** argv)
#define S_DNI_cos (4 * 1000 * cos(PI / 4))
#define GET_MC_RCV ssol_estimator_get_mc_receiver
#define GET_MC_SAMP_X_RCV ssol_estimator_get_mc_sampled_x_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, NULL, &estimator1), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator1), RES_OK);
CHECK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
CHECK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, S_DNI_cos * 2e-1), 1);
- CHECK(ssol_solve(scene, rng, 8 * N__, 0, NULL, &estimator2), RES_OK);
+ CHECK(ssol_solve(scene, rng, 8 * N__, NULL, &estimator2), RES_OK);
CHECK(GET_MC_RCV(estimator2, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
CHECK(eq_eps(mc_rcv.incoming_flux.E, S_DNI_cos, S_DNI_cos * 5e-2), 1);
CHECK(ssol_estimator_ref_put(estimator1), RES_OK);
- CHECK(ssol_solve(scene, rng, 3 * N__, 0, NULL, &estimator1), RES_OK);
+ CHECK(ssol_solve(scene, rng, 3 * N__, NULL, &estimator1), RES_OK);
CHECK(GET_MC_RCV(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -86,10 +86,8 @@ main(int argc, char** argv)
double transform2[12]; /* 3x4 column major matrix */
double dbl;
size_t i, count, fcount, scount;
- FILE* tmp = NULL;
double m, std;
double a_m, a_std;
- uint32_t r_id;
unsigned ntris;
(void) argc, (void) argv;
@@ -122,14 +120,14 @@ main(int argc, char** argv)
CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
CHECK(ssol_scene_create(dev, &scene), RES_OK);
- CHECK(ssol_solve(NULL, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, NULL, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 0, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, NULL), RES_BAD_ARG);
+ CHECK(ssol_solve(NULL, rng, 10, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, NULL, 10, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, NULL), RES_BAD_ARG);
/* No geometry */
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
/* Create scene content */
CHECK(ssol_shape_create_mesh(dev, &dummy), RES_OK);
@@ -165,14 +163,14 @@ main(int argc, char** argv)
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
/* No sun */
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
CHECK(ssol_solve
- (scene, rng, 1, &SSOL_PATH_TRACKER_DEFAULT, NULL, &estimator), RES_OK);
+ (scene, rng, 1, &SSOL_PATH_TRACKER_DEFAULT, &estimator), RES_OK);
CHECK(ssol_estimator_get_tracked_paths_count(NULL, NULL), RES_BAD_ARG);
CHECK(ssol_estimator_get_tracked_paths_count(estimator, NULL), RES_BAD_ARG);
@@ -249,7 +247,7 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_instance_sample(secondary, 0), RES_OK);
CHECK(ssol_instance_sample(heliostat, 0), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled), RES_BAD_ARG);
CHECK(ssol_instance_sample(target, 1), RES_OK);
@@ -258,7 +256,7 @@ main(int argc, char** argv)
/* No attached sun */
CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
CHECK(ssol_sun_ref_put(sun), RES_OK);
/* Sun with no spectrum */
@@ -266,7 +264,7 @@ main(int argc, char** argv)
CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
@@ -275,39 +273,34 @@ main(int argc, char** argv)
CHECK(ssol_sun_set_direction(sun, d3(dir, 1, 0, -1)), RES_OK);
CHECK(ssol_sun_set_spectrum(sun, spectrum), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_BAD_ARG);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
CHECK(ssol_sun_set_dni(sun, DNI), RES_OK);
/* No receiver in scene */
CHECK(ssol_instance_set_receiver(heliostat, 0, 0), RES_OK);
CHECK(ssol_instance_set_receiver(secondary, 0, 0), RES_OK);
CHECK(ssol_instance_set_receiver(target, 0, 0), RES_OK);
- CHECK(ssol_solve(scene, rng, 10, 0, NULL, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_OK);
CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
CHECK(ssol_instance_set_receiver(secondary, SSOL_FRONT, 0), RES_OK);
CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 0), RES_OK);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Can sample any geometry; variance is high */
- NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
#define GET_MC_GLOBAL ssol_estimator_get_mc_global
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
CHECK(fcount, 0);
- printf("Ir = %g +/- %g; ", m, std);
#define COS cos(PI / 4)
#define DNI_cos (DNI * COS)
- CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, 2*std)), 1);
+ m = 4 * DNI_cos;
#define SQR(x) ((x)*(x))
dbl = sqrt((SQR(12 * DNI_cos) / 3 - SQR(4 * DNI_cos)) / (double)count);
- CHECK(eq_eps(std, dbl, dbl*1e-2), 1);
+ std = dbl;
/* Target was sampled but shadowed by secondary */
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
PRINT_GLOBAL(mc_global);
@@ -331,23 +324,19 @@ main(int argc, char** argv)
CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-1), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Sample primary mirror only; variance is low */
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_instance_sample(secondary, 0), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g; ", m, std);
- CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, std)), 1);
- CHECK(eq_eps(std, 0, 1e-4), 1);
+ m = 4 * DNI_cos;
+ std = 0;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
PRINT_GLOBAL(mc_global);
CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
@@ -367,15 +356,11 @@ main(int argc, char** argv)
CHECK(ssol_atmosphere_set_absorption(atm, &abs_data), RES_OK);
CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g; ", m, std);
- CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, std)), 1);
- CHECK(eq_eps(std, 0, 1e-4), 1);
+ m = 4 * DNI_cos;
+ std = 0;
CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_OK);
CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
@@ -415,17 +400,12 @@ main(int argc, char** argv)
CHECK(ssol_scene_attach_atmosphere(scene, atm), RES_OK);
CHECK(ssol_instance_set_receiver(target, SSOL_FRONT, 1), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &a_m, &a_std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g; ", a_m, a_std);
#define K (exp(-KA * 4 * sqrt(2)))
- CHECK(eq_eps(a_m, REFLECTIVITY * 4 * K * DNI_cos,
- MMAX(4 * K * DNI_cos * 1e-1, a_std)), 1);
- CHECK(eq_eps(a_std, 0, 1e-4), 1);
+ a_m = REFLECTIVITY * 4 * K * DNI_cos;
+ a_std = 0;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
PRINT_GLOBAL(mc_global);
CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
@@ -441,7 +421,7 @@ main(int argc, char** argv)
CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat, &sampled), RES_BAD_ARG);
CHECK(ssol_estimator_get_mc_sampled(estimator, heliostat2, &sampled), RES_OK);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, a_m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.E, a_m, 1e-4), 1);
CHECK(eq_eps(mc_rcv.incoming_flux.SE, a_std, 1e-4), 1);
CHECK(ssol_mc_receiver_get_mc_shape(NULL, NULL, NULL), RES_BAD_ARG);
@@ -479,7 +459,7 @@ main(int argc, char** argv)
dbl += mc_prim.incoming_flux.E * area;
}
- CHECK(eq_eps(dbl, a_m, 1.e-6), 1);
+ CHECK(eq_eps(dbl, a_m, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
CHECK(ssol_scene_detach_instance(scene, heliostat2), RES_OK);
@@ -507,16 +487,12 @@ main(int argc, char** argv)
abs_data.value.spectrum = abs_spectrum;
CHECK(ssol_atmosphere_set_absorption(atm, &abs_data), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g; ", m, std);
#define K2 (exp(-0.121 * 4 * sqrt(2)))
- CHECK(eq_eps(m, 4 * K2 * DNI_cos, MMAX(4 * K2 * DNI_cos * 1e-4, std)), 1);
- CHECK(eq_eps(std, 0, 1e-4), 1);
+ m = 4 * K2 * DNI_cos;
+ std = 0;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
PRINT_GLOBAL(mc_global);
CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
@@ -526,7 +502,7 @@ main(int argc, char** argv)
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
PRINT_RCV(mc_rcv);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-4), 1);
CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
/* Free data */
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -82,9 +82,7 @@ main(int argc, char** argv)
double transform2[12]; /* 3x4 column major matrix */
double transform3[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
double m, std;
- uint32_t r_id;
(void) argc, (void) argv;
@@ -177,21 +175,16 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g\n", m, std);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
- CHECK(eq_eps(m, 4 * DNI_cos, 4 * DNI_cos * 1e-4), 1);
+ m = 4 * DNI_cos;
#define SQR(x) ((x)*(x))
- CHECK(eq_eps(std, 0, 1e-4), 1);
+ std = 0;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -82,9 +82,7 @@ main(int argc, char** argv)
double transform2[12]; /* 3x4 column major matrix */
double transform3[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
double m, std;
- uint32_t r_id;
(void) argc, (void) argv;
d33_splat(transform1, 0);
@@ -181,21 +179,15 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 50000
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g\n", m, std);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
- CHECK(eq_eps(m, 2 * DNI_cos, MMAX(2 * DNI_cos * 1e-2, std)), 1);
+ m = 2 * DNI_cos;
#define SQR(x) ((x)*(x))
- CHECK(eq_eps(std,
- sqrt((SQR(4 * DNI_cos) / 2 - SQR(2 * DNI_cos)) / (double)count), 1e-3), 1);
+ std = sqrt((SQR(4 * DNI_cos) / 2 - SQR(2 * DNI_cos)) / (double)count);
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
@@ -207,7 +199,7 @@ main(int argc, char** argv)
(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
CHECK(count, 0);
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -72,9 +72,7 @@ main(int argc, char** argv)
double transform[12]; /* 3x4 column major matrix */
double area;
size_t count;
- FILE* tmp;
double m, std;
- uint32_t r_id;
(void) argc, (void) argv;
d3_splat(transform + 9, 0);
@@ -136,21 +134,15 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 20000
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g\n", m, std);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
- CHECK(eq_eps(m, 4 * DNI_cos, 4 * DNI_cos * 2e-1), 1);
+ m = 4 * DNI_cos;
#define SQR(x) ((x)*(x))
- CHECK(eq_eps(std,
- sqrt((SQR(400*DNI_cos) / 100 - SQR(4*DNI_cos)) / (double)count), 20), 1);
+ std = sqrt((SQR(400*DNI_cos) / 100 - SQR(4*DNI_cos)) / (double)count);
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
@@ -162,8 +154,8 @@ main(int argc, char** argv)
(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
printf("Ir(target) = %g +/- %g\n",
mc_rcv.incoming_flux.E, mc_rcv.incoming_flux.SE);
- CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 1e-8), 1);
- CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 1e-4), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.E, m, 2 * std), 1);
+ CHECK(eq_eps(mc_rcv.incoming_flux.SE, std, 10), 1);
CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
CHECK(count, 0);
CHECK(ssol_instance_get_area(heliostat, &area), RES_OK);
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -72,9 +72,7 @@ main(int argc, char** argv)
double dir[3];
double transform[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
double m1, std1, m2, std2;
- uint32_t r_id1, r_id2;
(void) argc, (void) argv;
#define FOCAL 10
@@ -144,24 +142,17 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target2, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target2), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target1, &r_id1), RES_OK);
- CHECK(ssol_instance_get_id(target2, &r_id2), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id1, count, &m1, &std1), RES_OK);
- CHECK(pp_sum(tmp, (int32_t)r_id2, count, &m2, &std2), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g\n", m1, std1);
#define COS cos(0)
#define DNI_cos (1000 * COS)
- CHECK(eq_eps(m1, 400 * DNI_cos, 400 * DNI_cos * 1e-4), 1);
- CHECK(eq_eps(std1, 0, 1), 1);
- CHECK(m1, m2);
- CHECK(std1, std2);
+ m1 = 400 * DNI_cos;
+ std1 = 0;
+ m2 = m1;
+ std2 = std1;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -71,9 +71,7 @@ main(int argc, char** argv)
double dir[3];
double transform[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
double m, std;
- uint32_t r_id;
(void) argc, (void) argv;
#define FOCAL 10
@@ -136,19 +134,14 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
- CHECK(fclose(tmp), 0);
- printf("Ir = %g +/- %g\n", m, std);
#define COS cos(0)
#define DNI_cos (1000 * COS)
- CHECK(eq_eps(m, 400 * DNI_cos, 20), 1);
- CHECK(eq_eps(std, 0, 1), 1);
+ m = 400 * DNI_cos;
+ std = 0;
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
printf("Shadows = %g +/- %g\n", mc_global.shadowed.E, mc_global.shadowed.SE);
printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
diff --git a/src/test_ssol_solver6.c b/src/test_ssol_solver6.c
@@ -78,7 +78,6 @@ main(int argc, char** argv)
struct ssol_mc_receiver mc_rcv;
double dir[3];
double transform[12]; /* 3x4 column major matrix */
- FILE* tmp;
(void) argc, (void) argv;
@@ -175,11 +174,9 @@ main(int argc, char** argv)
transform[11] = 10;
CHECK(ssol_instance_set_transform(target2, transform), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(fclose(tmp), 0);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
PRINT_GLOBAL(mc_global);
CHECK(eq_eps(mc_global.shadowed.E, 100000, 2 * 100000/sqrt(N__)), 1);
diff --git a/src/test_ssol_solver7.c b/src/test_ssol_solver7.c
@@ -82,7 +82,6 @@ main(int argc, char** argv)
struct ssol_mc_receiver mc_rcv;
double dir[3], area;
double transform[12]; /* 3x4 column major matrix */
- FILE* tmp;
/* primary is a parabol */
struct ssol_quadric quadric1 = SSOL_QUADRIC_DEFAULT;
struct ssol_punched_surface punched1 = SSOL_PUNCHED_SURFACE_NULL;
@@ -192,9 +191,7 @@ main(int argc, char** argv)
#define TOTAL (HELIOSTAT_SZ * HELIOSTAT_SZ * DNI_cos)
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- NCHECK(tmp = tmpfile(), 0);
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(fclose(tmp), 0);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
CHECK(ssol_estimator_get_sampled_area(estimator, &area), RES_OK);
diff --git a/src/test_ssol_solver8.c b/src/test_ssol_solver8.c
@@ -75,8 +75,6 @@ main(int argc, char** argv)
double dir[3];
double transform[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
- uint32_t r_id;
(void) argc, (void) argv;
d3_splat(transform + 9, 0);
@@ -139,14 +137,11 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(fclose(tmp), 0);
CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
CHECK(count, 0);
#define S (sqrt(2) * X_SZ * Y_SZ)
diff --git a/src/test_ssol_solver9.c b/src/test_ssol_solver9.c
@@ -77,8 +77,6 @@ main(int argc, char** argv)
double dir[3];
double transform[12]; /* 3x4 column major matrix */
size_t count;
- FILE* tmp;
- uint32_t r_id;
(void) argc, (void) argv;
d3_splat(transform + 9, 0);
@@ -133,14 +131,11 @@ main(int argc, char** argv)
CHECK(ssol_instance_sample(target, 0), RES_OK);
CHECK(ssol_scene_attach_instance(scene, target), RES_OK);
- NCHECK(tmp = tmpfile(), 0);
#define N__ 100000
#define GET_MC_RCV ssol_estimator_get_mc_receiver
- CHECK(ssol_solve(scene, rng, N__, 0, tmp, &estimator), RES_OK);
- CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
+ CHECK(ssol_solve(scene, rng, N__, NULL, &estimator), RES_OK);
CHECK(ssol_estimator_get_realisation_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(fclose(tmp), 0);
CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
CHECK(count, 0);
#define DNI_TGT_S (DNI * TGT_X * TGT_Y)
diff --git a/src/test_ssol_utils.c b/src/test_ssol_utils.c
@@ -1,62 +0,0 @@
-/* Copyright (C) CNRS 2016-2017
- *
- * 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/>. */
-
-#define _POSIX_C_SOURCE 200809L /* snprintf support */
-
-#include "test_ssol_utils.h"
-#include "ssol_c.h"
-
-#include <rsys/math.h>
-
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-
-res_T
-pp_sum
- (FILE* f,
- const int32_t receiver_id,
- const size_t count,
- double* mean,
- double* std)
-{
- struct ssol_receiver_data hit;
- double sum = 0;
- double sum2 = 0;
- double E, V, SE;
-
- if(!f || !mean || !std || !count)
- return RES_BAD_ARG;
-
- rewind(f);
- while (1 == fread(&hit, sizeof(struct ssol_receiver_data), 1, f)) {
- if (ferror(f))
- return RES_BAD_ARG;
-
- if (receiver_id != hit.receiver_id)
- continue;
-
- sum += hit.weight;
- sum2 += hit.weight * hit.weight;
- }
-
- E = sum / (double)count;
- V = MMAX(sum2 / (double)count - E*E, 0);
- SE = sqrt(V / (double)count);
-
- *mean = E;
- *std = SE;
- return RES_OK;
-}
diff --git a/src/test_ssol_utils.h b/src/test_ssol_utils.h
@@ -30,14 +30,6 @@ check_memory_allocator(struct mem_allocator* allocator)
}
}
-extern LOCAL_SYM res_T
-pp_sum
- (FILE* f,
- const int32_t receiver_id,
- const size_t count,
- double* mean,
- double* std);
-
#define PRINT_GLOBAL(Mc) { \
printf("Shadows = %g +/- %g; ", (Mc).shadowed.E, (Mc).shadowed.SE); \
printf("Missing = %g +/- %g; ", (Mc).missing.E, (Mc).missing.SE); \
