commit f63ed8d3cd5319492a3b9aeb5ddb0169b133a7a1
parent 5ff64b96d08d358bbcd03a3c95cad9b1cd21d851
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Wed, 15 Feb 2017 11:06:55 +0100
Major refactoring of the ssol_estimator accessors
Replace the ssol_estimator_get_status function by the
ssol_estimator_get_mc_global one that returns all global MC estimations.
Replace the ssol_estimator_get_receiver_status function by the
ssol_estimator_get_mc_receiver one that fills a specific
ssol_mc_receiver structure defining the per receiver MC estimations.
Diffstat:
23 files changed, 456 insertions(+), 647 deletions(-)
diff --git a/src/ssol.h b/src/ssol.h
@@ -253,21 +253,17 @@ struct ssol_mc_result {
double SE; /* Standard error, i.e. sqrt(Expectation / N) */
};
-/* result for MC simulations */
-struct ssol_estimator_status {
- struct ssol_mc_result irradiance;
- struct ssol_mc_result absorptivity_loss;
- struct ssol_mc_result reflectivity_loss;
- struct ssol_mc_result cos_loss;
- size_t N; /* Samples count */
- size_t Nf; /* Failed samples count */
+struct ssol_mc_global {
+ struct ssol_mc_result cos_loss; /* In W */
+ struct ssol_mc_result shadowed; /* In W */
+ struct ssol_mc_result missing; /* In W */
};
-/* the always-ON indicators (MC computations) */
-enum ssol_status_type {
- SSOL_STATUS_SHADOW,
- SSOL_STATUS_MISSING,
- SSOL_STATUS_TYPES_COUNT__
+struct ssol_mc_receiver {
+ struct ssol_mc_result integrated_irradiance; /* In W */
+ struct ssol_mc_result absorptivity_loss; /* In W */
+ struct ssol_mc_result reflectivity_loss; /* In W */
+ struct ssol_mc_result cos_loss; /* In W */
};
typedef res_T
@@ -767,17 +763,16 @@ ssol_estimator_ref_put
(struct ssol_estimator* estimator);
SSOL_API res_T
-ssol_estimator_get_status
+ssol_estimator_get_mc_global
(const struct ssol_estimator* estimator,
- const enum ssol_status_type type,
- struct ssol_estimator_status* status);
+ struct ssol_mc_global* mc_global);
SSOL_API res_T
-ssol_estimator_get_receiver_status
+ssol_estimator_get_mc_receiver
(struct ssol_estimator* estimator,
const struct ssol_instance* instance,
const enum ssol_side_flag side,
- struct ssol_estimator_status* status);
+ struct ssol_mc_receiver* status);
SSOL_API res_T
ssol_estimator_get_count
diff --git a/src/ssol_estimator.c b/src/ssol_estimator.c
@@ -30,19 +30,19 @@
* Helper functions
******************************************************************************/
static res_T
-create_per_receiver_mc_data
+create_mc_receivers
(struct ssol_estimator* estimator,
struct ssol_scene* scene)
{
struct htable_instance_iterator it, end;
- struct mc_per_receiver_data mc_rcv_data_null;
+ struct mc_receiver mc_rcv_null;
res_T res = RES_OK;
ASSERT(scene && estimator);
htable_instance_begin(&scene->instances_rt, &it);
htable_instance_end(&scene->instances_rt, &end);
- mc_per_receiver_data_init(estimator->dev->allocator, &mc_rcv_data_null);
+ mc_receiver_init(estimator->dev->allocator, &mc_rcv_null);
while(!htable_instance_iterator_eq(&it, &end)) {
const struct ssol_instance* inst = *htable_instance_iterator_data_get(&it);
@@ -50,14 +50,13 @@ create_per_receiver_mc_data
if(!inst->receiver_mask) continue;
- res = htable_receiver_set
- (&estimator->global_receivers, &inst, &mc_rcv_data_null);
+ res = htable_receiver_set(&estimator->mc_receivers, &inst, &mc_rcv_null);
if(res != RES_OK) goto error;
}
exit:
return res;
error:
- htable_receiver_clear(&estimator->global_receivers);
+ htable_receiver_clear(&estimator->mc_receivers);
goto exit;
}
@@ -69,7 +68,7 @@ estimator_release(ref_T* ref)
CONTAINER_OF(ref, struct ssol_estimator, ref);
ASSERT(ref);
dev = estimator->dev;
- htable_receiver_release(&estimator->global_receivers);
+ htable_receiver_release(&estimator->mc_receivers);
ASSERT(dev && dev->allocator);
MEM_RM(dev->allocator, estimator);
SSOL(device_ref_put(dev));
@@ -97,71 +96,52 @@ ssol_estimator_ref_put
}
res_T
-ssol_estimator_get_status
+ssol_estimator_get_mc_global
(const struct ssol_estimator* estimator,
- const enum ssol_status_type type,
- struct ssol_estimator_status* status)
+ struct ssol_mc_global* global)
{
- const struct mc_data* data;
- if (!estimator || type >= SSOL_STATUS_TYPES_COUNT__ || !status)
- return RES_BAD_ARG;
-
- switch (type) {
- case SSOL_STATUS_SHADOW: data = &estimator->shadow; break;
- case SSOL_STATUS_MISSING: data = &estimator->missing; break;
- default: FATAL("Unreachable code.\n"); break;
- }
- status->N = estimator->realisation_count;
- status->Nf = estimator->failed_count;
- 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;
- status->cos_loss.E = 0;
- status->cos_loss.V = 0;
- status->cos_loss.SE = 0;
+ 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; \
+ global->Name.SE = global->Name.V > 0 ? sqrt(global->Name.V / N) : 0; \
+ } (void)0
+ SETUP_MC_RESULT(cos_loss);
+ SETUP_MC_RESULT(shadowed);
+ SETUP_MC_RESULT(missing);
+ #undef SETUP_MC_RESULT
return RES_OK;
}
res_T
-ssol_estimator_get_receiver_status
+ssol_estimator_get_mc_receiver
(struct ssol_estimator* estimator,
const struct ssol_instance* instance,
const enum ssol_side_flag side,
- struct ssol_estimator_status* status)
+ struct ssol_mc_receiver* rcv)
{
- const struct mc_per_receiver_1side_data* data = NULL;
- if (!estimator || !instance || !status
+ const struct mc_receiver_1side* mc_rcv1 = NULL;
+ if(!estimator || !instance || !rcv
|| (side != SSOL_BACK && side != SSOL_FRONT))
return RES_BAD_ARG;
/* Check if a receiver is defined for this instance/side */
- data = estimator_get_receiver_data
- (&estimator->global_receivers, instance, side);
- if(data == NULL) return RES_BAD_ARG;
+ mc_rcv1 = estimator_get_mc_receiver(&estimator->mc_receivers, instance, side);
+ if(mc_rcv1 == NULL) return RES_BAD_ARG;
- status->N = estimator->realisation_count;
- status->Nf = estimator->failed_count;
- #define SETUP_MC_STATUS(Name) { \
+ #define SETUP_MC_RESULT(Name) { \
const double N = (double)estimator->realisation_count; \
- status->Name.E = data->Name.weight / N; \
- status->Name.V = data->Name.sqr_weight/N - status->Name.E*status->Name.E; \
- status->Name.SE = status->Name.V > 0 ? sqrt(status->Name.V / N) : 0; \
+ rcv->Name.E = mc_rcv1->Name.weight / N; \
+ rcv->Name.V = mc_rcv1->Name.sqr_weight/N - rcv->Name.E*rcv->Name.E; \
+ rcv->Name.SE = rcv->Name.V > 0 ? sqrt(rcv->Name.V / N) : 0; \
} (void)0
- SETUP_MC_STATUS(irradiance);
- SETUP_MC_STATUS(absorptivity_loss);
- SETUP_MC_STATUS(reflectivity_loss);
- SETUP_MC_STATUS(cos_loss);
- #undef SETUP_MC_STATUS
+ SETUP_MC_RESULT(integrated_irradiance);
+ SETUP_MC_RESULT(absorptivity_loss);
+ SETUP_MC_RESULT(reflectivity_loss);
+ SETUP_MC_RESULT(cos_loss);
+ #undef SETUP_MC_RESULT
return RES_OK;
}
@@ -226,12 +206,12 @@ estimator_create
goto error;
}
- htable_receiver_init(dev->allocator, &estimator->global_receivers);
+ htable_receiver_init(dev->allocator, &estimator->mc_receivers);
SSOL(device_ref_get(dev));
estimator->dev = dev;
ref_init(&estimator->ref);
- res = create_per_receiver_mc_data(estimator, scene);
+ res = create_mc_receivers(estimator, scene);
if(res != RES_OK) goto error;
exit:
diff --git a/src/ssol_estimator_c.h b/src/ssol_estimator_c.h
@@ -1,17 +1,17 @@
/* 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/>. */
+ *
+ * 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/>. */
#ifndef SSOL_ESTIMATOR_C_H
#define SSOL_ESTIMATOR_C_H
@@ -40,40 +40,39 @@ static const struct mc_data MC_DATA_NULL = MC_DATA_NULL__;
#define HTABLE_DATA struct mc_data
#include <rsys/hash_table.h>
-struct mc_per_receiver_1side_data {
- struct mc_data irradiance;
- struct mc_data absorptivity_loss;
- struct mc_data reflectivity_loss;
- struct mc_data cos_loss;
+struct mc_receiver_1side {
+ struct mc_data integrated_irradiance; /* In W */
+ struct mc_data absorptivity_loss; /* In W */
+ struct mc_data reflectivity_loss; /* In W */
+ struct mc_data cos_loss; /* In W */
struct htable_rcvprim prims; /* Per primitive MC */
};
static INLINE void
-mc_per_receiver_1side_data_init
- (struct mem_allocator* allocator, struct mc_per_receiver_1side_data* data)
+mc_receiver_1side_init
+ (struct mem_allocator* allocator, struct mc_receiver_1side* mc)
{
- ASSERT(data);
- data->irradiance = MC_DATA_NULL;
- data->absorptivity_loss = MC_DATA_NULL;
- data->reflectivity_loss = MC_DATA_NULL;
- data->cos_loss = MC_DATA_NULL;
- htable_rcvprim_init(allocator, &data->prims);
+ ASSERT(mc);
+ mc->integrated_irradiance = MC_DATA_NULL;
+ mc->absorptivity_loss = MC_DATA_NULL;
+ mc->reflectivity_loss = MC_DATA_NULL;
+ mc->cos_loss = MC_DATA_NULL;
+ htable_rcvprim_init(allocator, &mc->prims);
}
static INLINE void
-mc_per_receiver_1side_data_release(struct mc_per_receiver_1side_data* data)
+mc_receiver_1side_release(struct mc_receiver_1side* mc)
{
- ASSERT(data);
- htable_rcvprim_release(&data->prims);
+ ASSERT(mc);
+ htable_rcvprim_release(&mc->prims);
}
static INLINE res_T
-mc_per_receiver_1side_data_copy
- (struct mc_per_receiver_1side_data* dst,
- const struct mc_per_receiver_1side_data* src)
+mc_receiver_1side_copy
+ (struct mc_receiver_1side* dst, const struct mc_receiver_1side* src)
{
ASSERT(dst && src);
- dst->irradiance = src->irradiance;
+ dst->integrated_irradiance = src->integrated_irradiance;
dst->absorptivity_loss = src->absorptivity_loss;
dst->reflectivity_loss = src->reflectivity_loss;
dst->cos_loss = src->cos_loss;
@@ -81,12 +80,11 @@ mc_per_receiver_1side_data_copy
}
static INLINE res_T
-mc_per_receiver_1side_data_copy_and_release
- (struct mc_per_receiver_1side_data* dst,
- struct mc_per_receiver_1side_data* src)
+mc_receiver_1side_copy_and_release
+ (struct mc_receiver_1side* dst, struct mc_receiver_1side* src)
{
ASSERT(dst && src);
- dst->irradiance = src->irradiance;
+ dst->integrated_irradiance = src->integrated_irradiance;
dst->absorptivity_loss = src->absorptivity_loss;
dst->reflectivity_loss = src->reflectivity_loss;
dst->cos_loss = src->cos_loss;
@@ -94,18 +92,18 @@ mc_per_receiver_1side_data_copy_and_release
}
static INLINE struct mc_data*
-mc_per_receiver_1side_data_get_primitive_data
- (struct mc_per_receiver_1side_data* data, const unsigned iprim)
+mc_receiver_1side_get_mc_primitive
+ (struct mc_receiver_1side* mc_rcv, const unsigned iprim)
{
struct mc_data* pmc = NULL;
- ASSERT(data);
+ ASSERT(mc_rcv);
- pmc = htable_rcvprim_find(&data->prims, &iprim);
+ pmc = htable_rcvprim_find(&mc_rcv->prims, &iprim);
if(!pmc) {
- struct mc_data mc = MC_DATA_NULL;
- const res_T res = htable_rcvprim_set(&data->prims, &iprim, &mc);
+ struct mc_data mc_prim = MC_DATA_NULL;
+ const res_T res = htable_rcvprim_set(&mc_rcv->prims, &iprim, &mc_prim);
if(res != RES_OK) goto error;
- pmc = htable_rcvprim_find(&data->prims, &iprim);
+ pmc = htable_rcvprim_find(&mc_rcv->prims, &iprim);
}
exit:
@@ -118,52 +116,48 @@ error:
/*******************************************************************************
* Double sided per receiver MC data
******************************************************************************/
-struct mc_per_receiver_data {
- struct mc_per_receiver_1side_data front;
- struct mc_per_receiver_1side_data back;
+struct mc_receiver {
+ struct mc_receiver_1side front;
+ struct mc_receiver_1side back;
};
static INLINE void
-mc_per_receiver_data_init
- (struct mem_allocator* allocator, struct mc_per_receiver_data* data)
+mc_receiver_init(struct mem_allocator* allocator, struct mc_receiver* mc)
{
- ASSERT(data);
- mc_per_receiver_1side_data_init(allocator, &data->front);
- mc_per_receiver_1side_data_init(allocator, &data->back);
+ ASSERT(mc);
+ mc_receiver_1side_init(allocator, &mc->front);
+ mc_receiver_1side_init(allocator, &mc->back);
}
static INLINE void
-mc_per_receiver_data_release(struct mc_per_receiver_data* data)
+mc_receiver_release(struct mc_receiver* mc)
{
- ASSERT(data);
- mc_per_receiver_1side_data_release(&data->front);
- mc_per_receiver_1side_data_release(&data->back);
+ ASSERT(mc);
+ mc_receiver_1side_release(&mc->front);
+ mc_receiver_1side_release(&mc->back);
}
static INLINE res_T
-mc_per_receiver_data_copy
- (struct mc_per_receiver_data* dst,
- const struct mc_per_receiver_data* src)
+mc_receiver_copy(struct mc_receiver* dst, const struct mc_receiver* src)
{
res_T res = RES_OK;
ASSERT(dst && src);
- res = mc_per_receiver_1side_data_copy(&dst->front, &src->front);
+ res = mc_receiver_1side_copy(&dst->front, &src->front);
if(res != RES_OK) return res;
- res = mc_per_receiver_1side_data_copy(&dst->back, &src->back);
+ res = mc_receiver_1side_copy(&dst->back, &src->back);
if(res != RES_OK) return res;
return RES_OK;
}
static INLINE res_T
-mc_per_receiver_data_copy_and_release
- (struct mc_per_receiver_data* dst,
- struct mc_per_receiver_data* src)
+mc_receiver_copy_and_release
+ (struct mc_receiver* dst, struct mc_receiver* src)
{
res_T res = RES_OK;
ASSERT(dst && src);
- res = mc_per_receiver_1side_data_copy_and_release(&dst->front, &src->front);
+ res = mc_receiver_1side_copy_and_release(&dst->front, &src->front);
if(res != RES_OK) return res;
- res = mc_per_receiver_1side_data_copy_and_release(&dst->back, &src->back);
+ res = mc_receiver_1side_copy_and_release(&dst->back, &src->back);
if(res != RES_OK) return res;
return RES_OK;
}
@@ -171,11 +165,11 @@ mc_per_receiver_data_copy_and_release
/* Define the htable_receiver data structure */
#define HTABLE_NAME receiver
#define HTABLE_KEY const struct ssol_instance*
-#define HTABLE_DATA struct mc_per_receiver_data
-#define HTABLE_DATA_FUNCTOR_INIT mc_per_receiver_data_init
-#define HTABLE_DATA_FUNCTOR_RELEASE mc_per_receiver_data_release
-#define HTABLE_DATA_FUNCTOR_COPY mc_per_receiver_data_copy
-#define HTABLE_DATA_FUNCTOR_COPY_AND_RELEASE mc_per_receiver_data_copy_and_release
+#define HTABLE_DATA struct mc_receiver
+#define HTABLE_DATA_FUNCTOR_INIT mc_receiver_init
+#define HTABLE_DATA_FUNCTOR_RELEASE mc_receiver_release
+#define HTABLE_DATA_FUNCTOR_COPY mc_receiver_copy
+#define HTABLE_DATA_FUNCTOR_COPY_AND_RELEASE mc_receiver_copy_and_release
#include <rsys/hash_table.h>
/*******************************************************************************
@@ -184,11 +178,14 @@ mc_per_receiver_data_copy_and_release
struct ssol_estimator {
size_t realisation_count;
size_t failed_count;
- /* the implicit MC computations */
- struct mc_data shadow;
+ /* The implicit MC computations */
+ struct mc_data shadowed;
struct mc_data missing;
- /* 1 global MC per receiver */
- struct htable_receiver global_receivers;
+ struct mc_data cos_loss; /* TODO compute it */
+
+ /* Per receiver MC */
+ struct htable_receiver mc_receivers;
+
/* areas */
double sampled_area, primary_area;
@@ -202,18 +199,19 @@ estimator_create
struct ssol_scene* scene,
struct ssol_estimator** estimator);
-static FINLINE struct mc_per_receiver_1side_data*
-estimator_get_receiver_data
+static FINLINE struct mc_receiver_1side*
+estimator_get_mc_receiver
(struct htable_receiver* receivers,
const struct ssol_instance* instance,
const enum ssol_side_flag side)
{
- struct mc_per_receiver_data* data;
+ struct mc_receiver* mc_rcv;
ASSERT(receivers && instance);
if(!(instance->receiver_mask & (int)side)) return NULL;
- data = htable_receiver_find(receivers, &instance);
- if(!data) return NULL;
- return side == SSOL_FRONT ? &data->front : &data->back;
+ mc_rcv = htable_receiver_find(receivers, &instance);
+ if(!mc_rcv) return NULL;
+ return side == SSOL_FRONT ? &mc_rcv->front : &mc_rcv->back;
}
#endif /* SSOL_ESTIMATOR_C_H */
+
diff --git a/src/ssol_solver.c b/src/ssol_solver.c
@@ -328,6 +328,40 @@ check_scene(const struct ssol_scene* scene, const char* caller)
return RES_OK;
}
+static void
+accum_mc_receivers_1side
+ (struct mc_receiver_1side* dst,
+ struct mc_receiver_1side* src)
+{
+ struct htable_rcvprim_iterator it, end;
+ const struct mc_data* mc_src;
+ struct mc_data* mc_dst;
+ unsigned iprim;
+ ASSERT(dst && src);
+
+ #define ACCUM_WEIGHT(Name) { \
+ dst->Name.weight += src->Name.weight; \
+ dst->Name.sqr_weight += src->Name.sqr_weight; \
+ } (void)0
+ ACCUM_WEIGHT(integrated_irradiance);
+ ACCUM_WEIGHT(absorptivity_loss);
+ ACCUM_WEIGHT(reflectivity_loss);
+ ACCUM_WEIGHT(cos_loss);
+ #undef ACCUM_WEIGHT
+
+ /* Merge the per primitive MC of the integrated irradiance */
+ htable_rcvprim_begin(&src->prims, &it);
+ htable_rcvprim_end(&src->prims, &end);
+ while(!htable_rcvprim_iterator_eq(&it, &end)) {
+ iprim = *htable_rcvprim_iterator_key_get(&it);
+ mc_src = htable_rcvprim_iterator_data_get(&it);
+ mc_dst = mc_receiver_1side_get_mc_primitive(dst, iprim);
+ mc_dst->weight += mc_src->weight;
+ mc_dst->sqr_weight += mc_src->sqr_weight;
+ htable_rcvprim_iterator_next(&it);
+ }
+}
+
/*******************************************************************************
* Exported functions
******************************************************************************/
@@ -350,6 +384,7 @@ ssol_solve
struct ssp_rng_proxy* rng_proxy = NULL;
struct mc_data* mc_shadows = NULL;
struct mc_data* mc_missings = NULL;
+ struct mc_data* mc_cos_losses = NULL; /* TODO compute it */
struct htable_receiver* mc_rcvs = NULL;
struct ssol_estimator* estimator = NULL;
float area;
@@ -409,6 +444,7 @@ ssol_solve
CREATE(bsdfs);
CREATE(mc_shadows);
CREATE(mc_missings);
+ CREATE(mc_cos_losses);
CREATE(mc_rcvs);
#undef CREATE
@@ -419,7 +455,7 @@ ssol_solve
res = ssp_rng_proxy_create_rng(rng_proxy, (size_t)i, rngs + i);
if(res != RES_OK) goto error;
htable_receiver_init(scn->dev->allocator, mc_rcvs + i);
- res = htable_receiver_copy(mc_rcvs + i, &estimator->global_receivers);
+ res = htable_receiver_copy(mc_rcvs + i, &estimator->mc_receivers);
if(res != RES_OK) goto error;
}
@@ -431,6 +467,7 @@ ssol_solve
struct ssf_bsdf* bsdf;
struct mc_data* shadow;
struct mc_data* missing;
+ struct mc_data* cos_loss;
struct htable_receiver* receiver;
float org[3], dir[3], range[2] = { 0, FLT_MAX };
const int ithread = omp_get_thread_num();
@@ -444,6 +481,7 @@ ssol_solve
rng = rngs[ithread];
bsdf = bsdfs[ithread];
shadow = mc_shadows + ithread;
+ cos_loss = mc_cos_losses + ithread;
missing = mc_missings + ithread;
receiver = mc_rcvs + ithread;
@@ -469,32 +507,31 @@ ssol_solve
if(point_is_receiver(&pt)) {
const res_T res_local = point_dump(&pt, (size_t)i, depth, output);
- struct mc_per_receiver_1side_data* data = NULL;
+ struct mc_receiver_1side* mc_rcv1 = NULL;
if(res_local != RES_OK) {
ATOMIC_SET(&res, res_local);
break;
}
- 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;
- data->cos_loss.weight += pt.cos_loss;
- data->cos_loss.sqr_weight += pt.cos_loss * pt.cos_loss;
+ mc_rcv1 = estimator_get_mc_receiver(receiver, pt.inst, pt.side);
+ mc_rcv1->integrated_irradiance.weight += pt.weight;
+ mc_rcv1->integrated_irradiance.sqr_weight += pt.weight*pt.weight;
+ mc_rcv1->absorptivity_loss.weight += pt.absorptivity_loss;
+ mc_rcv1->absorptivity_loss.sqr_weight += pt.absorptivity_loss * pt.absorptivity_loss;
+ mc_rcv1->reflectivity_loss.weight += pt.reflectivity_loss;
+ mc_rcv1->reflectivity_loss.sqr_weight += pt.reflectivity_loss * pt.reflectivity_loss;
+ mc_rcv1->cos_loss.weight += pt.cos_loss;
+ mc_rcv1->cos_loss.sqr_weight += pt.cos_loss * pt.cos_loss;
hit_a_receiver = 1;
if(pt.inst->receiver_per_primitive) {
- struct mc_data* prim = mc_per_receiver_1side_data_get_primitive_data
- (data, pt.prim.prim_id);
- if(!prim) {
+ struct mc_data* mc_prim;
+ mc_prim = mc_receiver_1side_get_mc_primitive(mc_rcv1, pt.prim.prim_id);
+ if(!mc_prim) {
ATOMIC_SET(&res, RES_MEM_ERR);
break;
}
- prim->weight += pt.weight;
- prim->sqr_weight += pt.weight*pt.weight;
+ mc_prim->weight += pt.weight;
+ mc_prim->sqr_weight += pt.weight*pt.weight;
}
}
@@ -555,35 +592,30 @@ ssol_solve
/* Merge per thread estimations */
FOR_EACH(i, 0, nthreads) {
- estimator->shadow.weight += mc_shadows[i].weight;
- estimator->shadow.sqr_weight += mc_shadows[i].sqr_weight;
+ estimator->shadowed.weight += mc_shadows[i].weight;
+ estimator->shadowed.sqr_weight += mc_shadows[i].sqr_weight;
estimator->missing.weight += mc_missings[i].weight;
estimator->missing.sqr_weight += mc_missings[i].sqr_weight;
+ estimator->cos_loss.weight += mc_cos_losses[i].weight;
+ estimator->cos_loss.sqr_weight += mc_cos_losses[i].sqr_weight;
}
- /* Merge per thread estimations */
- htable_receiver_begin(&estimator->global_receivers, &it);
- htable_receiver_end(&estimator->global_receivers, &end);
- while (!htable_receiver_iterator_eq(&it, &end)) {
- struct mc_per_receiver_data* estimator_data
- = htable_receiver_iterator_data_get(&it);
- const struct ssol_instance* key = *htable_receiver_iterator_key_get(&it);
+ /* Merge per thread receiver estimations */
+ htable_receiver_begin(&estimator->mc_receivers, &it);
+ htable_receiver_end(&estimator->mc_receivers, &end);
+ while(!htable_receiver_iterator_eq(&it, &end)) {
+ struct mc_receiver* mc_rcv = htable_receiver_iterator_data_get(&it);
+ const struct ssol_instance* inst = *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_per_receiver_data* thread_data
- = htable_receiver_find(mc_rcvs + i, &key);
- #define ACCUM_WEIGHT(Name) { \
- estimator_data->front.Name.weight += thread_data->front.Name.weight; \
- estimator_data->back.Name.weight += thread_data->front.Name.weight; \
- estimator_data->front.Name.sqr_weight += thread_data->front.Name.sqr_weight;\
- estimator_data->back.Name.sqr_weight += thread_data->front.Name.sqr_weight;\
- } (void)0
- ACCUM_WEIGHT(irradiance);
- ACCUM_WEIGHT(absorptivity_loss);
- ACCUM_WEIGHT(reflectivity_loss);
- ACCUM_WEIGHT(cos_loss);
- #undef ACCUM_WEIGHT
+ struct mc_receiver* mc_rcv_thread;
+ mc_rcv_thread = htable_receiver_find(mc_rcvs + i, &inst);
+
+ if(inst->receiver_mask & (int)SSOL_FRONT)
+ accum_mc_receivers_1side(&mc_rcv->front, &mc_rcv_thread->front);
+ if(inst->receiver_mask & (int)SSOL_BACK)
+ accum_mc_receivers_1side(&mc_rcv->back, &mc_rcv_thread->back);
}
}
estimator->realisation_count += realisations_count;
@@ -609,6 +641,7 @@ exit:
}
sa_release(mc_shadows);
sa_release(mc_missings);
+ sa_release(mc_cos_losses);
if(out_estimator) *out_estimator = estimator;
return (res_T)res;
error:
diff --git a/src/test_ssol_atmosphere.c b/src/test_ssol_atmosphere.c
@@ -16,12 +16,9 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_spectrum* spectrum;
@@ -31,13 +28,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum2), RES_OK);
@@ -64,8 +56,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum2), RES_OK);
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_by_receiver_integration.c b/src/test_ssol_by_receiver_integration.c
@@ -27,7 +27,6 @@
#define HALF_Y 10
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -47,7 +46,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -68,7 +66,7 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator *estimator1, *estimator2;
- struct ssol_estimator_status status;
+ struct ssol_mc_receiver mc_rcv;
double dir[3];
double transform[12]; /* 3x4 column major matrix */
@@ -80,13 +78,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -139,24 +132,24 @@ main(int argc, char** argv)
#define N__ 10000
#define S_DNI_cos (4 * 1000 * cos(PI / 4))
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
+#define GET_RCV_STATUS ssol_estimator_get_mc_receiver
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, "Ir(target) = %g +/- %g",
- status.irradiance.E, status.irradiance.SE);
+ CHECK(GET_RCV_STATUS(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
CHECK(ssol_instance_set_receiver(heliostat, SSOL_FRONT, 0), RES_OK);
- CHECK(eq_eps(status.irradiance.E, S_DNI_cos, S_DNI_cos * 2e-1), 1);
+ CHECK(eq_eps(mc_rcv.integrated_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, "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(GET_RCV_STATUS(estimator2, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_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, "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);
+ CHECK(GET_RCV_STATUS(estimator1, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, S_DNI_cos, S_DNI_cos * 1e-1), 1);
#undef N__
#undef S_DNI_cos
#undef GET_RCV_STATUS
@@ -178,8 +171,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_device.c b/src/test_ssol_device.c
@@ -18,6 +18,14 @@
#include <rsys/logger.h>
+static INLINE void
+log_stream(const char* msg, void* ctx)
+{
+ ASSERT(msg);
+ (void) msg, (void) ctx;
+ printf("%s\n", msg);
+}
+
int
main(int argc, char** argv)
{
diff --git a/src/test_ssol_image.c b/src/test_ssol_image.c
@@ -16,13 +16,10 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
int
main(int argc, char** argv)
{
double block[8/*#rows*/*3/*#channels*/*8/*#column*/];
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_image* img;
@@ -35,13 +32,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_image_create(dev, &img), RES_OK);
@@ -139,11 +131,8 @@ main(int argc, char** argv)
}
CHECK(ssol_image_ref_put(img), RES_OK);
-
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_instance.c b/src/test_ssol_instance.c
@@ -16,12 +16,9 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_shape* shape;
@@ -35,13 +32,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_material_create_virtual(dev, &material), RES_OK);
@@ -85,8 +77,6 @@ main(int argc, char** argv)
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_material.c b/src/test_ssol_material.c
@@ -17,12 +17,9 @@
#include "test_ssol_utils.h"
#include "test_ssol_materials.h"
-#include <rsys/logger.h>
-
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_material* material;
@@ -33,13 +30,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_material_create_mirror(NULL, &material), RES_BAD_ARG);
CHECK(ssol_material_create_mirror(dev, NULL), RES_BAD_ARG);
@@ -109,8 +101,6 @@ main(int argc, char** argv)
CHECK(ssol_material_ref_put(material), RES_OK);
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_object.c b/src/test_ssol_object.c
@@ -16,12 +16,9 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_shape* shape;
@@ -33,13 +30,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_material_create_virtual(dev, &mtl), RES_OK);
CHECK(ssol_material_create_virtual(dev, &mtl2), RES_OK);
CHECK(ssol_shape_create_punched_surface(dev, &shape), RES_OK);
@@ -88,7 +80,6 @@ main(int argc, char** argv)
CHECK(ssol_material_ref_put(mtl2), RES_OK);
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_scene.c b/src/test_ssol_scene.c
@@ -16,8 +16,6 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
static void
get_wlen(const size_t i, double* wlen, double* data, void* ctx)
{
@@ -32,7 +30,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_shape* shape;
@@ -51,13 +48,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_material_create_virtual(dev, &material), RES_OK);
@@ -166,8 +158,6 @@ main(int argc, char** argv)
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_shape.c b/src/test_ssol_shape.c
@@ -21,19 +21,14 @@
#define HALF_Y 1
#include "test_ssol_rect_geometry.h"
-#include <rsys/logger.h>
-
-/*******************************************************************************
- * Test main program
- ******************************************************************************/
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_shape* shape;
- struct ssol_vertex_data attribs[3] = { SSOL_VERTEX_DATA_NULL__, SSOL_VERTEX_DATA_NULL__, SSOL_VERTEX_DATA_NULL__ };
+ struct ssol_vertex_data attribs[3] =
+ {SSOL_VERTEX_DATA_NULL__, SSOL_VERTEX_DATA_NULL__, SSOL_VERTEX_DATA_NULL__};
struct ssol_punched_surface punched_surface = SSOL_PUNCHED_SURFACE_NULL;
struct ssol_carving carving = SSOL_CARVING_NULL;
struct ssol_quadric quadric = SSOL_QUADRIC_DEFAULT;
@@ -45,13 +40,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_shape_create_mesh(NULL, NULL), RES_BAD_ARG);
CHECK(ssol_shape_create_mesh(dev, NULL), RES_BAD_ARG);
@@ -150,11 +140,8 @@ main(int argc, char** argv)
quadric.data.parabolic_cylinder.focal = 1;
CHECK(ssol_shape_ref_put(shape), RES_OK);
-
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver1.c b/src/test_ssol_solver1.c
@@ -22,7 +22,6 @@
#define PLANE_NAME SQUARE
#include "test_ssol_rect_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -47,7 +46,6 @@ int
main(int argc, char** argv)
{
struct spectrum_desc desc = {0};
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -68,7 +66,8 @@ main(int argc, char** argv)
struct ssol_spectrum* abs;
struct ssol_atmosphere* atm;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
double dir[3];
double wavelengths[3] = { 1, 2, 3 };
double intensities[3] = { 1, 0.8, 1 };
@@ -98,13 +97,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
@@ -129,9 +123,7 @@ main(int argc, char** argv)
/* No geometry */
CHECK(ssol_solve(scene, rng, 10, NULL, &estimator), RES_BAD_ARG);
-
/* Create scene content */
-
CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
attribs[0].usage = SSOL_POSITION;
attribs[0].get = get_position;
@@ -177,12 +169,9 @@ main(int argc, char** argv)
CHECK(ssol_estimator_get_failed_count(estimator, &fcount), RES_OK);
CHECK(fcount, 0);
- #define GET_STATUS ssol_estimator_get_status
- CHECK(GET_STATUS(NULL, SSOL_STATUS_MISSING, &status), RES_BAD_ARG);
- CHECK(GET_STATUS(estimator, SSOL_STATUS_TYPES_COUNT__, &status), RES_BAD_ARG);
- CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, NULL), RES_BAD_ARG);
- CHECK(GET_STATUS(estimator, SSOL_STATUS_MISSING, &status), RES_OK);
- #undef GET_STATUS
+ CHECK(ssol_estimator_get_mc_global(NULL, &mc_global), RES_BAD_ARG);
+ CHECK(ssol_estimator_get_mc_global(estimator, NULL), RES_BAD_ARG);
+ CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
CHECK(ssol_estimator_ref_get(NULL), RES_BAD_ARG);
CHECK(ssol_estimator_ref_get(estimator), RES_OK);
@@ -249,8 +238,8 @@ main(int argc, char** argv)
/* Can sample any geometry; variance is high */
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
+#define GET_MC_RCV ssol_estimator_get_mc_receiver
+#define GET_MC_GLOBAL ssol_estimator_get_mc_global
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), RES_OK);
CHECK(ssol_estimator_get_count(estimator, &count), RES_OK);
@@ -259,47 +248,40 @@ 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, "\nIr = %g +/- %g", m, std);
+ printf("Ir = %g +/- %g; ", m, std);
#define COS cos(PI / 4)
-#define DNI 1000
+#define DNI 1000
#define DNI_cos (DNI * COS)
CHECK(eq_eps(m, 4 * DNI_cos, MMAX(4 * DNI_cos * 1e-2, 2*std)), 1);
#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);
/* 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.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.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);
- CHECK(GET_RCV_STATUS(estimator, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, target, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(estimator, target, SSOL_BACK, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, NULL, SSOL_BACK, &status), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(estimator, NULL, SSOL_BACK, &status), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, target, SSOL_BACK, &status), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(estimator, target, SSOL_BACK, &status), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(estimator, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, target, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(estimator, target, SSOL_FRONT, NULL), RES_BAD_ARG);
- CHECK(GET_RCV_STATUS(NULL, NULL, SSOL_FRONT, &status), RES_BAD_ARG);
- 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, "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_get_mc_global(estimator, &mc_global), RES_OK);
+ printf("Shadows = %g +/- %g; ", mc_global.shadowed.E, mc_global.shadowed.SE);
+ printf("Missing = %g +/- %g; ", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, m, 2 * dbl), 1);
+ CHECK(eq_eps(mc_global.missing.E, m, 2*mc_global.missing.SE), 1);
+ CHECK(GET_MC_RCV(NULL, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, NULL, SSOL_BACK, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, target, SSOL_BACK, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_BACK, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, NULL, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, NULL, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, target, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, target, SSOL_FRONT, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, NULL), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, NULL, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, NULL, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(NULL, target, SSOL_FRONT, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Sample primary mirror only; variance is low */
@@ -312,22 +294,19 @@ 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, "\nIr = %g +/- %g", m, std);
+ 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);
- CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- 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.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, "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_get_mc_global(estimator, &mc_global), RES_OK);
+ printf("Shadows = %g +/- %g; ", mc_global.shadowed.E, mc_global.shadowed.SE);
+ printf("Missing = %g +/- %g; ", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Check atmosphere model; with no absorption result is unchanged */
@@ -346,25 +325,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, "\nIr = %g +/- %g", m, std);
+ 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);
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.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.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, "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_get_mc_global(estimator, &mc_global), RES_OK);
+ printf("Shadows = %g +/- %g; ", mc_global.shadowed.E, mc_global.shadowed.SE);
+ printf("Missing = %g +/- %g; ", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
/* Check atmosphere model and imperfect mirror: there are losses */
@@ -396,41 +372,49 @@ main(int argc, char** argv)
CHECK(count, N__);
CHECK(pp_sum(tmp, (int32_t)r_id, count, &a_m, &a_std), RES_OK);
CHECK(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g", a_m, a_std);
+ 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,
+ 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.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.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,
- "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);
- logger_print(&logger, LOG_OUTPUT,
- "Cos Loss(target) = %g +/- %g (%.2g %%)",
- status.cos_loss.E, status.cos_loss.SE, 100 * status.cos_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(eq_eps(status.irradiance.E + status.absorptivity_loss.E
- + status.reflectivity_loss.E + status.cos_loss.E, 4 * DNI, 1e-8), 1);
- CHECK(eq_eps(status.cos_loss.E / (4 * DNI), 1 - COS, 1e-8), 1);
+ CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ printf("Shadows = %g +/- %g; ", mc_global.shadowed.E, mc_global.shadowed.SE);
+ printf("Missing = %g +/- %g\n", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf
+ ("\tIr(target) = %g +/- %g (%.2g %%)\n",
+ mc_rcv.integrated_irradiance.E,
+ mc_rcv.integrated_irradiance.SE,
+ 100 * mc_rcv.integrated_irradiance.E / m);
+ printf
+ ("\tAtmospheric Loss(target) = %g +/- %g (%.2g %%)\n",
+ mc_rcv.absorptivity_loss.E,
+ mc_rcv.absorptivity_loss.SE,
+ 100 * mc_rcv.absorptivity_loss.E / m);
+ printf
+ ("\tReflectivity Loss(target) = %g +/- %g (%.2g %%)\n",
+ mc_rcv.reflectivity_loss.E,
+ mc_rcv.reflectivity_loss.SE,
+ 100 * mc_rcv.reflectivity_loss.E / m);
+ printf
+ ("\tCos Loss(target) = %g +/- %g (%.2g %%)\n",
+ mc_rcv.cos_loss.E,
+ mc_rcv.cos_loss.SE,
+ 100 * mc_rcv.cos_loss.E / m);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, a_m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, a_std, 1e-4), 1);
+ CHECK(eq_eps
+ ( mc_rcv.integrated_irradiance.E
+ + mc_rcv.absorptivity_loss.E
+ + mc_rcv.reflectivity_loss.E, m, 1e-8), 1);
+ CHECK(eq_eps
+ ( mc_rcv.integrated_irradiance.E
+ + mc_rcv.absorptivity_loss.E
+ + mc_rcv.reflectivity_loss.E
+ + mc_rcv.cos_loss.E, 4 * DNI, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.cos_loss.E / (4 * DNI), 1 - COS, 1e-8), 1);
CHECK(ssol_estimator_ref_put(estimator), RES_OK);
CHECK(ssol_scene_detach_instance(scene, heliostat2), RES_OK);
@@ -458,25 +442,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, "\nIr = %g +/- %g", m, std);
+ 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);
- CHECK(GET_STATUS(estimator, SSOL_STATUS_SHADOW, &status), RES_OK);
- 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.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, "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
+ CHECK(ssol_estimator_get_mc_global(estimator, &mc_global), RES_OK);
+ printf("Shadows = %g +/- %g; ", mc_global.shadowed.E, mc_global.shadowed.SE);
+ printf("Missing = %g +/- %g; ", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat2), RES_OK);
@@ -500,8 +479,6 @@ status.irradiance.E, status.irradiance.SE);
CHECK(ssol_sun_ref_put(sun), RES_OK);
CHECK(ssol_sun_ref_put(sun_mono), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver2.c b/src/test_ssol_solver2.c
@@ -32,7 +32,6 @@
#define HALF_Y 1
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -52,7 +51,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -77,7 +75,8 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
double dir[3];
double transform1[12]; /* 3x4 column major matrix */
double transform2[12]; /* 3x4 column major matrix */
@@ -104,13 +103,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -185,38 +179,32 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
+#define GET_MC_RCV ssol_estimator_get_mc_receiver
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), 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(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
+ printf("Ir = %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.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.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, "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, "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, "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, "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
+ 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", mc_global.missing.E, mc_global.missing.SE);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, heliostat1, SSOL_BACK, &mc_rcv), RES_BAD_ARG);
+ CHECK(GET_MC_RCV(estimator, secondary, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(secondary) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(GET_MC_RCV(estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat1), RES_OK);
@@ -238,8 +226,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver2b.c b/src/test_ssol_solver2b.c
@@ -32,7 +32,6 @@
#define HALF_Y 1
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -52,7 +51,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -77,7 +75,8 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
double dir[3];
double transform1[12]; /* 3x4 column major matrix */
double transform2[12]; /* 3x4 column major matrix */
@@ -86,7 +85,6 @@ main(int argc, char** argv)
FILE* tmp;
double m, std;
uint32_t r_id;
-
(void) argc, (void) argv;
d33_splat(transform1, 0);
@@ -104,13 +102,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -122,7 +115,7 @@ main(int argc, char** argv)
CHECK(ssol_scene_create(dev, &scene), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- /* create scene content */
+ /* Create scene content */
CHECK(ssol_shape_create_mesh(dev, &rect), RES_OK);
attribs[0].usage = SSOL_POSITION;
@@ -190,33 +183,31 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 50000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), 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(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
+ printf("Ir = %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.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.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, "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
+ 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);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
+ CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
+ CHECK(count, 0);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat1), RES_OK);
@@ -238,8 +229,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver3.c b/src/test_ssol_solver3.c
@@ -27,7 +27,6 @@
#define HALF_Y 10
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -47,7 +46,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -68,14 +66,14 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
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;
d3_splat(transform + 9, 0);
@@ -84,13 +82,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -144,33 +137,31 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 20000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), 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(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
+ printf("Ir = %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.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.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, "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
+ 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);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
+ CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
+ CHECK(count, 0);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat), RES_OK);
@@ -188,8 +179,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver3N.c b/src/test_ssol_solver3N.c
@@ -27,7 +27,6 @@
#define HALF_Y 1
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -93,7 +92,6 @@ int
main(int argc, char** argv)
{
struct common common;
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -113,7 +111,8 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
double sun_dir[3];
double target_pos[3];
double transform[12]; /* 3x4 column major matrix */
@@ -126,13 +125,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -146,7 +140,7 @@ main(int argc, char** argv)
CHECK(ssol_scene_create(dev, &scene), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- /* create scene content */
+ /* Create scene content */
d3(target_pos, 0, 0, 1000);
@@ -211,33 +205,26 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), 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(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
+ printf("Ir = %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.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.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, "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
+ 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);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-6), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-3), 1);
/* Free data */
CHECK(ssol_instance_ref_put(target), RES_OK);
@@ -254,8 +241,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver4.c b/src/test_ssol_solver4.c
@@ -27,7 +27,6 @@
#define HALF_Y 10
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -47,7 +46,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -69,7 +67,8 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
double dir[3];
double transform[12]; /* 3x4 column major matrix */
size_t count;
@@ -85,13 +84,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -103,7 +97,7 @@ main(int argc, char** argv)
CHECK(ssol_scene_create(dev, &scene), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- /* create scene content */
+ /* Create scene content */
CHECK(ssol_shape_create_mesh(dev, &square), RES_OK);
attribs[0].usage = SSOL_POSITION;
@@ -151,8 +145,7 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
+#define GET_MC_RCV ssol_estimator_get_mc_receiver
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target1, &r_id1), RES_OK);
CHECK(ssol_instance_get_id(target2, &r_id2), RES_OK);
@@ -161,29 +154,29 @@ 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, "\nIr = %g +/- %g\n", m1, std1);
+ printf("Ir = %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.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.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, "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, "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
+ 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);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target1, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target1) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m1, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std1, 1e-4), 1);
+ CHECK(GET_MC_RCV(estimator, target2, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target2) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m2, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std2, 1e-4), 1);
+ CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
+ CHECK(count, 0);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat), RES_OK);
@@ -202,8 +195,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_solver5.c b/src/test_ssol_solver5.c
@@ -27,7 +27,6 @@
#define HALF_Y 10
#include "test_ssol_rect2D_geometry.h"
-#include <rsys/logger.h>
#include <rsys/double33.h>
#include <star/s3d.h>
@@ -47,7 +46,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssp_rng* rng;
@@ -68,15 +66,16 @@ main(int argc, char** argv)
struct ssol_sun* sun;
struct ssol_spectrum* spectrum;
struct ssol_estimator* estimator;
- struct ssol_estimator_status status;
+ struct ssol_mc_global mc_global;
+ struct ssol_mc_receiver mc_rcv;
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
d3_splat(transform + 9, 0);
d33_rotation_pitch(transform, PI); /* flip faces: invert normal */
@@ -84,13 +83,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
@@ -102,7 +96,7 @@ main(int argc, char** argv)
CHECK(ssol_scene_create(dev, &scene), RES_OK);
CHECK(ssol_scene_attach_sun(scene, sun), RES_OK);
- /* create scene content */
+ /* Create scene content */
CHECK(ssol_shape_create_mesh(dev, &rect), RES_OK);
attribs[0].usage = SSOL_POSITION;
@@ -144,34 +138,29 @@ main(int argc, char** argv)
NCHECK(tmp = tmpfile(), 0);
#define N__ 10000
-#define GET_STATUS ssol_estimator_get_status
-#define GET_RCV_STATUS ssol_estimator_get_receiver_status
CHECK(ssol_solve(scene, rng, N__, tmp, &estimator), RES_OK);
CHECK(ssol_instance_get_id(target, &r_id), 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(fclose(tmp), 0);
- logger_print(&logger, LOG_OUTPUT, "\nIr = %g +/- %g\n", m, std);
+ printf("Ir = %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.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.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, "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
+ 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);
+ CHECK(eq_eps(mc_global.shadowed.E, 0, 1e-4), 1);
+ CHECK(eq_eps(mc_global.missing.E, 0, 1e-4), 1);
+ CHECK(ssol_estimator_get_mc_receiver
+ (estimator, target, SSOL_FRONT, &mc_rcv), RES_OK);
+ printf("Ir(target) = %g +/- %g\n",
+ mc_rcv.integrated_irradiance.E, mc_rcv.integrated_irradiance.SE);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.E, m, 1e-8), 1);
+ CHECK(eq_eps(mc_rcv.integrated_irradiance.SE, std, 1e-4), 1);
+ CHECK(ssol_estimator_get_failed_count(estimator, &count), RES_OK);
+ CHECK(count, 0);
/* Free data */
CHECK(ssol_instance_ref_put(heliostat), RES_OK);
@@ -189,8 +178,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum), RES_OK);
CHECK(ssol_sun_ref_put(sun), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_spectrum.c b/src/test_ssol_spectrum.c
@@ -16,8 +16,6 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
-
struct spectrum_desc {
double wavelengths[3];
double data[3];
@@ -41,7 +39,6 @@ get_wlen(const size_t i, double* wlen, double* data, void* ctx)
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_spectrum* spectrum;
@@ -50,13 +47,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_spectrum_create(NULL, &spectrum), RES_BAD_ARG);
CHECK(ssol_spectrum_create(dev, NULL), RES_BAD_ARG);
@@ -90,8 +82,6 @@ main(int argc, char** argv)
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_sun.c b/src/test_ssol_sun.c
@@ -16,13 +16,11 @@
#include "ssol.h"
#include "test_ssol_utils.h"
-#include <rsys/logger.h>
#include <rsys/double3.h>
int
main(int argc, char** argv)
{
- struct logger logger;
struct mem_allocator allocator;
struct ssol_device* dev;
struct ssol_spectrum* spectrum;
@@ -36,13 +34,8 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(logger_init(&allocator, &logger), RES_OK);
- logger_set_stream(&logger, LOG_OUTPUT, log_stream, NULL);
- logger_set_stream(&logger, LOG_ERROR, log_stream, NULL);
- logger_set_stream(&logger, LOG_WARNING, log_stream, NULL);
-
CHECK(ssol_device_create
- (&logger, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
+ (NULL, &allocator, SSOL_NTHREADS_DEFAULT, 0, &dev), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum), RES_OK);
CHECK(ssol_spectrum_create(dev, &spectrum2), RES_OK);
@@ -198,8 +191,6 @@ main(int argc, char** argv)
CHECK(ssol_spectrum_ref_put(spectrum2), RES_OK);
CHECK(ssol_device_ref_put(dev), RES_OK);
- logger_release(&logger);
-
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
CHECK(mem_allocated_size(), 0);
diff --git a/src/test_ssol_utils.h b/src/test_ssol_utils.h
@@ -20,14 +20,6 @@
#include <stdio.h>
static INLINE void
-log_stream(const char* msg, void* ctx)
-{
- ASSERT(msg);
- (void) msg, (void) ctx;
- printf("%s\n", msg);
-}
-
-static INLINE void
check_memory_allocator(struct mem_allocator* allocator)
{
if(MEM_ALLOCATED_SIZE(allocator)) {
