commit 3edc179c05150e4a212959abcec8c102152f3f91
parent 96de90efe903cc013e85152de6e6d0a4fdeb7335
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Sun, 22 Sep 2019 15:08:15 +0200
Make the code compatible with Star-Schiff 0.4
The geometry distribution now has 2 functions: the first one sample only
the geometry of a soft particle, while the second one sample the scale
factor of its volume.
Diffstat:
5 files changed, 177 insertions(+), 93 deletions(-)
diff --git a/src/schiff.c b/src/schiff.c
@@ -62,11 +62,18 @@ dump_geometries
unsigned itri, ntris;
double volume_scaling;
double dist_scaling;
- res = distrib->sample(rng, shape, &volume_scaling, distrib->context);
+ void* shape_data = NULL;
+ res = distrib->sample(rng, &shape_data, shape, distrib->context);
if(res != RES_OK) {
fprintf(stderr, "Couldn't sample the micro organism geometry.\n");
goto error;
}
+ res = distrib->sample_volume_scaling
+ (rng, shape_data, &volume_scaling, distrib->context);
+ if(res != RES_OK) {
+ fprintf(stderr, "Couldn't sample the volume scaling of the geometry.\n");
+ goto error;
+ }
dist_scaling = pow(volume_scaling, 1.0/3.0);
diff --git a/src/schiff_args.c b/src/schiff_args.c
@@ -92,11 +92,10 @@ print_help(const char* binary)
" -w A[:B]... list of wavelengths in vacuum (expressed in micron) to\n"
" integrate.\n\n");
printf(
-"%s (C) 2015,2016,2019 CNRS. This is free software released under the GNU\n"
-"GPL license, version 3 or later. You are free to change or redistribute it\n"
-"under certain conditions <http://gnu.org/licenses/gpl.html>\n",
- binary);
-
+"Copyright (C) 2015, 2016 CNRS. Copyright (C) 2019 |Meso|Star>. This is free\n"
+"software released under the GNU GPL license, version 3 or later. You are free\n"
+"to change or redistribute it under certain conditions\n"
+"<http://gnu.org/licenses/gpl.html>\n");
}
static int
@@ -171,7 +170,7 @@ parse_wavelengths(const char* str, struct schiff_args* args)
ASSERT(args && str);
/* How many wavelengths are submitted */
- res = cstr_to_list_double(str, NULL, &len, 0);
+ res = cstr_to_list_double(str, ':', NULL, &len, 0);
if(res != RES_OK) goto error;
/* Reserve the wavelengths memory space */
@@ -179,7 +178,7 @@ parse_wavelengths(const char* str, struct schiff_args* args)
args->wavelengths = sa_add(args->wavelengths, len);
/* Read the wavelengths */
- res = cstr_to_list_double(optarg, args->wavelengths, NULL, len);
+ res = cstr_to_list_double(optarg, ':', args->wavelengths, NULL, len);
if(res != RES_OK) goto error;
/* Check the validity of read wavelengths */
@@ -1298,7 +1297,7 @@ static res_T
parse_yaml
(const char* filename,
struct schiff_geometry** out_geoms,
- struct ssp_ran_discrete** out_ran)
+ struct ssp_ranst_discrete** out_ran)
{
yaml_parser_t parser;
yaml_document_t doc;
@@ -1307,7 +1306,7 @@ parse_yaml
size_t idistrib;
struct schiff_geometry* geoms = NULL;
double* probas = NULL;
- struct ssp_ran_discrete* ran = NULL;
+ struct ssp_ranst_discrete* ran = NULL;
FILE* file = NULL;
int doc_is_init = 0;
res_T res = RES_OK;
@@ -1377,7 +1376,7 @@ parse_yaml
}
/* Create the geometry distribution random variate */
- res = ssp_ran_discrete_create(&mem_default_allocator, &ran);
+ res = ssp_ranst_discrete_create(&mem_default_allocator, &ran);
if(res != RES_OK) {
log_err(filename, root,
"couldn't allocate the random variate of geometry distributions.\n");
@@ -1411,7 +1410,7 @@ parse_yaml
}
/* Setup the geometry distributions random variate */
- res = ssp_ran_discrete_setup(ran, probas, ndistribs);
+ res = ssp_ranst_discrete_setup(ran, probas, ndistribs);
if(res != RES_OK) {
log_err(filename, root,
"couldn't setup the discrete geometry distributions.\n");
@@ -1428,7 +1427,7 @@ exit:
return res;
error:
if(ran) {
- SSP(ran_discrete_ref_put(ran));
+ SSP(ranst_discrete_ref_put(ran));
ran = NULL;
}
if(geoms) {
@@ -1599,7 +1598,7 @@ schiff_args_release(struct schiff_args* args)
count = sa_size(args->geoms);
FOR_EACH(i, 0, count) geometry_release(&args->geoms[i]);
sa_release(args->geoms);
- if(args->ran_geoms) SSP(ran_discrete_ref_put(args->ran_geoms));
+ if(args->ran_geoms) SSP(ranst_discrete_ref_put(args->ran_geoms));
args->geoms = NULL;
*args = SCHIFF_ARGS_NULL;
}
diff --git a/src/schiff_args.h b/src/schiff_args.h
@@ -32,7 +32,7 @@ struct schiff_args {
/* List of parsed geometry distribution parameters and its associated random
* variate */
struct schiff_geometry* geoms;
- struct ssp_ran_discrete* ran_geoms;
+ struct ssp_ranst_discrete* ran_geoms;
unsigned ngeoms_dump; /* # sampled geometries to dump */
unsigned nrealisations; /* # realisation */
diff --git a/src/schiff_geometry.c b/src/schiff_geometry.c
@@ -93,7 +93,7 @@ struct shape {
struct geometry_distribution_context {
struct schiff_optical_properties* properties; /* Per wavelength properties */
struct shape* shapes; /* List of shapes */
- struct ssp_ran_discrete* ran_geometries; /* Geometries random variates */
+ struct ssp_ranst_discrete* ran_geometries; /* Geometries random variates */
};
/*******************************************************************************
@@ -320,25 +320,23 @@ compute_s3d_shape_volume
(struct s3d_device* s3d, struct s3d_shape* shape, double* out_volume)
{
struct s3d_scene* scn = NULL;
+ struct s3d_scene_view* view = NULL;
float volume = 0.f;
- int mask;
res_T res = RES_OK;
ASSERT(s3d && shape && out_volume);
if(RES_OK != (res = s3d_scene_create(s3d, &scn))) goto error;
if(RES_OK != (res = s3d_scene_attach_shape(scn, shape))) goto error;
- if(RES_OK != (res = s3d_scene_begin_session(scn, S3D_TRACE))) goto error;
- if(RES_OK != (res = s3d_scene_compute_volume(scn, &volume))) goto error;
- S3D(scene_end_session(scn));
+ if(RES_OK != (res = s3d_scene_view_create(scn, 0, &view))) goto error;
+ if(RES_OK != (res = s3d_scene_view_compute_volume(view, &volume))) goto error;
exit:
if(scn) S3D(scene_ref_put(scn));
+ if(view) S3D(scene_view_ref_put(view));
/* The volume may be negative if the faces are not correctly oriented */
*out_volume = absf(volume);
return res;
error:
- S3D(scene_get_session_mask(scn, &mask));
- if(mask) S3D(scene_end_session(scn));
goto exit;
}
@@ -422,14 +420,12 @@ static res_T
shape_cylinder_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
struct s3d_vertex_data attrib;
struct mesh_context ctx;
size_t nverts, nprims;
- ASSERT(shape && volume_scaling);
- ASSERT(shape->geometry->type == SCHIFF_CYLINDER);
+ ASSERT(shape && shape->geometry->type == SCHIFF_CYLINDER);
ctx.type = SCHIFF_CYLINDER;
ctx.mesh = &shape->mesh;
@@ -445,7 +441,6 @@ shape_cylinder_generate_s3d_shape
nverts = darray_float_size_get(&shape->mesh.vertices.cartesian) / 3/*#coords*/;
nprims = darray_uint_size_get(&shape->mesh.indices) / 3/*#indices per prim*/;
- *volume_scaling = 1.0;
return s3d_mesh_setup_indexed_vertices(s3d_shape, (unsigned)nprims,
geometry_get_indices, (unsigned)nverts, &attrib, 1, &ctx);
}
@@ -454,9 +449,19 @@ static res_T
shape_cylinder_as_sphere_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
+ ASSERT(shape && shape->geometry->type == SCHIFF_CYLINDER_AS_SPHERE);
+ (void)rng;
+ return s3d_mesh_copy(shape->shape, s3d_shape);
+}
+
+static res_T
+shape_cylinder_as_sphere_sample_volume_scaling
+ (const struct shape* shape,
+ struct ssp_rng* rng,
+ double* volume_scaling)
+{
double radius, sphere_volume;
ASSERT(shape && volume_scaling);
ASSERT(shape->geometry->type == SCHIFF_CYLINDER_AS_SPHERE);
@@ -464,7 +469,7 @@ shape_cylinder_as_sphere_generate_s3d_shape
radius = eval_param(&shape->geometry->data.cylinder.radius_sphere, rng);
sphere_volume = 4.0/3.0 * PI * radius*radius*radius;
*volume_scaling = sphere_volume / shape->volume;
- return s3d_mesh_copy(shape->shape, s3d_shape);
+ return RES_OK;
}
static res_T
@@ -541,15 +546,13 @@ static res_T
shape_ellipsoid_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
struct s3d_vertex_data attrib;
struct mesh_context ctx;
size_t nverts, nprims;
double a, b, c, a2, b2, c2;
- ASSERT(shape && volume_scaling);
- ASSERT(shape->geometry->type == SCHIFF_ELLIPSOID);
+ ASSERT(shape && shape->geometry->type == SCHIFF_ELLIPSOID);
ctx.type = SCHIFF_ELLIPSOID;
ctx.mesh = &shape->mesh;
@@ -575,7 +578,6 @@ shape_ellipsoid_generate_s3d_shape
nverts = darray_uint_size_get(&shape->mesh.vertices.polar) / 2/*#theta/phi*/;
nprims = darray_uint_size_get(&shape->mesh.indices) / 3/*#indices*/;
- *volume_scaling = 1.0;
return s3d_mesh_setup_indexed_vertices(s3d_shape, (unsigned)nprims,
geometry_get_indices, (unsigned)nverts, &attrib, 1, &ctx);
}
@@ -584,9 +586,19 @@ static res_T
shape_ellipsoid_as_sphere_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
+ ASSERT(shape && shape->geometry->type == SCHIFF_ELLIPSOID_AS_SPHERE);
+ (void)rng;
+ return s3d_mesh_copy(shape->shape, s3d_shape);
+}
+
+static res_T
+shape_ellipsoid_as_sphere_sample_volume_scaling
+ (const struct shape* shape,
+ struct ssp_rng* rng,
+ double* volume_scaling)
+{
double radius, sphere_volume;
ASSERT(shape && volume_scaling);
ASSERT(shape->geometry->type == SCHIFF_ELLIPSOID_AS_SPHERE);
@@ -594,7 +606,7 @@ shape_ellipsoid_as_sphere_generate_s3d_shape
radius = eval_param(&shape->geometry->data.ellipsoid.radius_sphere, rng);
sphere_volume = 4.0/3.0 * PI * radius*radius*radius;
*volume_scaling = sphere_volume / shape->volume;
- return s3d_mesh_copy(shape->shape, s3d_shape);
+ return RES_OK;
}
static res_T
@@ -678,7 +690,6 @@ static res_T
shape_helical_pipe_generate_s3d_shape
(struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
const struct schiff_helical_pipe* helical_pipe;
@@ -688,9 +699,7 @@ shape_helical_pipe_generate_s3d_shape
size_t nprims, nverts;
double pitch, height, hradius, cradius;
res_T res = RES_OK;
-
- ASSERT(shape && volume_scaling);
- ASSERT(shape->geometry->type == SCHIFF_HELICAL_PIPE);
+ ASSERT(shape && shape->geometry->type == SCHIFF_HELICAL_PIPE);
helical_pipe = &shape->geometry->data.helical_pipe;
@@ -719,8 +728,6 @@ shape_helical_pipe_generate_s3d_shape
helical_pipe_get_indices, (unsigned)nverts, &attrib, 1, &ctx);
if(res != RES_OK) goto error;
- *volume_scaling = 1.0;
-
exit:
if(vertices) {
schiff_mesh_helical_pipe_destroy_vertices(&shape->mesh, vertices);
@@ -732,11 +739,21 @@ error:
static res_T
shape_helical_pipe_as_sphere_generate_s3d_shape
- (const struct shape* shape,
+ (struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
+ ASSERT(shape && shape->geometry->type == SCHIFF_HELICAL_PIPE_AS_SPHERE);
+ (void)rng;
+ return s3d_mesh_copy(shape->shape, s3d_shape);
+}
+
+static res_T
+shape_helical_pipe_as_sphere_sample_volume_scaling
+ (const struct shape* shape,
+ struct ssp_rng* rng,
+ double* volume_scaling)
+{
double radius, sphere_volume;
ASSERT(shape && volume_scaling);
ASSERT(shape->geometry->type == SCHIFF_HELICAL_PIPE_AS_SPHERE);
@@ -744,7 +761,7 @@ shape_helical_pipe_as_sphere_generate_s3d_shape
radius = eval_param(&shape->geometry->data.helical_pipe.radius_sphere, rng);
sphere_volume = 4.0/3.0 * PI * radius*radius*radius;
*volume_scaling = sphere_volume / shape->volume;
- return s3d_mesh_copy(shape->shape, s3d_shape);
+ return RES_OK;
}
static res_T
@@ -805,9 +822,19 @@ static res_T
shape_sphere_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
+ ASSERT(shape && shape->geometry->type == SCHIFF_SPHERE);
+ (void)rng;
+ return s3d_mesh_copy(shape->shape, s3d_shape);
+}
+
+static res_T
+shape_sphere_sample_volume_scaling
+ (const struct shape* shape,
+ struct ssp_rng* rng,
+ double* volume_scaling)
+{
double radius, sphere_volume;
ASSERT(shape && volume_scaling);
ASSERT(shape->geometry->type == SCHIFF_SPHERE);
@@ -815,7 +842,7 @@ shape_sphere_generate_s3d_shape
radius = eval_param(&shape->geometry->data.sphere.radius, rng);
sphere_volume = 4.0/3.0 * PI * radius*radius*radius;
*volume_scaling = sphere_volume / shape->volume;
- return s3d_mesh_copy(shape->shape, s3d_shape);
+ return RES_OK;
}
static res_T
@@ -886,7 +913,6 @@ static res_T
shape_supershape_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
const struct schiff_supershape* sshape;
@@ -894,8 +920,7 @@ shape_supershape_generate_s3d_shape
struct s3d_vertex_data attrib;
size_t nverts, nprims;
int iform, iattr;
- ASSERT(shape && volume_scaling);
- ASSERT(shape->geometry->type == SCHIFF_SUPERSHAPE);
+ ASSERT(shape && shape->geometry->type == SCHIFF_SUPERSHAPE);
sshape = &shape->geometry->data.supershape;
ctx.mesh = &shape->mesh;
@@ -914,7 +939,6 @@ shape_supershape_generate_s3d_shape
nverts = darray_uint_size_get(&shape->mesh.vertices.polar) / 2/*#theta/phi*/;
nprims = darray_uint_size_get(&shape->mesh.indices) / 3/*#indices*/;
- *volume_scaling = 1.0;
return s3d_mesh_setup_indexed_vertices(s3d_shape, (unsigned)nprims,
geometry_get_indices, (unsigned)nverts, &attrib, 1, &ctx);
}
@@ -923,9 +947,19 @@ static res_T
shape_supershape_as_sphere_generate_s3d_shape
(const struct shape* shape,
struct ssp_rng* rng,
- double* volume_scaling,
struct s3d_shape* s3d_shape)
{
+ ASSERT(shape && shape->geometry->type == SCHIFF_SUPERSHAPE_AS_SPHERE);
+ (void)rng;
+ return s3d_mesh_copy(shape->shape, s3d_shape);
+}
+
+static res_T
+shape_supershape_as_sphere_sample_volume_scaling
+ (const struct shape* shape,
+ struct ssp_rng* rng,
+ double* volume_scaling)
+{
double radius, sphere_volume;
ASSERT(shape && volume_scaling);
ASSERT(shape->geometry->type == SCHIFF_SUPERSHAPE_AS_SPHERE);
@@ -933,65 +967,107 @@ shape_supershape_as_sphere_generate_s3d_shape
radius = eval_param(&shape->geometry->data.supershape.radius_sphere, rng);
sphere_volume = 4.0/3.0 * PI * radius*radius*radius;
*volume_scaling = sphere_volume / shape->volume;
- return s3d_mesh_copy(shape->shape, s3d_shape);
+ return RES_OK;
}
static res_T
-geometry_sample
+geometry_sample_shape
(struct ssp_rng* rng,
+ void** shape_data,
struct s3d_shape* s3d_shape,
- double* volume_scaling,
void* ctx)
{
struct geometry_distribution_context* distrib = ctx;
struct shape* shape;
size_t isamp;
res_T res = RES_OK;
- ASSERT(rng && ctx);
+ ASSERT(rng && shape_data && ctx);
- isamp = ssp_ran_discrete(rng, distrib->ran_geometries);
+ isamp = ssp_ranst_discrete_get(rng, distrib->ran_geometries);
shape = distrib->shapes + isamp;
switch(shape->geometry->type) {
case SCHIFF_ELLIPSOID:
- res = shape_ellipsoid_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_ellipsoid_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_ELLIPSOID_AS_SPHERE:
- res = shape_ellipsoid_as_sphere_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_ellipsoid_as_sphere_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_CYLINDER:
- res = shape_cylinder_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_cylinder_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_CYLINDER_AS_SPHERE:
- res = shape_cylinder_as_sphere_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_cylinder_as_sphere_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_HELICAL_PIPE:
- res = shape_helical_pipe_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_helical_pipe_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_HELICAL_PIPE_AS_SPHERE:
- res = shape_helical_pipe_as_sphere_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_helical_pipe_as_sphere_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_SPHERE:
- res = shape_sphere_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_sphere_generate_s3d_shape(shape, rng, s3d_shape);
break;
case SCHIFF_SUPERSHAPE:
- res = shape_supershape_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_supershape_generate_s3d_shape(shape, rng, s3d_shape);
+ break;
+ case SCHIFF_SUPERSHAPE_AS_SPHERE:
+ res = shape_supershape_as_sphere_generate_s3d_shape(shape, rng, s3d_shape);
+ break;
+ default: FATAL("Unreachable code.\n"); break;
+ }
+ if(res != RES_OK) goto error;
+
+exit:
+ *shape_data = shape;
+ return res;
+error:
+ goto exit;
+}
+
+static res_T
+geometry_sample_volume_scaling
+ (struct ssp_rng* rng,
+ void* shape_data,
+ double* volume_scaling,
+ void* ctx)
+{
+ struct shape* shape = shape_data;
+ res_T res = RES_OK;
+ ASSERT(rng && shape_data && volume_scaling && ctx);
+ (void)ctx;
+
+ switch(shape->geometry->type) {
+ case SCHIFF_ELLIPSOID:
+ case SCHIFF_CYLINDER:
+ case SCHIFF_HELICAL_PIPE:
+ case SCHIFF_SUPERSHAPE:
+ *volume_scaling = 1;
+ break;
+ case SCHIFF_ELLIPSOID_AS_SPHERE:
+ res = shape_ellipsoid_as_sphere_sample_volume_scaling
+ (shape, rng, volume_scaling);
+ break;
+ case SCHIFF_CYLINDER_AS_SPHERE:
+ res = shape_cylinder_as_sphere_sample_volume_scaling
+ (shape, rng, volume_scaling);
+ break;
+ case SCHIFF_HELICAL_PIPE_AS_SPHERE:
+ res = shape_helical_pipe_as_sphere_sample_volume_scaling
+ (shape, rng, volume_scaling);
+ break;
+ case SCHIFF_SPHERE:
+ res = shape_sphere_sample_volume_scaling
+ (shape, rng, volume_scaling);
break;
case SCHIFF_SUPERSHAPE_AS_SPHERE:
- res = shape_supershape_as_sphere_generate_s3d_shape
- (shape, rng, volume_scaling, s3d_shape);
+ res = shape_supershape_as_sphere_sample_volume_scaling
+ (shape, rng, volume_scaling);
break;
default: FATAL("Unreachable code.\n"); break;
}
if(res != RES_OK) goto error;
+ ASSERT(*volume_scaling > 0);
exit:
return res;
@@ -1019,7 +1095,7 @@ schiff_geometry_distribution_release
sa_release(ctx->shapes);
}
if(ctx->ran_geometries)
- SSP(ran_discrete_ref_put(ctx->ran_geometries));
+ SSP(ranst_discrete_ref_put(ctx->ran_geometries));
mem_rm(ctx);
}
@@ -1030,7 +1106,7 @@ schiff_geometry_distribution_init
const struct schiff_geometry* geoms,
const size_t ngeoms,
const double characteristic_length,
- struct ssp_ran_discrete* ran_geoms,
+ struct ssp_ranst_discrete* ran_geoms,
struct schiff_optical_properties* properties)
{
struct geometry_distribution_context* ctx = NULL;
@@ -1090,12 +1166,13 @@ schiff_geometry_distribution_init
}
}
ctx->properties = properties;
- SSP(ran_discrete_ref_get(ran_geoms));
+ SSP(ranst_discrete_ref_get(ran_geoms));
ctx->ran_geometries = ran_geoms;
distrib->material.get_property = get_material_property;
distrib->material.material = properties;
- distrib->sample = geometry_sample;
+ distrib->sample = geometry_sample_shape;
+ distrib->sample_volume_scaling = geometry_sample_volume_scaling;
distrib->characteristic_length = characteristic_length;
exit:
diff --git a/src/schiff_geometry.h b/src/schiff_geometry.h
@@ -126,21 +126,22 @@ struct schiff_supershape {
struct schiff_param radius_sphere;
unsigned nslices;
};
-#define SCHIFF_SUPERSHAPE_DEFAULT__ \
- {{{SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__}, \
- {SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__, \
- SCHIFF_PARAM_DEFAULT__}}, \
- SCHIFF_PARAM_DEFAULT__, \
- 64}
+#define SCHIFF_SUPERSHAPE_DEFAULT__ { \
+ {{SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__}, \
+ {SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__, \
+ SCHIFF_PARAM_DEFAULT__}}, \
+ SCHIFF_PARAM_DEFAULT__, \
+ 64 \
+}
static const struct schiff_supershape SCHIFF_SUPERSHAPE_DEFAULT =
SCHIFF_SUPERSHAPE_DEFAULT__;
@@ -173,7 +174,7 @@ schiff_geometry_distribution_init
const struct schiff_geometry* geometry,
const size_t ngeoms,
const double characteristic_length,
- struct ssp_ran_discrete* ran_geoms,
+ struct ssp_ranst_discrete* ran_geoms,
struct schiff_optical_properties* properties);
extern LOCAL_SYM void
