float
__ieee754_atanhf (float x)
{
float xa = fabsf (x);
float t;
if (isless (xa, 0.5f))
{
if (__builtin_expect (xa < 0x1.0p-28f, 0))
{
math_force_eval (huge + x);
return x;
}
t = xa + xa;
t = 0.5f * __log1pf (t + t * xa / (1.0f - xa));
}
else if (__builtin_expect (isless (xa, 1.0f), 1))
t = 0.5f * __log1pf ((xa + xa) / (1.0f - xa));
else
{
if (isgreater (xa, 1.0f))
return (x - x) / (x - x);
return x / 0.0f;
}
return __copysignf (t, x);
}
double
__ieee754_atanh (double x)
{
double xa = fabs (x);
double t;
if (isless (xa, 0.5))
{
if (__glibc_unlikely (xa < 0x1.0p-28))
{
math_force_eval (huge + x);
math_check_force_underflow (x);
return x;
}
t = xa + xa;
t = 0.5 * __log1p (t + t * xa / (1.0 - xa));
}
else if (__glibc_likely (isless (xa, 1.0)))
t = 0.5 * __log1p ((xa + xa) / (1.0 - xa));
else
{
if (isgreater (xa, 1.0))
return (x - x) / (x - x);
return x / 0.0;
}
return __copysign (t, x);
}
double
__ieee754_atanh (double x)
{
double xa = fabs (x);
double t;
if (isless (xa, 0.5))
{
if (__builtin_expect (xa < 0x1.0p-28, 0))
{
math_force_eval (huge + x);
return x;
}
t = xa + xa;
t = 0.5 * __log1p (t + t * xa / (1.0 - xa));
}
else if (__builtin_expect (isless (xa, 1.0), 1))
t = 0.5 * __log1p ((xa + xa) / (1.0 - xa));
else
{
if (isgreater (xa, 1.0))
return (x - x) / (x - x);
return x / 0.0;
}
return __copysign (t, x);
}
float
__ieee754_atanhf (float x)
{
float xa = fabsf (x);
float t;
if (isless (xa, 0.5f))
{
if (__glibc_unlikely (xa < 0x1.0p-28f))
{
math_force_eval (huge + x);
if (fabsf (x) < FLT_MIN)
{
float force_underflow = x * x;
math_force_eval (force_underflow);
}
return x;
}
t = xa + xa;
t = 0.5f * __log1pf (t + t * xa / (1.0f - xa));
}
else if (__glibc_likely (isless (xa, 1.0f)))
t = 0.5f * __log1pf ((xa + xa) / (1.0f - xa));
else
{
if (isgreater (xa, 1.0f))
return (x - x) / (x - x);
return x / 0.0f;
}
return __copysignf (t, x);
}
void test_isless()
{
static_assert((std::is_same<decltype(isless((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (long double)0)), bool>::value), "");
assert(isless(-1.0, 0.F) == true);
}
long double
__ieee754_exp2l (long double x)
{
if (__glibc_likely (isless (x, (long double) LDBL_MAX_EXP)))
{
if (__builtin_expect (isgreaterequal (x, (long double) (LDBL_MIN_EXP
- LDBL_MANT_DIG
- 1)), 1))
{
int intx = (int) x;
long double fractx = x - intx;
if (fabsl (fractx) < LDBL_EPSILON / 4.0L)
return __scalbnl (1.0L + fractx, intx);
return __scalbnl (__ieee754_expl (M_LN2l * fractx), intx);
}
else
{
/* Underflow or exact zero. */
if (isinf (x))
return 0;
else
return LDBL_MIN * LDBL_MIN;
}
}
else
/* Infinity, NaN or overflow. */
return LDBL_MAX * x;
}
/**
* Adjusts a value to fit the constraints for a certain variable:
* - If the value is lower than the minimum, use the minimum.
* - If the value is higher than the maximum, use the maximum.
* - If the variable has steps, round the value to the nearest step.
*/
static void CheckValue(variable_t *var, vlc_value_t *val)
{
/* Check that our variable is within the bounds */
switch (var->i_type & VLC_VAR_TYPE)
{
case VLC_VAR_INTEGER:
if (val->i_int < var->min.i_int)
val->i_int = var->min.i_int;
if (val->i_int > var->max.i_int)
val->i_int = var->max.i_int;
if (var->step.i_int != 0 && (val->i_int % var->step.i_int))
{
if (val->i_int > 0)
val->i_int = (val->i_int + (var->step.i_int / 2))
/ var->step.i_int * var->step.i_int;
else
val->i_int = (val->i_int - (var->step.i_int / 2))
/ var->step.i_int * var->step.i_int;
}
break;
case VLC_VAR_FLOAT:
if (isless(val->f_float, var->min.f_float))
val->f_float = var->min.f_float;
if (isgreater(val->f_float, var->max.f_float))
val->f_float = var->max.f_float;
if (var->step.f_float != 0.f)
val->f_float = var->step.f_float
* roundf(val->f_float / var->step.f_float);
break;
}
}
static int
map_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options)
{
struct drange_map_data *mdata = data;
const struct sol_flow_node_type_float_map_options *opts;
SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options, SOL_FLOW_NODE_TYPE_FLOAT_MAP_OPTIONS_API_VERSION, -EINVAL);
opts = (const struct sol_flow_node_type_float_map_options *)options;
mdata->use_input_range = opts->use_input_range;
mdata->input = opts->input_range;
if (!mdata->use_input_range &&
isgreaterequal(mdata->input.min, mdata->input.max)) {
SOL_WRN("Invalid range: input max must to be bigger than min");
return -EINVAL;
}
mdata->output = opts->output_range;
if (isless(mdata->output.min, mdata->output.max)) {
mdata->output_value.min = mdata->output.min;
mdata->output_value.max = mdata->output.max;
} else {
mdata->output_value.max = mdata->output.min;
mdata->output_value.min = mdata->output.max;
}
mdata->output_value.step = opts->output_range.step;
return 0;
}
static inline char *format_value_with_precision_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision) {
if(unlikely(isnan(value) || isinf(value)))
value = 0.0;
char *separator = "";
if(unlikely(isalnum(*units)))
separator = " ";
if(precision < 0) {
int len, lstop = 0, trim_zeros = 1;
calculated_number abs = value;
if(isless(value, 0)) {
lstop = 1;
abs = calculated_number_fabs(value);
}
if(isgreaterequal(abs, 1000)) {
len = snprintfz(value_string, value_string_len, "%0.0" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
trim_zeros = 0;
}
else if(isgreaterequal(abs, 10)) len = snprintfz(value_string, value_string_len, "%0.1" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else if(isgreaterequal(abs, 1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else if(isgreaterequal(abs, 0.1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else if(isgreaterequal(abs, 0.01)) len = snprintfz(value_string, value_string_len, "%0.4" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else if(isgreaterequal(abs, 0.001)) len = snprintfz(value_string, value_string_len, "%0.5" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else if(isgreaterequal(abs, 0.0001)) len = snprintfz(value_string, value_string_len, "%0.6" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
else len = snprintfz(value_string, value_string_len, "%0.7" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
if(unlikely(trim_zeros)) {
int l;
// remove trailing zeros from the decimal part
for(l = len - 1; l > lstop; l--) {
if(likely(value_string[l] == '0')) {
value_string[l] = '\0';
len--;
}
else if(unlikely(value_string[l] == '.')) {
value_string[l] = '\0';
len--;
break;
}
else
break;
}
}
if(unlikely(len <= 0)) len = 1;
snprintfz(&value_string[len], value_string_len - len, "%s%s", separator, units);
}
else {
if(precision > 50) precision = 50;
snprintfz(value_string, value_string_len, "%0.*" LONG_DOUBLE_MODIFIER "%s%s", precision, (LONG_DOUBLE) value, separator, units);
}
return value_string;
}
/* wrapper sqrtf */
float
__sqrtf (float x)
{
if (__builtin_expect (isless (x, 0.0f), 0) && _LIB_VERSION != _IEEE_)
return __kernel_standard_f (x, x, 126); /* sqrt(negative) */
return __ieee754_sqrtf (x);
}
/* wrapper sqrt */
double
__sqrt (double x)
{
if (__builtin_expect (isless (x, 0.0), 0) && _LIB_VERSION != _IEEE_)
return __kernel_standard (x, x, 26); /* sqrt(negative) */
return __ieee754_sqrt (x);
}
/* wrapper acoshf */
float
__acoshf (float x)
{
if (__builtin_expect (isless (x, 1.0f), 0) && _LIB_VERSION != _IEEE_)
/* acosh(x<1) */
return __kernel_standard_f (x, x, 129);
return __ieee754_acoshf (x);
}
void
vtc_expect(struct vtclog *vl,
const char *olhs, const char *lhs,
const char *cmp,
const char *orhs, const char *rhs)
{
vre_t *vre;
const char *error;
int erroroffset;
int i, j, retval = -1;
double fl, fr;
j = lhs == NULL || rhs == NULL;
if (lhs == NULL)
lhs = "<undef>";
if (rhs == NULL)
rhs = "<undef>";
if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) {
vre = VRE_compile(rhs, 0, &error, &erroroffset);
if (vre == NULL)
vtc_fatal(vl, "REGEXP error: %s (@%d) (%s)",
error, erroroffset, rhs);
i = VRE_exec(vre, lhs, strlen(lhs), 0, 0, NULL, 0, 0);
retval = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!');
VRE_free(&vre);
} else if (!strcmp(cmp, "==")) {
retval = strcmp(lhs, rhs) == 0;
} else if (!strcmp(cmp, "!=")) {
retval = strcmp(lhs, rhs) != 0;
} else if (j) {
// fail inequality comparisons if either side is undef'ed
retval = 0;
} else {
fl = VNUM(lhs);
fr = VNUM(rhs);
if (!strcmp(cmp, "<"))
retval = isless(fl, fr);
else if (!strcmp(cmp, ">"))
retval = isgreater(fl, fr);
else if (!strcmp(cmp, "<="))
retval = islessequal(fl, fr);
else if (!strcmp(cmp, ">="))
retval = isgreaterequal(fl, fr);
}
if (retval == -1)
vtc_fatal(vl,
"EXPECT %s (%s) %s %s (%s) test not implemented",
olhs, lhs, cmp, orhs, rhs);
else if (retval == 0)
vtc_fatal(vl, "EXPECT %s (%s) %s \"%s\" failed",
olhs, lhs, cmp, rhs);
else
vtc_log(vl, 4, "EXPECT %s (%s) %s \"%s\" match",
olhs, lhs, cmp, rhs);
}
/* wrapper acosl */
long double
__acoshl (long double x)
{
if (__builtin_expect (isless (x, 1.0L), 0) && _LIB_VERSION != _IEEE_)
/* acosh(x<1) */
return __kernel_standard (x, x, 229);
return __ieee754_acoshl (x);
}
/* wrapper acosh */
double
acosh (double x)
{
#if defined(__UCLIBC_HAS_FENV__)
if (__builtin_expect (isless (x, 1.0), 0) && _LIB_VERSION != _IEEE_)
/* acosh(x<1) */
return __kernel_standard (x, x, 29);
#endif
return __ieee754_acosh (x);
}
SOL_API bool
sol_drange_val_equal(double var0, double var1)
{
double abs_var0, abs_var1, diff;
diff = fabs(var0 - var1);
/* when a or b are close to zero relative error isn't meaningful -
* it handles subnormal case */
if (fpclassify(var0) == FP_ZERO || fpclassify(var1) == FP_ZERO ||
isless(diff, DBL_MIN)) {
return isless(diff, (DBL_EPSILON * DBL_MIN));
}
/* use relative error for other cases */
abs_var0 = fabs(var0);
abs_var1 = fabs(var1);
return isless(diff / fmin((abs_var0 + abs_var1), DBL_MAX), DBL_EPSILON);
}
ISTATUS
TestReflectorAllocate(
_In_ float_t x,
_In_ float_t y,
_In_ float_t z,
_Out_ PREFLECTOR *reflector
)
{
if (isinf(x) || isless(x, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_00;
}
if (isinf(y) || isless(y, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_01;
}
if (isinf(z) || isless(z, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_02;
}
if (reflector == NULL)
{
return ISTATUS_INVALID_ARGUMENT_03;
}
TEST_REFLECTOR test_reflector;
test_reflector.x = x;
test_reflector.y = y;
test_reflector.z = z;
ISTATUS status = ReflectorAllocate(&test_reflector_vtable,
&test_reflector,
sizeof(TEST_REFLECTOR),
alignof(TEST_REFLECTOR),
reflector);
return status;
}
ISTATUS
TestSpectrumAllocate(
_In_ float_t x,
_In_ float_t y,
_In_ float_t z,
_Out_ PSPECTRUM *spectrum
)
{
if (isinf(x) || isless(x, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_00;
}
if (isinf(y) || isless(y, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_01;
}
if (isinf(z) || isless(z, (float_t)0.0))
{
return ISTATUS_INVALID_ARGUMENT_02;
}
if (spectrum == NULL)
{
return ISTATUS_INVALID_ARGUMENT_03;
}
TEST_SPECTRUM test_spectrum;
test_spectrum.x = x;
test_spectrum.y = y;
test_spectrum.z = z;
ISTATUS status = SpectrumAllocate(&test_spectrum_vtable,
&test_spectrum,
sizeof(TEST_SPECTRUM),
alignof(TEST_SPECTRUM),
spectrum);
return status;
}
FLOAT
M_DECL_FUNC (__fmax) (FLOAT x, FLOAT y)
{
if (isgreaterequal (x, y))
return x;
else if (isless (x, y))
return y;
else if (issignaling (x) || issignaling (y))
return x + y;
else
return isnan (y) ? x : y;
}
int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )
{
if (isless(a, b)) {
return float_relation_less;
} else if (a == b) {
return float_relation_equal;
} else if (isgreater(a, b)) {
return float_relation_greater;
} else {
return float_relation_unordered;
}
}
static double
pick_query(Viewer *viewer, EventHandler *ehandler, const double ray_start[3],
const double ray_dir[3])
{
RendererSimTraffic *self = (RendererSimTraffic*) ehandler->user;
if (!ctrans_have_pose (self->ctrans)) return -1;
if (!self->tracks) return -1;
double car_pos[3];
ctrans_local_pos (self->ctrans, car_pos);
vec3d_t rd = { ray_dir[0], ray_dir[1], ray_dir[2] };
geom_vec_normalize_3d (&rd);
double tmin = INFINITY;
for (int i=0; i<self->tracks->ntracks; i++) {
lcmtypes_track_t *vd = &self->tracks->tracks[i];
point3d_t box_size = { vd->size[0], vd->size[1], VEHICLE_HEIGHT };
// transform the ray into object frame
double rs_obj[3] = {
ray_start[0] - vd->pos[0],
ray_start[1] - vd->pos[1],
ray_start[2] - (car_pos[2] + VEHICLE_HEIGHT / 2)
};
double rquat[4];
double zaxis[3] = { 0, 0, 1 };
rot_angle_axis_to_quat (vd->theta, zaxis, rquat);
rot_quat_rotate_rev (rquat, rs_obj);
double rd_obj[3] = { rd.x, rd.y, rd.z };
rot_quat_rotate_rev (rquat, rd_obj);
point3d_t pos = { 0, 0, 0 };
// in object frame, intersection test is easy
double t = geom_ray_axis_aligned_box_intersect_3d (POINT3D(rs_obj),
POINT3D(rd_obj), &pos, &box_size, NULL);
if (isfinite (t) && isless (t, tmin)) {
tmin = t;
self->selected_vehicle_id = vd->id;
}
}
if (isfinite (tmin)) {
return tmin;
}
self->ehandler.hovering = 0;
return -1;
}
extern double
cosmoPk_eval(cosmoPk_t pk, double k)
{
assert(pk != NULL);
assert(isgreater(k, 0.0));
if (isless(k, pk->k[0]))
return pk->P[0] * pow(k / (pk->k[0]), pk->slopeBeforeKmin);
if (isgreater(k, pk->k[pk->numPoints - 1]))
return pk->P[0] * pow(k / (pk->k[pk->numPoints - 1]),
pk->slopeBeyondKmax);
return gsl_spline_eval(pk->spline, k, pk->acc);
}
FLOAT
M_DECL_FUNC (__fminmag) (FLOAT x, FLOAT y)
{
FLOAT ax = M_FABS (x);
FLOAT ay = M_FABS (y);
if (isless (ax, ay))
return x;
else if (isgreater (ax, ay))
return y;
else if (ax == ay)
return x < y ? x : y;
else if (issignaling (x) || issignaling (y))
return x + y;
else
return isnan (y) ? x : y;
}
void FLP32(void) {
const double x = 0;
const double y = 0;
double result;
result = acos(x);
result = atan2(y, x);
result = pow(x, y);
if (((x == 0.f) && islessequal(y, 0)) ||
(isless(x, 0))) {
/* handle domain and range errors */
}
result = pow(x, y);
result = sqrt(x);
printf("%f", result);
}
static int
_constrain(struct sol_drange *value)
{
double val = value->val;
errno = 0;
val -= fmod(value->val - value->min, value->step);
if (errno) {
SOL_WRN("Modulo failed: %f, %f", value->val - value->min, value->step);
return -errno;
}
if (isless(val, value->min)) val = value->min;
if (isgreater(val, value->max)) val = value->max;
value->val = val;
return 0;
}
static int
sqrt_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
double value, result;
int r;
r = sol_flow_packet_get_drange_value(packet, &value);
SOL_INT_CHECK(r, < 0, r);
if (isless(value, 0)) {
SOL_WRN("Number can't be negative");
return -EDOM;
}
result = sqrt(value);
return sol_flow_send_drange_value_packet(node,
SOL_FLOW_NODE_TYPE_FLOAT_SQRT__OUT__OUT, result);
}
static int
angle_set(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
double in_value;
struct servo_motor_data *mdata = data;
int r, pulse_width;
r = sol_flow_packet_get_drange_value(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
if (isless(in_value, 0) || isgreaterequal(in_value, 180)) {
SOL_WRN("Invalid value %f. It must be >= 0 and < 180", in_value);
return -EINVAL;
}
pulse_width = in_value * mdata->duty_cycle_diff / 180 +
mdata->duty_cycle_range.min;
return set_pulse_width(mdata, pulse_width);
}
static void
local_startrunSimparams()
{
io_logging_section(global_io.log, "Setting simulation parameter");
io_logging_subsection(global_io.log, "Information from file");
# ifdef WITH_MPI
if (global_mpi.rank != 0) {
io_logging_msg(global_io.log, INT32_C(4), "Not setting up myself, will receive.");
fflush(NULL);
} else {
# else
{
# endif
int32_t no_timestep;
io_file_get(global_io.log, global_io.file, IO_FILE_GET_BOXSIZE, (void *)&(simu.boxsize));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_OMEGA0, (void *)&(simu.omega0));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_OMEGAL, (void *)&(simu.lambda0));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_PMASS, (void *)&(simu.pmass));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_NOPART, (void *)&(simu.no_part));
# ifdef MULTIMASS
io_file_get(global_io.log, global_io.file, IO_FILE_GET_NOVPART, (void *)&(simu.no_vpart));
# else
simu.no_vpart = (double)(simu.no_part);
# endif
io_file_get(global_io.log, global_io.file, IO_FILE_GET_NOSPECIES, (void *)&(simu.no_species));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_AINITIAL, (void *)&(simu.a_initial));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_DOUBLE, (void *)&(simu.double_precision));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_MMASS, (void *)&(simu.multi_mass));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_MINWEIGHT, (void *)&(simu.min_weight));
io_file_get(global_io.log, global_io.file, IO_FILE_GET_MAXWEIGHT, (void *)&(simu.max_weight));
/* Copy over the information contained in the parameter file */
simu.NGRID_DOM = global_io.params->NGRID_DOM;
simu.NGRID_MIN = simu.NGRID_DOM;
simu.Nth_dom = global_io.params->Nth_dom;
simu.Nth_ref = global_io.params->Nth_ref;
simu.lb_level = global_io.params->lb_level;
//fprintf(stderr,"simu.lb_level=%d global_io.params->lb_level=%d\n",simu.lb_level,global_io.params->lb_level);
simu.MaxGatherRad = global_io.params->MaxGatherRad;
simu.UserDvir = global_io.params->UserDvir;
simu.UseRhoBack = global_io.params->UseRhoBack;
simu.NGRID_MAX = global_io.params->NGRID_MAX;
simu.AHF_MINPART = global_io.params->AHF_MINPART;
simu.AHF_VTUNE = global_io.params->AHF_VTUNE;
simu.GADGET_m2Msunh= global_io.params->GADGET_m2Msunh;
simu.GADGET_l2Mpch = global_io.params->GADGET_l2Mpch;
# ifdef AHF_LRSI
simu.lrsi_beta = global_io.params->lrsi_beta;
simu.lrsi_r_s = global_io.params->lrsi_r_s;
# endif
#if (defined AHFmixHaloIDandSnapID || defined SUSSING2013)
simu.isnap = global_io.params->isnap;
#endif
/* Set quantities given by constants */
# ifdef NP_LIMIT
simu.np_limit = TRUE;
# else
simu.np_limit = FALSE;
# endif
simu.mean_dens = (double) 1.0;
#ifdef MULTIMASS
simu.multi_mass = 1;
#endif
simu.mmfocus = 0;
simu.hydro = 0;
simu.magneto = 0;
/* Set the time unit */
simu.t_unit = 1/H0; // we assume that we only ever deal with
// cosmological simulations...
/* Set derived quantities */
simu.SHIFT = ((double)0.5000000/(double) simu.NGRID_DOM);
simu.z_initial = (double)1.0/simu.a_initial - (double)1.0;
simu.a_final = (double)1.0/((double)1.0 + simu.z_final);
simu.FourPiG = 1.5*simu.omega0;
/* Do some sanity checks */
io_file_get(global_io.log, global_io.file,
IO_FILE_GET_NOTSTEP, (void *)&(no_timestep));
if ( isless(fabs(simu.a_initial-simu.a_final), ZERO) ) {
io_logging_warn(global_io.log, INT32_C(3),
"Since a_initial = %g is equal to "
"a_final = %g, create_timeline will not "
"function correctly, setting "
"a_initial = .1 * a_final = %g",
simu.a_initial, simu.a_final,
simu.a_final / 10.0);
simu.a_initial = simu.a_final / 10.0;
}
if ( simu.a_initial > simu.a_final ) {
io_logging_warn(global_io.log, INT32_C(3),
"Since a_initial = %g is greater than "
"a_final = %g, create_timeline will not "
"function correctly, setting "
"a_initial = 0.001",
simu.a_initial, simu.a_final);
simu.a_initial = 0.001;
simu.z_initial = 1./simu.a_initial - 1.;
}
} /* End of stuff done solely by process 0 */
io_logging_subsection(global_io.log, "Gathering from reading processes");
# ifdef WITH_MPI
io_logging_msg(global_io.log, INT32_C(4), "Broadcast of simulation parameters!");
MPI_Bcast(&simu, sizeof(struct param_simu),
MPI_BYTE,
0,
MPI_COMM_WORLD);
io_logging_msg(global_io.log, INT32_C(4), "Broadcast done.");
# endif
/* Create timeline */
io_logging_subsection(global_io.log, "Local setup");
io_logging_msg(global_io.log, INT32_C(2), "Creating timeline from a = %g to a = %g",
simu.a_initial/10., simu.a_final);
create_timeline(simu.a_initial/10., simu.a_final, &simu.timeline);
io_logging_msg(global_io.log, INT32_C(2), "Timeline created");
/* Set the SFC information */
io_logging_msg(global_io.log, INT32_C(2), "Setting volume boundaries");
# ifdef AHFrestart
if(global_io.params->ic_filetype != IO_FILE_ARES)
{
fprintf(stderr,"AHFrestart only works together with ic_filetype=5\nPlease make sure that your input file is of this type and adjust AHF.input\nExiting now!\n");
exit(0);
}
global_info.minkey = (sfc_key_t)( ((io_ares_t)(global_io.file))->header->minkey);
global_info.maxkey = (sfc_key_t)( ((io_ares_t)(global_io.file))->header->maxkey);
global_info.level = ((io_ares_t)(global_io.file))->header->lb_level;
# else
// global_info.level = LOADBALANCE_DOMAIN_LEVEL;
global_info.level = global_io.params->lb_level;
global_info.minkey = (sfc_key_t)0;
global_info.maxkey = (sfc_key_t)((1<<(3*global_info.level))-1);
# endif
global_info.ctype = SFC_CURVE_HILBERT;
io_logging_msg(global_io.log, INT32_C(2), " minkey: %"SFC_PRIkey, global_info.minkey);
io_logging_msg(global_io.log, INT32_C(2), " maxkey: %"SFC_PRIkey, global_info.maxkey);
io_logging_msg(global_io.log, INT32_C(2), " level : %i", global_info.level);
io_logging_msg(global_io.log, INT32_C(2), " ctype : %s", sfc_curve_typestr(global_info.ctype));
/* Now that we have the timeline, set the time variables */
simu.super_t_initial = calc_super_t(simu.a_initial);
simu.super_t_final = calc_super_t(simu.a_final);
simu.t_initial = calc_t(simu.a_initial);
simu.t_final = calc_t(simu.a_final);
/* FIXME
* Not set or not properly set simu-structure members:
*
* Hydro variables:
* gamma
* omegab
* omegaDM
* f_b
* H_frac
* T_init
* e_init
* med_weight
* l_unit
* m_unit
*
* AHF variable:
* no_halos
*
* Unkown:
* ifdef GAS_PARTICLES: no_gas
* ifdef GADGET: no_stars
*
*/
/* Will use dummy values */
simu.gamma = 0.0;
simu.omegab = 0.0;
simu.omegaDM = simu.omega0;
simu.f_b = 0.0;
simu.H_frac = 0.0;
simu.T_init = 0.0;
simu.B_init = 0.0;
simu.e_init = 0.0;
simu.no_halos = 0;
simu.med_weight = simu.max_weight; // TODO: this is very conservative yet leads to more credible halos
simu.l_unit = 0.0;
simu.m_unit = 0.0;
simu.no_gas = 0;
simu.no_stars = 0;
//# ifdef VERBOSE
/* Be so kind and write everything to the logfile */
io_logging_subsection(global_io.log, "Used simulation parameters");
io_logging_msg(global_io.log, INT32_C(5), "simu.omega0 : %g", simu.omega0);
io_logging_msg(global_io.log, INT32_C(5), "simu.lambda0 : %g", simu.lambda0);
io_logging_msg(global_io.log, INT32_C(5), "simu.boxsize : %g", simu.boxsize);
io_logging_msg(global_io.log, INT32_C(5), "simu.a_initial : %g", simu.a_initial);
io_logging_msg(global_io.log, INT32_C(5), "simu.a_final : %g", simu.a_final);
io_logging_msg(global_io.log, INT32_C(5), "simu.z_initial : %g", simu.z_initial);
io_logging_msg(global_io.log, INT32_C(5), "simu.z_final : %g", simu.z_final);
io_logging_msg(global_io.log, INT32_C(5), "simu.t_initial : %g", simu.t_initial);
io_logging_msg(global_io.log, INT32_C(5), "simu.t_final : %g", simu.t_final);
io_logging_msg(global_io.log, INT32_C(5), "simu.super_t_initial : %g", simu.super_t_initial);
io_logging_msg(global_io.log, INT32_C(5), "simu.super_t_final : %g", simu.super_t_final);
io_logging_msg(global_io.log, INT32_C(5), "simu.mean_dens : %g", simu.mean_dens);
io_logging_msg(global_io.log, INT32_C(5), "simu.FourPiG : %g", simu.FourPiG);
io_logging_msg(global_io.log, INT32_C(5), "simu.pmass : %g", simu.pmass);
io_logging_msg(global_io.log, INT32_C(5), "simu.t_unit : %g", simu.t_unit);
io_logging_msg(global_io.log, INT32_C(5), "simu.gamma : %g", simu.gamma);
io_logging_msg(global_io.log, INT32_C(5), "simu.timeline (ptr) : %p", (void*)&(simu.timeline));
io_logging_msg(global_io.log, INT32_C(5), "simu.no_part : %lu", simu.no_part);
io_logging_msg(global_io.log, INT32_C(5), "simu.no_vpart : %g", simu.no_vpart);
io_logging_msg(global_io.log, INT32_C(5), "simu.no_species : %i", simu.no_species);
io_logging_msg(global_io.log, INT32_C(5), "simu.no_halos : %lu", simu.no_halos);
io_logging_msg(global_io.log, INT32_C(5), "simu.NGRID_DOM : %i", simu.NGRID_DOM);
io_logging_msg(global_io.log, INT32_C(5), "simu.NGRID_MIN : %i", simu.NGRID_MIN);
io_logging_msg(global_io.log, INT32_C(5), "simu.NGRID_MAX : %i", simu.NGRID_MAX);
io_logging_msg(global_io.log, INT32_C(5), "simu.Nth_dom : %g", simu.Nth_dom);
io_logging_msg(global_io.log, INT32_C(5), "simu.Nth_ref : %g", simu.Nth_ref);
io_logging_msg(global_io.log, INT32_C(5), "simu.MaxGatherRad : %g", simu.MaxGatherRad);
io_logging_msg(global_io.log, INT32_C(5), "simu.lb_level : %d", simu.lb_level);
io_logging_msg(global_io.log, INT32_C(5), "simu.min_weight : %g", simu.min_weight);
io_logging_msg(global_io.log, INT32_C(5), "simu.max_weight : %g", simu.max_weight);
io_logging_msg(global_io.log, INT32_C(5), "simu.np_limit : %i", simu.np_limit);
io_logging_msg(global_io.log, INT32_C(5), "simu.mmfocus : %i", simu.mmfocus);
io_logging_msg(global_io.log, INT32_C(5), "simu.multi_mass : %i", simu.multi_mass);
io_logging_msg(global_io.log, INT32_C(5), "simu.double_precision: %i", simu.double_precision);
//# endif /* VERBOSE */
//fprintf(stderr,"simu.lb_level=%d global_io.params->lb_level=%d\n",simu.lb_level,global_io.params->lb_level);
return;
}
static void
local_startrunRetset(double *timecounter,
double *timestep,
int32_t *no_first_timestep)
{
io_logging_subsection(global_io.log, "Setting time counter");
# ifdef WITH_MPI
if (global_mpi.rank == 0) {
# else
{
# endif
double a_current;
io_file_get(global_io.log, global_io.file,
IO_FILE_GET_NOTSTEP, (void *)no_first_timestep);
io_file_get(global_io.log, global_io.file,
IO_FILE_GET_TSTEP, (void *)timestep);
io_file_get(global_io.log, global_io.file,
IO_FILE_GET_A, (void *)&a_current);
*timecounter = calc_super_t(a_current);
}
# ifdef WITH_MPI
MPI_Bcast(timecounter, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(timestep, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(no_first_timestep, 1, MPI_INT, 0, MPI_COMM_WORLD);
# endif
return;
}
static bool
drange_val_less(double var0, double var1)
{
return isless(var0, var1);
}
static int
drange_val_isless(double var0, double var1)
{
return isless(var0, var1);
}
