commit f904ab7d3d1b9a9ad3b1aa45ec9278a50636c567
parent 8ead7f083d0c80d0cc427b7d9624a1e9502bc5e3
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Fri, 8 Sep 2017 09:39:16 +0200
Merge remote-tracking branch 'origin/develop' into develop
Diffstat:
19 files changed, 167 insertions(+), 310 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
@@ -1103,7 +1103,7 @@ ssol_estimator_ref_put
SSOL_API res_T
ssol_estimator_get_mc_global
- (const struct ssol_estimator* estimator,
+ (struct ssol_estimator* estimator,
struct ssol_mc_global* mc_global);
SSOL_API res_T
@@ -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_estimator.c b/src/ssol_estimator.c
@@ -107,15 +107,17 @@ ssol_estimator_ref_put(struct ssol_estimator* estimator)
res_T
ssol_estimator_get_mc_global
- (const struct ssol_estimator* estimator,
+ (struct ssol_estimator* estimator,
struct ssol_mc_global* global)
{
if(!estimator || !global) return RES_BAD_ARG;
#define SETUP_MC_RESULT(Name) { \
const double N = (double)estimator->realisation_count; \
- const struct mc_data* data = &estimator->Name; \
- global->Name.E = data->weight / N; \
- global->Name.V = data->sqr_weight / N - global->Name.E*global->Name.E; \
+ struct mc_data* data = &estimator->Name; \
+ double weight, sqr_weight; \
+ mc_data_get(data, &weight, &sqr_weight); \
+ global->Name.E = weight / N; \
+ global->Name.V = sqr_weight / N - global->Name.E*global->Name.E; \
global->Name.V = global->Name.V > 0 ? global->Name.V : 0; \
global->Name.SE = sqrt(global->Name.V / N); \
} (void)0
@@ -165,9 +167,11 @@ ssol_estimator_get_mc_sampled_x_receiver
mc_rcv1 = side == SSOL_FRONT ? &mc_rcv->front : &mc_rcv->back;
#define SETUP_MC_RESULT(Name) { \
const double N = (double)estimator->realisation_count; \
- const struct mc_data* data = &mc_rcv1->Name; \
- rcv->Name.E = data->weight / N; \
- rcv->Name.V = data->sqr_weight / N - rcv->Name.E*rcv->Name.E; \
+ struct mc_data* data = &mc_rcv1->Name; \
+ double weight, sqr_weight; \
+ mc_data_get(data, &weight, &sqr_weight); \
+ rcv->Name.E = weight / N; \
+ rcv->Name.V = sqr_weight / N - rcv->Name.E*rcv->Name.E; \
rcv->Name.V = rcv->Name.V > 0 ? rcv->Name.V : 0; \
rcv->Name.SE = sqrt(rcv->Name.V / N); \
} (void)0
@@ -236,9 +240,11 @@ ssol_estimator_get_mc_sampled
sampled->nb_samples = mc->nb_samples;
#define SETUP_MC_RESULT(Name, Count) { \
const double N = (double)(Count); \
- const struct mc_data* data = &mc->Name; \
- sampled->Name.E = data->weight / N; \
- sampled->Name.V = data->sqr_weight/N - sampled->Name.E*sampled->Name.E; \
+ struct mc_data* data = &mc->Name; \
+ double weight, sqr_weight; \
+ mc_data_get(data, &weight, &sqr_weight); \
+ sampled->Name.E = weight / N; \
+ sampled->Name.V = sqr_weight/N - sampled->Name.E*sampled->Name.E; \
sampled->Name.V = sampled->Name.V > 0 ? sampled->Name.V : 0; \
sampled->Name.SE = sqrt(sampled->Name.V / N); \
} (void)0
diff --git a/src/ssol_estimator_c.h b/src/ssol_estimator_c.h
@@ -29,10 +29,14 @@ struct ssol_instance;
/* Monte carlo data */
struct mc_data {
- double weight;
- double sqr_weight;
+ size_t irealisation;
+ double tmp;
+
+ /* Internal data; use get() */
+ double __weight;
+ double __sqr_weight;
};
-#define MC_DATA_NULL__ { 0, 0 }
+#define MC_DATA_NULL__ { SIZE_MAX, 0, 0, 0 }
static const struct mc_data MC_DATA_NULL = MC_DATA_NULL__;
#define MC_RECEIVER_DATA \
@@ -48,6 +52,56 @@ static const struct mc_data MC_DATA_NULL = MC_DATA_NULL__;
struct mc_data absorbed_lost_in_atmosphere; /* In W */
/*******************************************************************************
+ * Deferred MC data accumulators
+ ******************************************************************************/
+static INLINE void
+mc_data_init(struct mc_data* data)
+{
+ ASSERT(data);
+ *data = MC_DATA_NULL;
+}
+
+static INLINE void
+mc_data_flush(struct mc_data* data)
+{
+ ASSERT(data);
+ data->__weight += data->tmp;
+ data->__sqr_weight += data->tmp * data->tmp;
+ data->tmp = 0;
+}
+
+static INLINE void
+mc_data_add_weight(struct mc_data* data, size_t irealisation, double w)
+{
+ ASSERT(data);
+ ASSERT(irealisation != SIZE_MAX);
+ if(irealisation != data->irealisation) {
+ mc_data_flush(data);
+ data->irealisation = irealisation;
+ }
+ data->tmp = w;
+}
+
+static INLINE void
+mc_data_accum(struct mc_data* dst, struct mc_data* src)
+{
+ ASSERT(dst && src);
+ mc_data_flush(dst);
+ mc_data_flush(src);
+ dst->__weight += src->__weight;
+ dst->__sqr_weight += src->__sqr_weight;
+}
+
+static INLINE void
+mc_data_get(struct mc_data* data, double* weight, double* sqr_weight)
+{
+ ASSERT(data && weight && sqr_weight);
+ mc_data_flush(data);
+ *weight = data->__weight;
+ *sqr_weight = data->__sqr_weight;
+}
+
+/*******************************************************************************
* One sided per shape MC data
******************************************************************************/
struct mc_primitive_1side {
diff --git a/src/ssol_mc_receiver.c b/src/ssol_mc_receiver.c
@@ -53,9 +53,11 @@ ssol_estimator_get_mc_receiver
mc_rcv1 = side == SSOL_FRONT ? &mc_rcv->front : &mc_rcv->back;
#define SETUP_MC_RESULT(Name) { \
const double N = (double)estimator->realisation_count; \
- const struct mc_data* data = &mc_rcv1->Name; \
- rcv->Name.E = data->weight / N; \
- rcv->Name.V = data->sqr_weight/N - rcv->Name.E*rcv->Name.E; \
+ struct mc_data* data = &mc_rcv1->Name; \
+ double weight, sqr_weight; \
+ mc_data_get(data, &weight, &sqr_weight); \
+ rcv->Name.E = weight / N; \
+ rcv->Name.V = sqr_weight/N - rcv->Name.E*rcv->Name.E; \
rcv->Name.V = rcv->Name.V > 0 ? rcv->Name.V : 0; \
rcv->Name.SE = sqrt(rcv->Name.V / N); \
} (void)0
@@ -150,9 +152,11 @@ ssol_mc_shape_get_mc_primitive
#define SETUP_MC_RESULT(Name) { \
const double N = (double)shape->N__; \
- const struct mc_data* data = &mc_prim1->Name; \
- prim->Name.E = data->weight / N; \
- prim->Name.V = data->sqr_weight/N - prim->Name.E*prim->Name.E; \
+ struct mc_data* data = &mc_prim1->Name; \
+ double weight, sqr_weight; \
+ mc_data_get(data, &weight, &sqr_weight); \
+ prim->Name.E = weight / N; \
+ prim->Name.V = sqr_weight/N - prim->Name.E*prim->Name.E; \
prim->Name.V = prim->Name.V > 0 ? prim->Name.V : 0; \
prim->Name.SE = sqrt(prim->Name.V / N); \
prim->Name.E /= area; \
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
******************************************************************************/
@@ -594,10 +569,7 @@ accum_mc_receivers_1side
ACCUM_WEIGHT(absorbed_lost_in_atmosphere); \
} (void)0
- #define ACCUM_WEIGHT(Name) { \
- dst->Name.weight += src->Name.weight; \
- dst->Name.sqr_weight += src->Name.sqr_weight; \
- } (void)0
+ #define ACCUM_WEIGHT(Name) mc_data_accum(&dst->Name, &src->Name)
ACCUM_ALL;
#undef ACCUM_WEIGHT
@@ -628,10 +600,8 @@ accum_mc_receivers_1side
res = mc_shape_1side_get_mc_primitive(mc_shape1_dst, iprim, &mc_prim1_dst);
if(res != RES_OK) goto error;
- #define ACCUM_WEIGHT(Name) { \
- mc_prim1_dst->Name.weight += mc_prim1_src->Name.weight; \
- mc_prim1_dst->Name.sqr_weight += mc_prim1_src->Name.sqr_weight; \
- } (void)0
+ #define ACCUM_WEIGHT(Name) \
+ mc_data_accum(&mc_prim1_dst->Name, &mc_prim1_src->Name)
ACCUM_ALL;
#undef ACCUM_WEIGHT
@@ -657,10 +627,7 @@ accum_mc_sampled(struct mc_sampled* dst, struct mc_sampled* src)
mc_receiver_init(NULL, &mc_rcv_null);
- #define ACCUM_WEIGHT(Name) { \
- dst->Name.weight += src->Name.weight; \
- dst->Name.sqr_weight += src->Name.sqr_weight; \
- } (void)0
+ #define ACCUM_WEIGHT(Name) mc_data_accum(&dst->Name, &src->Name)
ACCUM_WEIGHT(cos_factor);
ACCUM_WEIGHT(shadowed);
#undef ACCUM_WEIGHT
@@ -708,18 +675,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 */
@@ -745,10 +707,8 @@ update_mc
(pt->incoming_if_no_atm_loss - pt->incoming_flux) * pt->kabs_at_pt); \
} (void)0
- #define ACCUM_WEIGHT(Name, W) { \
- mc_rcv1->Name.weight += (W); \
- mc_rcv1->Name.sqr_weight += (W)*(W); \
- } (void)0
+ #define ACCUM_WEIGHT(Name, W) \
+ mc_data_add_weight(&mc_rcv1->Name, irealisation, W)
ACCUM_ALL;
#undef ACCUM_WEIGHT
@@ -757,10 +717,8 @@ update_mc
(pt->mc_samp, pt->inst, pt->side, &mc_samp_x_rcv1);
if(res != RES_OK) goto error;
- #define ACCUM_WEIGHT(Name, W) { \
- mc_samp_x_rcv1->Name.weight += (W); \
- mc_samp_x_rcv1->Name.sqr_weight += (W)*(W); \
- } (void)0
+ #define ACCUM_WEIGHT(Name, W)\
+ mc_data_add_weight(&mc_samp_x_rcv1->Name, irealisation, W)
ACCUM_ALL;
#undef ACCUM_WEIGHT
@@ -775,10 +733,8 @@ update_mc
res = mc_shape_1side_get_mc_primitive(mc_shape1, pt->prim.prim_id, &mc_prim1);
if(res != RES_OK) goto error;
- #define ACCUM_WEIGHT(Name, W) { \
- mc_prim1->Name.weight += (W); \
- mc_prim1->Name.sqr_weight += (W)*(W); \
- } (void)0
+ #define ACCUM_WEIGHT(Name, W)\
+ mc_data_add_weight(&mc_prim1->Name, irealisation, W)
ACCUM_ALL;
#undef ACCUM_WEIGHT
}
@@ -792,7 +748,7 @@ error:
static res_T
trace_radiative_path
- (const size_t path_id, /* Unique id of the radiative path */
+ (const size_t irealisation, /* Unique id of the realisation */
const double sampled_area_proxy, /* Overall area of the sampled geometries */
struct thread_context* thread_ctx,
struct ssol_scene* scn,
@@ -800,8 +756,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;
@@ -839,10 +794,7 @@ trace_radiative_path
if(res != RES_OK) goto error;
}
- #define ACCUM_WEIGHT(Res, W) { \
- Res.weight += (W); \
- Res.sqr_weight += (W)*(W); \
- } (void)0
+ #define ACCUM_WEIGHT(Res, W) mc_data_add_weight(&Res, irealisation, W)
if(!is_lit) { /* The starting point is not lit */
ACCUM_WEIGHT(pt.mc_samp->shadowed, pt.initial_flux);
@@ -891,7 +843,7 @@ trace_radiative_path
/* If receiver update MC results */
if(hit_receiver) {
hit_a_receiver = 1;
- res = update_mc(&pt, path_id, 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;
@@ -1012,7 +964,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;
@@ -1113,7 +1064,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) {
@@ -1130,12 +1081,10 @@ ssol_solve
/* Merge per thread global MC estimations */
FOR_EACH(i, 0, nthreads) {
- const struct thread_context* thread_ctx;
- thread_ctx = darray_thread_ctx_cdata_get(&thread_ctxs)+i;
- #define ACCUM_WEIGHT(Name) { \
- estimator->Name.weight += thread_ctx->Name.weight; \
- estimator->Name.sqr_weight += thread_ctx->Name.sqr_weight; \
- } (void)0
+ struct thread_context* thread_ctx;
+ thread_ctx = darray_thread_ctx_data_get(&thread_ctxs)+i;
+ #define ACCUM_WEIGHT(Name) \
+ mc_data_accum(&estimator->Name, &thread_ctx->Name)
ACCUM_WEIGHT(cos_factor);
ACCUM_WEIGHT(absorbed_by_receivers);
ACCUM_WEIGHT(shadowed);
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); \
