commit 5159b18b8b5d0ab2edcabed7cfa4bca0c2cd9f13
parent faeb474edf8d3e55fe95e4d9a49c716365953a4e
Author: Christophe Coustet <christophe.coustet@meso-star.com>
Date: Thu, 9 Feb 2017 14:15:26 +0100
Losses computation (per receiver atmospheric and reflectivity losses).
A few renames too.
Diffstat:
15 files changed, 313 insertions(+), 161 deletions(-)
diff --git a/src/ssol.h b/src/ssol.h
@@ -247,11 +247,17 @@ struct ssol_receiver_data {
/* TODO Add the geometry and primitive identifier */
};
+struct ssol_mc_result {
+ double E; /* Expectation */
+ double V; /* Variance */
+ double SE; /* Standard error, i.e. sqrt(Expectation / N) */
+};
+
/* result for MC simulations */
struct ssol_estimator_status {
- double E; /* Expected value */
- double V; /* Variance */
- double SE; /* Standard error, i.e. sqrt(V / N) */
+ struct ssol_mc_result irradiance;
+ struct ssol_mc_result absorptivity_loss;
+ struct ssol_mc_result reflectivity_loss;
size_t N; /* Samples count */
size_t Nf; /* Failed samples count */
};
diff --git a/src/ssol_atmosphere.c b/src/ssol_atmosphere.c
@@ -123,7 +123,7 @@ ssol_atmosphere_set_uniform_absorption
* Local functions
******************************************************************************/
double
-compute_atmosphere_attenuation
+compute_atmosphere_transmissivity
(const struct ssol_atmosphere* atmosphere,
const double distance,
const double wavelength)
diff --git a/src/ssol_atmosphere_c.h b/src/ssol_atmosphere_c.h
@@ -42,7 +42,7 @@ struct ssol_atmosphere {
};
extern LOCAL_SYM double
-compute_atmosphere_attenuation
+compute_atmosphere_transmissivity
(const struct ssol_atmosphere* atmosphere,
const double distance,
const double wavelength);
diff --git a/src/ssol_estimator.c b/src/ssol_estimator.c
@@ -48,7 +48,7 @@ create_per_receiver_mc_data
if(!inst->receiver_mask) continue;
res = htable_receiver_set
- (&estimator->global_receivers, &inst, &MC_DATA2_NULL);
+ (&estimator->global_receivers, &inst, &MC_RECV_DATA_NULL);
if(res != RES_OK) goto error;
}
exit:
@@ -110,9 +110,19 @@ ssol_estimator_get_status
}
status->N = estimator->realisation_count;
status->Nf = estimator->failed_count;
- status->E = data->weight / (double)status->N;
- status->V = data->sqr_weight / (double)status->N - status->E * status->E;
- status->SE = (status->V > 0) ? sqrt(status->V / (double)status->N) : 0;
+ status->irradiance.E = data->weight / (double)status->N;
+ status->irradiance.V
+ = data->sqr_weight / (double)status->N
+ - status->irradiance.E * status->irradiance.E;
+ status->irradiance.SE
+ = (status->irradiance.V > 0)
+ ? sqrt(status->irradiance.V / (double)status->N) : 0;
+ status->absorptivity_loss.E = 0;
+ status->absorptivity_loss.V = 0;
+ status->absorptivity_loss.SE = 0;
+ status->reflectivity_loss.E = 0;
+ status->reflectivity_loss.V = 0;
+ status->reflectivity_loss.SE = 0;
return RES_OK;
}
@@ -123,21 +133,39 @@ ssol_estimator_get_receiver_status
const enum ssol_side_flag side,
struct ssol_estimator_status* status)
{
- const struct mc_data* rcv_data = NULL;
+ const struct mc_per_receiver_1side_data* data = NULL;
if (!estimator || !instance || !status
|| (side != SSOL_BACK && side != SSOL_FRONT))
return RES_BAD_ARG;
/* Check if a receiver is defined for this instance/side */
- rcv_data = estimator_get_receiver_data
+ data = estimator_get_receiver_data
(&estimator->global_receivers, instance, side);
- if(rcv_data == NULL) return RES_BAD_ARG;
+ if(data == NULL) return RES_BAD_ARG;
status->N = estimator->realisation_count;
status->Nf = estimator->failed_count;
- status->E = rcv_data->weight / (double)status->N;
- status->V = rcv_data->sqr_weight / (double)status->N - status->E * status->E;
- status->SE = (status->V > 0) ? sqrt(status->V / (double)status->N) : 0;
+ status->irradiance.E = data->irradiance.weight / (double)status->N;
+ status->irradiance.V
+ = data->irradiance.sqr_weight / (double)status->N
+ - status->irradiance.E * status->irradiance.E;
+ status->irradiance.SE
+ = (status->irradiance.V > 0) ?
+ sqrt(status->irradiance.V / (double)status->N) : 0;
+ status->absorptivity_loss.E = data->absorptivity_loss.weight / (double) status->N;
+ status->absorptivity_loss.V
+ = data->absorptivity_loss.sqr_weight / (double) status->N
+ - status->absorptivity_loss.E * status->absorptivity_loss.E;
+ status->absorptivity_loss.SE
+ = (status->absorptivity_loss.V > 0) ?
+ sqrt(status->absorptivity_loss.V / (double) status->N) : 0;
+ status->reflectivity_loss.E = data->reflectivity_loss.weight / (double) status->N;
+ status->reflectivity_loss.V
+ = data->reflectivity_loss.sqr_weight / (double) status->N
+ - status->reflectivity_loss.E * status->reflectivity_loss.E;
+ status->reflectivity_loss.SE
+ = (status->reflectivity_loss.V > 0) ?
+ sqrt(status->reflectivity_loss.V / (double) status->N) : 0;
return RES_OK;
}
diff --git a/src/ssol_estimator_c.h b/src/ssol_estimator_c.h
@@ -37,30 +37,43 @@ struct mc_data {
#define MC_DATA_NULL__ { 0, 0 }
static const struct mc_data MC_DATA_NULL = MC_DATA_NULL__;
-struct mc_data_2 {
- struct mc_data front;
- struct mc_data back;
+struct mc_per_receiver_1side_data {
+ struct mc_data irradiance;
+ struct mc_data absorptivity_loss;
+ struct mc_data reflectivity_loss;
};
-#define MC_DATA2_NULL__ { MC_DATA_NULL__, MC_DATA_NULL__ }
-static const struct mc_data_2 MC_DATA2_NULL = MC_DATA2_NULL__;
+#define MC_RECV_1SIDE_DATA_NULL__ { MC_DATA_NULL__, MC_DATA_NULL__, MC_DATA_NULL__ }
+
+static const struct mc_per_receiver_1side_data
+MC_RECV_1SIDE_DATA_NULL = MC_RECV_1SIDE_DATA_NULL__;
+
+struct mc_per_receiver_data {
+ struct mc_per_receiver_1side_data front;
+ struct mc_per_receiver_1side_data back;
+};
+
+#define MC_RECV_DATA_NULL__ { MC_RECV_1SIDE_DATA_NULL__, MC_RECV_1SIDE_DATA_NULL__ }
+
+static const struct mc_per_receiver_data
+MC_RECV_DATA_NULL = MC_RECV_DATA_NULL__;
static INLINE void
-init_mc_data2
+init_mc_per_recv_data
(struct mem_allocator* alloc,
- struct mc_data_2* data)
+ struct mc_per_receiver_data* data)
{
(void)alloc;
ASSERT(data);
- *data = MC_DATA2_NULL;
+ *data = MC_RECV_DATA_NULL;
}
/* Define the htable_receiver data structure */
struct ssol_instance;
#define HTABLE_NAME receiver
#define HTABLE_KEY const struct ssol_instance*
-#define HTABLE_DATA struct mc_data_2
-#define HTABLE_FUNCTOR_INIT init_mc_data2
+#define HTABLE_DATA struct mc_per_receiver_data
+#define HTABLE_FUNCTOR_INIT init_mc_per_recv_data
#include <rsys/hash_table.h>
struct ssol_estimator {
@@ -82,18 +95,18 @@ estimator_create
struct ssol_scene* scene,
struct ssol_estimator** estimator);
-static FINLINE struct mc_data*
+static FINLINE struct mc_per_receiver_1side_data*
estimator_get_receiver_data
(struct htable_receiver* receivers,
const struct ssol_instance* instance,
const enum ssol_side_flag side)
{
- struct mc_data_2* data2;
+ struct mc_per_receiver_data* data;
ASSERT(receivers && instance);
if(!(instance->receiver_mask & (int)side)) return NULL;
- data2 = htable_receiver_find(receivers, &instance);
- if(!data2) return NULL;
- return side == SSOL_FRONT ? &data2->front : &data2->back;
+ data = htable_receiver_find(receivers, &instance);
+ if(!data) return NULL;
+ return side == SSOL_FRONT ? &data->front : &data->back;
}
#endif /* SSOL_ESTIMATOR_C_H */
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -53,10 +53,17 @@ struct point {
double dir[3];
float uv[2];
double wl; /* Sampled wavelength */
- double weight;
+ double weight; /* actual weight */
+ double absorptivity_loss; /* weight with no amospheric effets */
+ double reflectivity_loss; /* weight with no reflectivity effets */
enum ssol_side_flag side;
};
+
+#define POINT_NULL__ { NULL, NULL, S3D_PRIMITIVE_NULL__, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0}, 0, 0, 0, 0, SSOL_FRONT }
+static const struct point POINT_NULL = POINT_NULL__;
+
+
/*******************************************************************************
* Helper functions
******************************************************************************/
@@ -100,6 +107,7 @@ point_init
/* Initialise the Monte Carlo weight */
pt->weight = scn->sun->dni * sampled_area * fabs(d3_dot(pt->N, pt->dir));
+ pt->absorptivity_loss = pt->reflectivity_loss = 0;
/* Retrieve the sampled instance and shaded shape */
pt->inst = *htable_instance_find(&scn->instances_samp, &pt->prim.inst_id);
@@ -201,7 +209,7 @@ point_shade
(struct point* pt, struct ssf_bsdf* bsdf, struct ssp_rng* rng, double dir[3])
{
struct surface_fragment frag;
- double wi[3], pdf;
+ double wi[3], pdf, r;
res_T res;
/* TODO ensure that if `prim' was sampled, then the surface fragment setup
@@ -226,7 +234,11 @@ point_shade
* directions point outward the surface => negate incoming dir */
d3_minus(wi, pt->dir);
- pt->weight *= ssf_bsdf_sample(bsdf, rng, wi, frag.Ns, dir, &pdf);
+ r = ssf_bsdf_sample(bsdf, rng, wi, frag.Ns, dir, &pdf);
+ ASSERT(0 <= r && r <= 1);
+ pt->reflectivity_loss += (1 - r) * pt->weight;
+ pt->weight *= r;
+
return RES_OK;
}
@@ -395,11 +407,8 @@ ssol_solve
htable_receiver_begin(mc_rcvs + i, &it);
htable_receiver_end(mc_rcvs + i, &end);
while (!htable_receiver_iterator_eq(&it, &end)) {
- struct mc_data_2* estimator_data = htable_receiver_iterator_data_get(&it);
- estimator_data->front.weight = 0;
- estimator_data->front.sqr_weight = 0;
- estimator_data->back.weight = 0;
- estimator_data->back.sqr_weight = 0;
+ struct mc_per_receiver_data* estimator_data = htable_receiver_iterator_data_get(&it);
+ *estimator_data = MC_RECV_DATA_NULL;
htable_receiver_iterator_next(&it);
}
}
@@ -450,15 +459,19 @@ ssol_solve
if(point_is_receiver(&pt)) {
const res_T res_local = point_dump(&pt, (size_t)i, depth, output);
- struct mc_data* mc_rcv = NULL;
+ struct mc_per_receiver_1side_data* data = NULL;
if(res_local != RES_OK) {
ATOMIC_SET(&res, res_local);
break;
}
- mc_rcv = estimator_get_receiver_data(receiver, pt.inst, pt.side);
- ASSERT(mc_rcv);
- mc_rcv->weight += pt.weight;
- mc_rcv->sqr_weight += pt.weight*pt.weight;
+ data = estimator_get_receiver_data(receiver, pt.inst, pt.side);
+ ASSERT(data);
+ data->irradiance.weight += pt.weight;
+ data->irradiance.sqr_weight += pt.weight*pt.weight;
+ data->absorptivity_loss.weight += pt.absorptivity_loss;
+ data->absorptivity_loss.sqr_weight += pt.absorptivity_loss * pt.absorptivity_loss;
+ data->reflectivity_loss.weight += pt.reflectivity_loss;
+ data->reflectivity_loss.sqr_weight += pt.reflectivity_loss * pt.reflectivity_loss;
hit_a_receiver = 1;
}
@@ -477,6 +490,7 @@ ssol_solve
ATOMIC_SET(&res, res_local);
break;
}
+ if (pt.weight == 0) break;
/* Setup new ray parameters */
f2(range, 0, FLT_MAX);
@@ -499,8 +513,11 @@ ssol_solve
/* Take into account the atmosphere attenuation along the new ray */
if(scn->atmosphere) {
- pt.weight *= compute_atmosphere_attenuation
- (scn->atmosphere, hit.distance, pt.wl);
+ double transmissivity =
+ compute_atmosphere_transmissivity(scn->atmosphere, hit.distance, pt.wl);
+ ASSERT(0 < transmissivity && transmissivity <= 1);
+ pt.absorptivity_loss += (1 - transmissivity) * pt.weight;
+ pt.weight *= transmissivity;
}
/* Update the point */
@@ -525,16 +542,40 @@ ssol_solve
htable_receiver_begin(&estimator->global_receivers, &it);
htable_receiver_end(&estimator->global_receivers, &end);
while (!htable_receiver_iterator_eq(&it, &end)) {
- struct mc_data_2* estimator_data = htable_receiver_iterator_data_get(&it);
+ struct mc_per_receiver_data* estimator_data
+ = htable_receiver_iterator_data_get(&it);
const struct ssol_instance* key = *htable_receiver_iterator_key_get(&it);
htable_receiver_iterator_next(&it);
FOR_EACH(i, 0, nthreads) {
/* Sum both sides, even if no receiver is defined to avoid tests */
- struct mc_data_2* thread_data = htable_receiver_find(mc_rcvs + i, &key);
- estimator_data->front.weight += thread_data->front.weight;
- estimator_data->front.sqr_weight += thread_data->front.sqr_weight;
- estimator_data->back.weight += thread_data->back.weight;
- estimator_data->back.sqr_weight += thread_data->back.sqr_weight;
+ struct mc_per_receiver_data* thread_data
+ = htable_receiver_find(mc_rcvs + i, &key);
+ estimator_data->front.irradiance.weight
+ += thread_data->front.irradiance.weight;
+ estimator_data->front.irradiance.sqr_weight
+ += thread_data->front.irradiance.sqr_weight;
+ estimator_data->back.irradiance.weight
+ += thread_data->back.irradiance.weight;
+ estimator_data->back.irradiance.sqr_weight
+ += thread_data->back.irradiance.sqr_weight;
+
+ estimator_data->front.absorptivity_loss.weight
+ += thread_data->front.absorptivity_loss.weight;
+ estimator_data->front.absorptivity_loss.sqr_weight
+ += thread_data->front.absorptivity_loss.sqr_weight;
+ estimator_data->back.absorptivity_loss.weight
+ += thread_data->back.absorptivity_loss.weight;
+ estimator_data->back.absorptivity_loss.sqr_weight
+ += thread_data->back.absorptivity_loss.sqr_weight;
+
+ estimator_data->front.reflectivity_loss.weight
+ += thread_data->front.reflectivity_loss.weight;
+ estimator_data->front.reflectivity_loss.sqr_weight
+ += thread_data->front.reflectivity_loss.sqr_weight;
+ estimator_data->back.reflectivity_loss.weight
+ += thread_data->back.reflectivity_loss.weight;
+ estimator_data->back.reflectivity_loss.sqr_weight
+ += thread_data->back.reflectivity_loss.sqr_weight;
}
}
estimator->realisation_count += realisations_count;
diff --git a/src/test_ssol_by_receiver_integration.c b/src/test_ssol_by_receiver_integration.c
@@ -142,18 +142,21 @@ main(int argc, char** argv)
#define GET_RCV_STATUS ssol_estimator_get_receiver_status
CHECK(ssol_solve(scene, rng, N__, NULL, &estimator1), RES_OK);
CHECK(GET_RCV_STATUS(estimator1, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT), RES_OK);
- CHECK(eq_eps(status.E, S_DNI_cos, S_DNI_cos * 2e-1), 1);
+ CHECK(eq_eps(status.irradiance.E, S_DNI_cos, S_DNI_cos * 2e-1), 1);
CHECK(ssol_solve(scene, rng, 8 * N__, NULL, &estimator2), RES_OK);
CHECK(GET_RCV_STATUS(estimator2, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, S_DNI_cos, S_DNI_cos * 5e-2), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.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__, NULL, &estimator1), RES_OK);
CHECK(GET_RCV_STATUS(estimator1, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, S_DNI_cos, S_DNI_cos * 1e-1), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, S_DNI_cos, S_DNI_cos * 1e-1), 1);
#undef N__
#undef S_DNI_cos
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_materials.h b/src/test_ssol_materials.h
@@ -16,6 +16,8 @@
#ifndef TEST_SSOL_MATERIALS_H
#define TEST_SSOL_MATERIALS_H
+#define REFLECTIVITY 0.87
+
struct ssol_device;
static void
@@ -53,6 +55,23 @@ get_shader_reflectivity
}
static void
+get_shader_reflectivity_2
+(struct ssol_device* dev,
+ struct ssol_param_buffer* buf,
+ const double wavelength,
+ const double P[3],
+ const double Ng[3],
+ const double Ns[3],
+ const double uv[2],
+ const double w[3],
+ double* val)
+{
+ (void) dev, (void) buf, (void) wavelength;
+ (void) P, (void) Ng, (void) Ns, (void) uv, (void) w;
+ *val = REFLECTIVITY;
+}
+
+static void
get_shader_roughness
(struct ssol_device* dev,
struct ssol_param_buffer* buf,
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -54,12 +54,12 @@ main(int argc, char** argv)
struct ssol_scene* scene;
struct ssol_shape* square;
struct ssol_vertex_data attribs[1] = { SSOL_VERTEX_DATA_NULL__ };
- struct ssol_material* m_mtl;
+ struct ssol_material *m_mtl, *m_mtl2;
struct ssol_material* v_mtl;
struct ssol_mirror_shader shader = SSOL_MIRROR_SHADER_NULL;
- struct ssol_object* m_object;
+ struct ssol_object *m_object, *m_object2;
struct ssol_object* t_object;
- struct ssol_instance* heliostat;
+ struct ssol_instance *heliostat, *heliostat2;
struct ssol_instance* secondary;
struct ssol_instance* target;
struct ssol_sun* sun;
@@ -81,6 +81,7 @@ main(int argc, char** argv)
size_t count, fcount;
FILE* tmp = NULL;
double m, std;
+ double a_m, a_std;
uint32_t r_id;
(void) argc, (void) argv;
@@ -258,7 +259,7 @@ main(int argc, char** argv)
CHECK(fclose(tmp), 0);
CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
CHECK(fcount, 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g", m, std);
#define COS cos(PI / 4)
#define DNI_cos (1000 * COS)
CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, 2*std)), 1);
@@ -267,13 +268,15 @@ main(int argc, char** argv)
CHECK(eq_eps(std, dbl, dbl*1e-2), 1);
/* Target was sampled but shadowed by secondary */
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 2 * dbl), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 2 * dbl), 1);
CHECK(status.N, count);
CHECK(status.Nf, fcount);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 2*status.SE), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 2*status.irradiance.SE), 1);
CHECK(status.N, count);
CHECK(status.Nf, fcount);
CHECK(GET_RCV_STATUS(NULL, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
@@ -292,9 +295,10 @@ main(int argc, char** argv)
CHECK(GET_RCV_STATUS(estimator, NULL, SSOL_FRONT, &status), RES_BAD_ARG);
CHECK(GET_RCV_STATUS(NULL, target, SSOL_FRONT, &status), RES_BAD_ARG);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Sample primary mirror only; variance is low */
@@ -307,19 +311,22 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %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);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Check atmosphere model; with no absorption result is unchanged */
@@ -338,26 +345,44 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %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);
CHECK(ssol_scene_detach_atmosphere(scene, atm), RES_OK);
CHECK(ssol_spectrum_ref_put(abs), RES_OK);
CHECK(ssol_atmosphere_ref_put(atm), RES_OK);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
- /* Check atmosphere model; with absorption power decreases */
- ka[0] = ka[1] = ka[2] = 0.1;
+ /* Check atmosphere model and imperfect mirror: there are losses */
+ CHECK(ssol_scene_detach_instance(scene, heliostat), RES_OK);
+
+ CHECK(ssol_material_create_mirror(dev, &m_mtl2), RES_OK);
+ shader.normal = get_shader_normal;
+ shader.reflectivity = get_shader_reflectivity_2;
+ shader.roughness = get_shader_roughness;
+ CHECK(ssol_mirror_set_shader(m_mtl2, &shader), RES_OK);
+
+ CHECK(ssol_object_create(dev, &m_object2), RES_OK);
+ CHECK(ssol_object_add_shaded_shape(m_object2, square, m_mtl2, m_mtl2), RES_OK);
+ CHECK(ssol_object_instantiate(m_object2, &heliostat2), RES_OK);
+ CHECK(ssol_instance_set_receiver(heliostat2, SSOL_FRONT), RES_OK);
+ CHECK(ssol_scene_attach_instance(scene, heliostat2), RES_OK);
+
+#define KA 0.03
+ ka[0] = ka[1] = ka[2] = KA;
CHECK(ssol_spectrum_create(dev, &abs), RES_OK);
CHECK(ssol_spectrum_setup(abs, get_wlen, 3, &desc), RES_OK);
CHECK(ssol_atmosphere_create_uniform(dev, &atm), RES_OK);
@@ -368,24 +393,35 @@ main(int argc, char** argv)
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
CHECK(count, N__);
- CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
+ CHECK(pp_sum(tmp, (int32_t)r_id, count, &a_m, &a_std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
-#define K (exp(-0.1 * 4 * sqrt(2)))
- CHECK(eq_eps(m, 4 * K * DNI_cos, MMAX(4 * K * DNI_cos * 1e-1, std)), 1);
- CHECK(eq_eps(std, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %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);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g (%.2g %%)",
+ status.irradiance.E, status.irradiance.SE, 100 * status.irradiance.E / m);
+ logger_print(&logger, LOG_OUTPUT, "Atmospheric Loss(target) = %g +/- %g (%.2g %%)",
+ status.absorptivity_loss.E, status.absorptivity_loss.SE, 100 * status.absorptivity_loss.E / m);
+ logger_print(&logger, LOG_OUTPUT, "Reflectivity Loss(target) = %g +/- %g (%.2g %%)",
+ status.reflectivity_loss.E, status.reflectivity_loss.SE, 100 * status.reflectivity_loss.E / m);
+ CHECK(eq_eps(status.irradiance.E, a_m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, a_std, 1e-4), 1);
+ CHECK(eq_eps(status.irradiance.E + status.absorptivity_loss.E + status.reflectivity_loss.E, m, 1e-8), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
+ CHECK(ssol_scene_detach_instance(scene, heliostat2), RES_OK);
+ CHECK(ssol_scene_attach_instance(scene, heliostat), RES_OK);
+
/* Check a monochromatic sun */
desc.wavelengths = &mono;
desc.intensities = intensities;
@@ -397,7 +433,7 @@ main(int argc, char** argv)
CHECK(ssol_sun_set_dni(sun_mono, 1000), RES_OK);
CHECK(ssol_scene_detach_sun(scene, sun), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun_mono), RES_OK);
- ka[1] = 0.2;
+ ka[1] = 0.2; ka[0] = ka[2] = 0.1;
desc.wavelengths = wavelengths;
desc.intensities = ka;
desc.count = 2;
@@ -408,24 +444,30 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %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);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g",
+ status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g",
+status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
/* Free data */
+ CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
+ CHECK(ssol_object_ref_put(m_object2), RES_OK);
+ CHECK(ssol_material_ref_put(m_mtl2), RES_OK);
CHECK(ssol_instance_ref_put(heliostat), RES_OK);
CHECK(ssol_instance_ref_put(secondary), RES_OK);
CHECK(ssol_instance_ref_put(target), RES_OK);
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -193,28 +193,28 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
CHECK(eq_eps(m, 4 * DNI_cos, 4 * DNI_cos * 1e-4), 1);
#define SQR(x) ((x)*(x))
CHECK(eq_eps(std, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, heliostat1, SSOL_BACK, &status), RES_BAD_ARG);
CHECK(GET_RCV_STATUS(estimator, heliostat1, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(heliostat1) = %g +/- %g", status.E, status.SE);
+ logger_print(&logger, LOG_OUTPUT, "Ir(heliostat1) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
CHECK(GET_RCV_STATUS(estimator, heliostat2, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(heliostat2) = %g +/- %g", status.E, status.SE);
+ logger_print(&logger, LOG_OUTPUT, "Ir(heliostat2) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
CHECK(GET_RCV_STATUS(estimator, secondary, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(secondary) = %g +/- %g", status.E, status.SE);
+ logger_print(&logger, LOG_OUTPUT, "Ir(secondary) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -198,23 +198,23 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
CHECK(eq_eps(m, 2 * DNI_cos, MMAX(2 * DNI_cos * 1e-2, std)), 1);
#define SQR(x) ((x)*(x))
CHECK(eq_eps(std,
sqrt((SQR(4 * DNI_cos) / 2 - SQR(2 * DNI_cos)) / (double)count), 1e-3), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(status.Nf, 0);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -152,23 +152,23 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 4))
CHECK(eq_eps(m, 4 * DNI_cos, 4 * DNI_cos * 2e-1), 1);
#define SQR(x) ((x)*(x))
CHECK(eq_eps(std,
sqrt((SQR(400*DNI_cos) / 100 - SQR(4*DNI_cos)) / (double)count), 20), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(status.Nf, 0);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_solver3N.c b/src/test_ssol_solver3N.c
@@ -219,20 +219,20 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(PI / 8))
CHECK(eq_eps(m, 4 * NX * NY * NZ * DNI_cos, 4 * NX * NY * NZ * DNI_cos * 2e-1), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(status.Nf, 0);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-6), 1);
- CHECK(eq_eps(status.SE, std, 1e-3), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-6), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-3), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -161,27 +161,27 @@ main(int argc, char** argv)
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);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m1, std1);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m1, std1);
#define DNI_cos (1000 * cos(0))
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);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(status.Nf, 0);
CHECK(GET_RCV_STATUS(estimator, target1, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target1) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m1, 1e-8), 1);
- CHECK(eq_eps(status.SE, std1, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target1) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m1, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std1, 1e-4), 1);
CHECK(GET_RCV_STATUS(estimator, target2, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target2) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m2, 1e-8), 1);
- CHECK(eq_eps(status.SE, std2, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target2) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m2, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std2, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -152,21 +152,21 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &m, &std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nP = %g +/- %g\n", m, std);
+ logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
#define DNI_cos (1000 * cos(0))
CHECK(eq_eps(m, 400 * DNI_cos, 20), 1);
CHECK(eq_eps(std, 0, 1), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Shadows = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, 0, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Missing = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, 0, 1e-4), 1);
CHECK(status.Nf, 0);
CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, &status), RES_OK);
- logger_print(&logger, LOG_OUTPUT, "P(target) = %g +/- %g", status.E, status.SE);
- CHECK(eq_eps(status.E, m, 1e-8), 1);
- CHECK(eq_eps(status.SE, std, 1e-4), 1);
+ logger_print(&logger, LOG_OUTPUT, "Ir(target) = %g +/- %g", status.irradiance.E, status.irradiance.SE);
+ CHECK(eq_eps(status.irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(status.irradiance.SE, std, 1e-4), 1);
#undef GET_STATUS
#undef GET_RCV_STATUS
