hkl-5.0.0.2569/ 0000755 0001751 0001751 00000000000 13574157101 013124 5 ustar 00picca picca 0000000 0000000 hkl-5.0.0.2569/tests/ 0000755 0001751 0001751 00000000000 13574157075 014300 5 ustar 00picca picca 0000000 0000000 hkl-5.0.0.2569/tests/hkl-pseudoaxis-k4cv-t.c 0000644 0001751 0001751 00000014622 13447477011 020511 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
static void degenerated(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {0, 1, 0};
struct Geometry gconf = K4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes) {
const darray_string *parameters;
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if(n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
params[0] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine,
hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if (geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, 3));
}
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "degenerated");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void eulerians(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double eulerians[] = {0., 90 * HKL_DEGTORAD, 0.};
struct Geometry gconf = K4cv(1.54, 0., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "eulerians", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes){
const darray_string *parameters;
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if(n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
params[0] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine,
eulerians, ARRAY_SIZE(eulerians),
HKL_UNIT_DEFAULT, NULL);
if (geometries) {
const HklGeometryListItem *item;
/* first solution = -180, -90, 180 */
item = hkl_geometry_list_items_first_get(geometries);
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, -180. * HKL_DEGTORAD, -90 * HKL_DEGTORAD, 180. * HKL_DEGTORAD));
/* second solution = 0, 90, 0 */
item = hkl_geometry_list_items_next_get(geometries,item);
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, 0., 90 * HKL_DEGTORAD, 0.));
/* no more solution */
res &= DIAG(hkl_geometry_list_items_next_get(geometries, item) == NULL);
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "eulerians");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void q(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = K4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "q", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.));
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double q;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(q=-1.; q<1.; q += 0.1){
HklGeometryList *geometries = NULL;
geometries = hkl_engine_set_values_v(engine, q, NULL);
if(NULL != geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, q));
}
hkl_geometry_list_free(geometries);
}
}
}
ok(res == TRUE, "q");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
int main(void)
{
plan(3);
degenerated();
eulerians();
q();
return 0;
}
hkl-5.0.0.2569/tests/hkl-parameter-t.c 0000644 0001751 0001751 00000017210 13464522142 017427 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#include "hkl-parameter-private.h"
static void new(void)
{
HklParameter *p;
ok(NULL == hkl_parameter_new("", "", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
ok(NULL == hkl_parameter_new("", "", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
ok(NULL == hkl_parameter_new("", "", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
ok(NULL == hkl_parameter_new("toto", "", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg), __func__);
ok(NULL == hkl_parameter_new("toto", "", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_length_nm), __func__);
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
ok(0 == !p, __func__);
is_double(1., p->range.min, HKL_EPSILON, __func__);
is_double(2., p->_value, HKL_EPSILON, __func__);
is_double(3., p->range.max, HKL_EPSILON, __func__);
ok(FALSE == p->fit, __func__);
ok(TRUE == p->changed, __func__);
ok(&hkl_unit_angle_rad == p->unit, __func__);
ok(&hkl_unit_angle_deg == p->punit, __func__);
hkl_parameter_free(p);
}
static void new_copy(void)
{
HklParameter *copy, *p;
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
copy = hkl_parameter_new_copy(p);
ok(copy->name == p->name, __func__);
ok(copy->description == p->description, __func__);
is_double(copy->range.min, p->range.min, HKL_EPSILON, __func__);
is_double(copy->_value, p->_value, HKL_EPSILON, __func__);
is_double(copy->range.max, p->range.max, HKL_EPSILON, __func__);
ok(copy->fit == p->fit, __func__);
ok(copy->changed == p->changed, __func__);
ok(&hkl_unit_angle_rad == copy->unit, __func__);
ok(&hkl_unit_angle_deg == copy->punit, __func__);
hkl_parameter_free(copy);
hkl_parameter_free(p);
}
static void init(void)
{
HklParameter *p;
int res = TRUE;
res &= DIAG(NULL == hkl_parameter_new("", "no description", 2, NAN, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg));
res &= DIAG(NULL == hkl_parameter_new("", "no description", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg));
res &= DIAG(NULL == hkl_parameter_new("", "no description", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg));
res &= DIAG(NULL == hkl_parameter_new("toto", "no description", 2, 1, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg));
res &= DIAG(NULL == hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_length_nm));
res &= DIAG(NULL == hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_length_nm));
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
res &= DIAG(NULL != p);
hkl_parameter_free(p);
ok(res == TRUE, __func__);
}
static void set(void)
{
HklParameter *p;
GError *error;
int res = TRUE;
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
/* can not set a parameter with a NaN value */
error = NULL;
res &= DIAG(FALSE == hkl_parameter_value_set(p, NAN, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* set a normal value is ok */
error = NULL;
res &= DIAG(TRUE == hkl_parameter_value_set(p, 10, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error == NULL);
hkl_parameter_free(p);
ok(res == TRUE, __func__);
}
static void is_valid(void)
{
HklParameter *p;
GError *error;
int res = TRUE;
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
res &= DIAG(TRUE == hkl_parameter_is_valid(p));
error = NULL;
res &= DIAG(TRUE == hkl_parameter_value_set(p, 10, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error == NULL);
res &= DIAG(FALSE == hkl_parameter_is_valid(p));
hkl_parameter_free(p);
ok(res == TRUE, __func__);
}
static void min_max(void)
{
HklParameter *p;
double min, max;
GError *error;
int res = TRUE;
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1, min, HKL_EPSILON, __func__);
is_double(3, max, HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_min_max_set(p, 1.1, 4, HKL_UNIT_DEFAULT, NULL));
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1.1, min, HKL_EPSILON, __func__);
is_double(4, max, HKL_EPSILON, __func__);
error = NULL;
res &= DIAG(FALSE == hkl_parameter_min_max_set(p, 4, 1, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* nothing should have changed */
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1.1, min, HKL_EPSILON, __func__);
is_double(4, max, HKL_EPSILON, __func__);
error = NULL;
res &= DIAG(FALSE == hkl_parameter_min_max_set(p, NAN, 1, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* nothing should have changed */
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1.1, min, HKL_EPSILON, __func__);
is_double(4, max, HKL_EPSILON, __func__);
error = NULL;
res &= DIAG(FALSE == hkl_parameter_min_max_set(p, 1, NAN, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* nothing should have changed */
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1.1, min, HKL_EPSILON, __func__);
is_double(4, max, HKL_EPSILON, __func__);
error = NULL;
res &= DIAG(FALSE == hkl_parameter_min_max_set(p, NAN, NAN, HKL_UNIT_DEFAULT, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* nothing should have changed */
hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_DEFAULT);
is_double(1.1, min, HKL_EPSILON, __func__);
is_double(4, max, HKL_EPSILON, __func__);
hkl_parameter_free(p);
}
static void getter(void)
{
HklParameter *p;
p = hkl_parameter_new("toto", "no description", 1, 2, 3,
FALSE, TRUE,
&hkl_unit_angle_rad, &hkl_unit_angle_deg);
ok(NULL == hkl_parameter_axis_v_get(p), __func__);
ok(NULL == hkl_parameter_quaternion_get(p), __func__);
ok(NULL != hkl_parameter_description_get(p), __func__);
hkl_parameter_free(p);
}
int main(void)
{
plan(40);
new();
new_copy();
init();
set();
is_valid();
min_max();
getter();
return 0;
}
hkl-5.0.0.2569/tests/hkl-source-t.c 0000644 0001751 0001751 00000004447 13447477011 016764 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include "hkl-source-private.h"
static void new_copy(void)
{
HklSource s, c;
hkl_source_init(&s, 1.54, 1, 0, 0);
c = s;
is_double(c.wave_length, s.wave_length, HKL_EPSILON, __func__);
ok(FALSE == hkl_vector_cmp(&c.direction, &s.direction), __func__);
}
static void init(void)
{
HklSource s;
hkl_source_init(&s, 1, 1, 0, 0);
is_double(1., s.wave_length, HKL_EPSILON, __func__);
is_double(1., s.direction.data[0], HKL_EPSILON, __func__);
is_double(0., s.direction.data[1], HKL_EPSILON, __func__);
is_double(0., s.direction.data[2], HKL_EPSILON, __func__);
}
static void cmp(void)
{
HklSource ref, s1, s2;
hkl_source_init(&ref, 1.54, 1, 0, 0);
hkl_source_init(&s1, 1.54, 1, 0, 0);
hkl_source_init(&s2, 1, 1, 0, 0);
ok(TRUE == hkl_source_cmp(&ref, &s1), __func__);
ok(FALSE == hkl_source_cmp(&ref, &s2), __func__);
}
static void compute_ki(void)
{
HklSource s;
HklVector ki_ref = {{HKL_TAU / 1.54, 0, 0}};
HklVector ki;
hkl_source_init(&s, 1.54, 1, 0, 0);
hkl_source_compute_ki(&s, &ki);
ok(0 == hkl_vector_cmp(&ki_ref, &ki), __func__);
}
static void get_wavelength(void)
{
HklSource s;
hkl_source_init(&s, 1, 1, 0, 0);
is_double(1., hkl_source_get_wavelength(&s), HKL_EPSILON, __func__);
}
int main(void)
{
plan(10);
new_copy();
init();
cmp();
compute_ki();
get_wavelength();
return 0;
}
hkl-5.0.0.2569/tests/hkl-geometry-t.c 0000644 0001751 0001751 00000041537 13447477011 017320 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
/* BEWARE THESE TESTS ARE DEALING WITH HKL INTERNALS WHICH EXPOSE A
* NON PUBLIC API WHICH ALLOW TO SHOOT YOURSELF IN YOUR FOOT */
#include "hkl/ccan/container_of/container_of.h"
#include "hkl-axis-private.h" /* temporary */
#include "hkl-geometry-private.h"
static void add_holder(void)
{
HklGeometry *g = NULL;
HklHolder *holder = NULL;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
is_int(0, darray_size(g->holders), __func__);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_angle_deg);
is_int(1, darray_size(g->holders), __func__);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_angle_deg);
is_int(2, darray_size(g->holders), __func__);
ok(holder == darray_item(g->holders, 1), __func__);
hkl_geometry_free(g);
}
static void get_axis(void)
{
int res = TRUE;
HklGeometry *g = NULL;
HklHolder *holder = NULL;
const HklParameter *axis0;
GError *error;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
/* check the private API */
res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "A"));
res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "B"));
res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "C"));
res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "T"));
res &= DIAG(1 == !hkl_geometry_get_axis_by_name(g, "DONOTEXIST"));
/* check the public API */
/* get */
res &= DIAG(NULL != hkl_geometry_axis_get(g, "A", NULL));
res &= DIAG(NULL == hkl_geometry_axis_get(g, "DONOTEXIST", NULL));
error = NULL;
res &= DIAG(NULL != hkl_geometry_axis_get(g, "A", &error));
res &= DIAG(error == NULL);
res &= DIAG(NULL != hkl_geometry_axis_get(g, "T", &error));
res &= DIAG(error == NULL);
res &= DIAG(NULL == hkl_geometry_axis_get(g, "DONOTEXIST", &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
/* set */
axis0 = hkl_geometry_axis_get(g, "A", NULL);
res &= DIAG(TRUE == hkl_geometry_axis_set(g, "A", axis0, NULL));
res &= DIAG(FALSE == hkl_geometry_axis_set(g, "B", axis0, NULL));
res &= DIAG(FALSE == hkl_geometry_axis_set(g, "T", axis0, NULL));
error = NULL;
res &= DIAG(hkl_geometry_axis_set(g, "A", axis0, &error));
res &= DIAG(error == NULL);
res &= DIAG(FALSE == hkl_geometry_axis_set(g, "B", axis0, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
res &= DIAG(FALSE == hkl_geometry_axis_set(g, "T", axis0, &error));
res &= DIAG(error != NULL);
g_clear_error(&error);
ok(res, __func__);
hkl_geometry_free(g);
}
static void update(void)
{
int res = TRUE;
HklGeometry *g = NULL;
HklHolder *holder = NULL;
HklAxis *axis1;
HklQuaternion q_ref = {{1./sqrt(2), 1./sqrt(2), 0.0, 0.0 }};
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T1", 1., 0., 0., &hkl_unit_length_mm);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T2", 1., 0., 0., &hkl_unit_length_mm);
axis1 = container_of(hkl_geometry_get_axis_by_name(g, "B"), HklAxis, parameter);
res &= DIAG(hkl_parameter_value_set(&axis1->parameter, M_PI_2, HKL_UNIT_DEFAULT, NULL));
/* now axis1 is dirty */
ok(TRUE == axis1->parameter.changed, __func__);
hkl_geometry_update(g);
holder = darray_item(g->holders, 0);
is_quaternion(&q_ref, &holder->q, __func__);
/* now axis1 is clean */
res &= DIAG(FALSE == axis1->parameter.changed);
ok(res, __func__);
hkl_geometry_free(g);
}
static void set(void)
{
HklGeometry *g;
HklGeometry *g1;
HklGeometry *g2;
HklHolder *holder;
HklFactory *fake_factory;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
g1 = hkl_geometry_new_copy(g);
/* it is required to use a fake factory, with the public API
* geometry contain always a real factory */
fake_factory = (HklFactory *)0x1;
g2 = hkl_geometry_new(fake_factory, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
ok(hkl_geometry_set(g, g1), __func__);
hkl_geometry_free(g2);
hkl_geometry_free(g1);
hkl_geometry_free(g);
}
static void axis_values_get_set(void)
{
unsigned int i;
HklGeometry *g;
HklHolder *holder;
static double set_1[] = {1, 1, 1, 1};
static double set_10[] = {10, 10, 10, 10};
double values[4];
GError *error;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
/* check set DEFAULT unit */
error = NULL;
ok(TRUE == hkl_geometry_axis_values_set(g, set_1, ARRAY_SIZE(set_1), HKL_UNIT_DEFAULT, NULL), __func__);
ok(TRUE == hkl_geometry_axis_values_set(g, set_1, ARRAY_SIZE(set_1), HKL_UNIT_DEFAULT, &error), __func__);
ok(error == NULL, __func__);
for(i=0; iaxes, i), HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
/* check get DEFAULT unit */
hkl_geometry_axis_values_get(g, values, ARRAY_SIZE(values), HKL_UNIT_DEFAULT);
for(i=0; iaxes, 0),
-100 * HKL_DEGTORAD, 100 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(FALSE == hkl_geometry_is_valid(geom));
ok(res, __func__);
hkl_geometry_free(geom);
}
static void wavelength(void)
{
HklGeometry *geom = NULL;
GError *error;
geom = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
is_double(1.54, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
ok(TRUE == hkl_geometry_wavelength_set(geom, 2, HKL_UNIT_DEFAULT, NULL), __func__);
is_double(2, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
error = NULL;
ok(TRUE == hkl_geometry_wavelength_set(geom, 2, HKL_UNIT_DEFAULT, &error), __func__);
ok(error == NULL, __func__);
is_double(2, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
hkl_geometry_free(geom);
}
static void xxx_rotation_get(void)
{
int res = TRUE;
size_t i, n;
HklFactory **factories;
HklDetector *detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
HklSample *sample = hkl_sample_new("test");
factories = hkl_factory_get_all(&n);
for(i=0; igeometry->axes, 0), HKL_UNIT_DEFAULT),
HKL_EPSILON, __func__);
}
ok(res, __func__);
hkl_geometry_free(g);
hkl_geometry_list_free(list);
}
static void list_multiply_from_range(void)
{
int res = TRUE;
HklGeometry *g;
HklGeometryList *list;
HklHolder *holder;
HklParameter *axisA, *axisB, *axisC, *axisT;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
axisA = hkl_geometry_get_axis_by_name(g, "A");
axisB = hkl_geometry_get_axis_by_name(g, "B");
axisC = hkl_geometry_get_axis_by_name(g, "C");
axisT = hkl_geometry_get_axis_by_name(g, "T");
res &= DIAG(hkl_parameter_min_max_set(axisA, -190, 190, HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisB, -190, 190, HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisC, -190, 190, HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisT, -190, 190., HKL_UNIT_USER, NULL));
list = hkl_geometry_list_new();
res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
185. * HKL_DEGTORAD, -185. * HKL_DEGTORAD, 190. * HKL_DEGTORAD, 100.));
hkl_geometry_list_add(list, g);
hkl_geometry_list_multiply_from_range(list);
res &= DIAG(8 == hkl_geometry_list_n_items_get(list));
ok(res, __func__);
hkl_geometry_free(g);
hkl_geometry_list_free(list);
}
static void list_remove_invalid(void)
{
int res = TRUE;
HklGeometry *g;
HklGeometryList *list;
HklHolder *holder;
HklParameter *axisA, *axisB, *axisC, *axisT;
g = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(g);
hkl_holder_add_rotation(holder, "A", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "B", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "C", 1., 0., 0., &hkl_unit_angle_deg);
hkl_holder_add_translation(holder, "T", 1., 0., 0., &hkl_unit_length_mm);
axisA = hkl_geometry_get_axis_by_name(g, "A");
axisB = hkl_geometry_get_axis_by_name(g, "B");
axisC = hkl_geometry_get_axis_by_name(g, "C");
axisT = hkl_geometry_get_axis_by_name(g, "T");
res &= DIAG(hkl_parameter_min_max_set(axisA, -100, 180., HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisB, -100., 180., HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisC, -100., 180., HKL_UNIT_USER, NULL));
res &= DIAG(hkl_parameter_min_max_set(axisT, 0.0, 179., HKL_UNIT_USER, NULL));
list = hkl_geometry_list_new();
res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
185. * HKL_DEGTORAD,
-185. * HKL_DEGTORAD,
185. * HKL_DEGTORAD,
0.1));
hkl_geometry_list_add(list, g);
res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
-190. * HKL_DEGTORAD,
-190. * HKL_DEGTORAD,
-190. * HKL_DEGTORAD,
0.1));
hkl_geometry_list_add(list, g);
res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
180. * HKL_DEGTORAD,
180. * HKL_DEGTORAD,
180. * HKL_DEGTORAD,
0.1));
hkl_geometry_list_add(list, g);
is_int(3, hkl_geometry_list_n_items_get(list), __func__);
hkl_geometry_list_remove_invalid(list);
is_int(1, hkl_geometry_list_n_items_get(list), __func__);
ok(res, __func__);
hkl_geometry_free(g);
hkl_geometry_list_free(list);
}
int main(void)
{
plan(48);
add_holder();
get_axis();
update();
set();
axis_values_get_set();
distance();
is_valid();
wavelength();
xxx_rotation_get();
list();
list_multiply_from_range();
list_remove_invalid();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-e6c-t.c 0000644 0001751 0001751 00000036231 13447477011 020317 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include "hkl-axis-private.h" /* temporary */
#define CHECK_AXIS_VALUE(geometry, axis, value) fabs((value) - hkl_parameter_value_get(hkl_geometry_axis_get(geometry, axis, NULL), HKL_UNIT_DEFAULT)) < HKL_EPSILON
static int hkl_geometry_list_check_geometry_unit(const HklGeometryList *self,
double mu,
double omega,
double chi,
double phi,
double gamma,
double delta)
{
const HklGeometryListItem *item;
int res = TRUE;
HKL_GEOMETRY_LIST_FOREACH(item, self){
const HklGeometry *geometry;
geometry = hkl_geometry_list_item_geometry_get(item);
res = TRUE;
res &= CHECK_AXIS_VALUE(geometry, "mu", mu * HKL_DEGTORAD);
res &= CHECK_AXIS_VALUE(geometry, "omega", omega * HKL_DEGTORAD);
res &= CHECK_AXIS_VALUE(geometry, "chi", chi * HKL_DEGTORAD);
res &= CHECK_AXIS_VALUE(geometry, "phi", phi * HKL_DEGTORAD);
res &= CHECK_AXIS_VALUE(geometry, "gamma", gamma * HKL_DEGTORAD);
res &= CHECK_AXIS_VALUE(geometry, "delta", delta * HKL_DEGTORAD);
if (res)
break;
}
return res;
}
static void getter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E6c(1.54, 0., 30., 0., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
/* geometry -> pseudo */
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 30., 0., 0., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., 0., 1.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 30., 0., 90., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 30., 0., -90., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, -1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 30., 0., 180., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., 0., -1.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 45., 0., 135., 0., 90.));
res &= DIAG(check_pseudoaxes_v(engine, 1., 0., -1.));
ok(res == TRUE, "getter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void degenerated(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {0, 0, 1};
struct Geometry gconf = E6c(1.54, 0., 30., 0., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes) {
const darray_string *parameters;
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if (n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
params[0] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine,
hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if (geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, 3));
}
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "degenerated");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void q2(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const char **mode;
const darray_string *modes;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E6c(1.54, 0., 30., 0., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "q2", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double q, alpha;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(q=0.1; q<1.; q += 0.1)
for(alpha = -M_PI; alpha.
*
* Copyright (C) 2010-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
* Oussama Sboui
*/
#include
#include "hkl3d.h"
#include "tap/basic.h"
#include "tap/hkl-tap.h"
#define MODEL_FILENAME "data/diffabs.yaml"
static void check_model_validity(Hkl3D *hkl3d)
{
uint i, j;
uint len;
int res;
Hkl3DObject *obji;
Hkl3DObject *objj;
res = TRUE;
/* imported 1 config files with 7 Hkl3DObjects */
res &= DIAG(hkl3d->config->len == 1);
res &= DIAG(hkl3d->config->models[0]->len == 7);
/* all Hkl3DObjects must have a different axis_name */
len = hkl3d->config->models[0]->len;
for(i=0;iconfig->models[0]->objects[i];
for (j=1; jconfig->models[0]->objects[i+j];
if(!(strcmp(obji->axis_name, objj->axis_name))){
res &= DIAG(FALSE);
break;
}
}
obji++;
}
/* check the _movingObjects validity, all Hkl3DAxis must have a size of 1 */
for(i=0; i<6; ++i)
res &= DIAG(hkl3d->geometry->axes[i]->len == 1);
ok(res == TRUE, "no identical objects");
}
/* check the collision and that the right axes are colliding */
static void check_collision(Hkl3D *hkl3d)
{
char buffer[1000];
int res = TRUE;
double values[] = {23, 0., 0., 0., 0., 0.};
/* check the collision and that the right axes are colliding */
res &= DIAG(hkl_geometry_axis_values_set(hkl3d->geometry->geometry,
values, ARRAY_SIZE(values),
HKL_UNIT_USER, NULL));
res &= DIAG(hkl3d_is_colliding(hkl3d) == TRUE);
strcpy(buffer, "");
/* now check that only delta and mu are colliding */
for(size_t i=0; iconfig->models[0]->len; ++i){
const char *name;
int tmp;
name = hkl3d->config->models[0]->objects[i]->axis_name;
tmp = hkl3d->config->models[0]->objects[i]->is_colliding == TRUE;
/* add the colliding axes to the buffer */
if(tmp){
strcat(buffer, " ");
strcat(buffer, name);
}
if(!strcmp(name, "mu") || !strcmp(name, "delta"))
res &= DIAG(tmp == TRUE);
else
res &= DIAG(tmp == FALSE);
}
ok(res == TRUE, "collision [%s]", buffer);
}
static void check_no_collision(Hkl3D *hkl3d)
{
int res = TRUE;
double i;
/* check that rotating around komega/kappa/kphi do not create collisison */
res &= DIAG(hkl_geometry_set_values_v(hkl3d->geometry->geometry,
HKL_UNIT_USER, NULL,
0., 0., 0., 0., 0., 0.));
/* komega */
for(i=0; i<=360; i=i+10){
double values[] = {0., i, 0., 0., 0., 0.};
res &= DIAG(hkl_geometry_axis_values_set(hkl3d->geometry->geometry,
values, ARRAY_SIZE(values),
HKL_UNIT_USER, NULL));
res &= DIAG(hkl3d_is_colliding(hkl3d) == FALSE);
}
/* kappa */
for(i=0; i<=360; i=i+10){
double values[] = {0., 0., i, 0., 0., 0.};
res &= DIAG(hkl_geometry_axis_values_set(hkl3d->geometry->geometry,
values, ARRAY_SIZE(values),
HKL_UNIT_USER, NULL));
res &= DIAG(hkl3d_is_colliding(hkl3d) == FALSE);
}
/* kphi */
for(i=0; i<=360; i=i+10){
double values[] = {0., 0., 0., i, 0., 0.};
res &= DIAG(hkl_geometry_axis_values_set(hkl3d->geometry->geometry,
values, ARRAY_SIZE(values),
HKL_UNIT_USER, NULL));
res &= DIAG(hkl3d_is_colliding(hkl3d) == FALSE);
}
ok(res == TRUE, "no-collision");
}
int main(void)
{
char* filename;
const HklFactory *factory;
HklGeometry *geometry;
Hkl3D *hkl3d;
factory = hkl_factory_get_by_name("K6C", NULL);
geometry = hkl_factory_create_new_geometry(factory);
/* compute the filename of the diffractometer config file */
filename = test_file_path(MODEL_FILENAME);
hkl3d = hkl3d_new(filename, geometry);
plan(3);
check_model_validity(hkl3d);
check_collision(hkl3d);
check_no_collision(hkl3d);
/* TODO add/remove object*/
hkl3d_free(hkl3d);
test_file_path_free(filename);
hkl_geometry_free(geometry);
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-soleil-sirius-kappa-t.c 0000644 0001751 0001751 00000006040 13447477011 023532 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include
#include
#include
#include "hkl/ccan/generator/generator.h"
#include "hkl-geometry-private.h"
#include "hkl-trajectory-private.h"
/* tests */
static void stability(void)
{
int res = TRUE;
HklGeometryList *solutions;
struct Sample gaas = {
.name = "GaAs",
.lattice = Cubic(5.6533),
.ux = -90.003382 * HKL_DEGTORAD,
.uy = 0.12907 * HKL_DEGTORAD,
.uz = -159.91372 * HKL_DEGTORAD,
};
struct Geometry gconfig = \
SoleilSiriusKappa(1.458637,
-0.5193202, 64.7853160, 133.5621380, -80.9690000, -0.0223369, 30.0000299);
struct Geometry gconfig2 = \
SoleilSiriusKappa(1.458637,
-0.5193202, 64.7853160, 133.5621380, 124.9690000, -0.0223369, 30.0000299);
struct Mode mode = ModeHklBissectorVertical;
/* move between each step */
struct Trajectory tconfig1 = TrajectoryHklFromTo(0, 0, 1, 0, 0, 6, 11, mode);
solutions = Trajectory_solve(tconfig1, gconfig, gaas, TRUE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
solutions = Trajectory_solve(tconfig1, gconfig, gaas, TRUE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
struct Trajectory tconfig2 = TrajectoryHklFromTo(0, 0, 1, 0, 0, 6, 101, mode);
solutions = Trajectory_solve(tconfig2, gconfig, gaas, TRUE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
solutions = Trajectory_solve(tconfig2, gconfig2, gaas, TRUE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
/* do not move between each steps */
solutions = Trajectory_solve(tconfig1, gconfig, gaas, FALSE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
solutions = Trajectory_solve(tconfig1, gconfig, gaas, FALSE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
solutions = Trajectory_solve(tconfig2, gconfig, gaas, FALSE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
solutions = Trajectory_solve(tconfig2, gconfig2, gaas, FALSE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
ok(res == TRUE, __func__);
}
int main(void)
{
plan(1);
stability();
return 0;
}
hkl-5.0.0.2569/tests/tap/ 0000755 0001751 0001751 00000000000 13574157075 015064 5 ustar 00picca picca 0000000 0000000 hkl-5.0.0.2569/tests/tap/hkl-tap.c 0000644 0001751 0001751 00000010775 13175570520 016571 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2012 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include
#include "basic.h"
#include "hkl-tap.h"
#include "hkl/hkl-matrix-private.h"
#include "hkl/hkl-macros-private.h"
#include "hkl/hkl-pseudoaxis-private.h"
void is_quaternion(const HklQuaternion *wanted, const HklQuaternion *seen, const char *format, ...)
{
va_list args;
va_start(args, format);
fflush(stderr);
if(TRUE == hkl_quaternion_cmp(wanted, seen))
okv(1, format, args);
else{
printf("# wanted: %g %g %g %g\n",
wanted->data[0], wanted->data[1], wanted->data[2], wanted->data[3]);
printf("# seen: %g %g %g %g\n",
seen->data[0], seen->data[1], seen->data[2], wanted->data[3]);
okv(0, format, args);
}
}
void is_matrix(const HklMatrix *wanted, const HklMatrix *seen, const char *format, ...)
{
va_list args;
va_start(args, format);
fflush(stderr);
if(TRUE == hkl_matrix_cmp(wanted, seen))
okv(1, format, args);
else{
printf("# wanted: %g %g %g\n# : %g %g %g\n# : %g %g %g\n",
wanted->data[0][0], wanted->data[0][1], wanted->data[0][2],
wanted->data[1][0], wanted->data[1][1], wanted->data[1][2],
wanted->data[2][0], wanted->data[2][1], wanted->data[2][2]);
printf("# seen: %g %g %g\n# : %g %g %g\n# : %g %g %g\n",
seen->data[0][0], seen->data[0][1], seen->data[0][2],
seen->data[1][0], seen->data[1][1], seen->data[1][2],
seen->data[2][0], seen->data[2][1], seen->data[2][2]);
okv(0, format, args);
}
}
int check_pseudoaxes_v(HklEngine *engine, ...)
{
uint i;
va_list ap;
unsigned int len = hkl_engine_len(engine);
double values[len];
/* extract the variable part of the method */
va_start(ap, engine);
for(i=0; ipseudo_axes, i);
hkl_parameter_randomize(parameter);
values[i] = hkl_parameter_value_get(parameter, unit_type);
}
}
/**
* hkl_tap_engine_parameters_randomize: (skip)
* @self: the this ptr
*
* randomize all the parameters of the #HklEngine
**/
void hkl_tap_engine_parameters_randomize(HklEngine *self)
{
HklParameter **parameter;
darray_foreach(parameter, self->mode->parameters){
hkl_parameter_randomize(*parameter);
}
}
hkl-5.0.0.2569/tests/tap/basic.h 0000644 0001751 0001751 00000015442 13435016332 016306 0 ustar 00picca picca 0000000 0000000 /*
* Basic utility routines for the TAP protocol.
*
* This file is part of C TAP Harness. The current version plus supporting
* documentation is at .
*
* Copyright 2009, 2010, 2011, 2012, 2013, 2014, 2015
* Russ Allbery
* Copyright 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2011, 2012, 2014
* The Board of Trustees of the Leland Stanford Junior University
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef TAP_BASIC_H
#define TAP_BASIC_H 1
#include
#include /* va_list */
#include /* size_t */
/*
* Used for iterating through arrays. ARRAY_SIZE returns the number of
* elements in the array (useful for a < upper bound in a for loop) and
* ARRAY_END returns a pointer to the element past the end (ISO C99 makes it
* legal to refer to such a pointer as long as it's never dereferenced).
*/
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
#define ARRAY_END(array) (&(array)[ARRAY_SIZE(array)])
BEGIN_DECLS
/*
* The test count. Always contains the number that will be used for the next
* test status.
*/
extern unsigned long testnum;
/* Print out the number of tests and set standard output to line buffered. */
void plan(unsigned long count);
/*
* Prepare for lazy planning, in which the plan will be printed automatically
* at the end of the test program.
*/
void plan_lazy(void);
/* Skip the entire test suite. Call instead of plan. */
void skip_all(const char *format, ...)
__attribute__((__noreturn__, __format__(printf, 1, 2)));
/*
* Basic reporting functions. The okv() function is the same as ok() but
* takes the test description as a va_list to make it easier to reuse the
* reporting infrastructure when writing new tests. ok() and okv() return the
* value of the success argument.
*/
int ok(int success, const char *format, ...)
__attribute__((__format__(printf, 2, 3)));
int okv(int success, const char *format, va_list args)
__attribute__((__format__(printf, 2, 0)));
void skip(const char *reason, ...)
__attribute__((__format__(printf, 1, 2)));
/*
* Report the same status on, or skip, the next count tests. ok_block()
* returns the value of the success argument.
*/
int ok_block(unsigned long count, int success, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
void skip_block(unsigned long count, const char *reason, ...)
__attribute__((__format__(printf, 2, 3)));
/*
* Check an expected value against a seen value. Returns true if the test
* passes and false if it fails.
*/
int is_int(long wanted, long seen, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
int is_string(const char *wanted, const char *seen, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
int is_hex(unsigned long wanted, unsigned long seen, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
/* Bail out with an error. sysbail appends strerror(errno). */
void bail(const char *format, ...)
__attribute__((__noreturn__, __nonnull__, __format__(printf, 1, 2)));
void sysbail(const char *format, ...)
__attribute__((__noreturn__, __nonnull__, __format__(printf, 1, 2)));
/* Report a diagnostic to stderr prefixed with #. */
int diag(const char *format, ...)
__attribute__((__nonnull__, __format__(printf, 1, 2)));
int sysdiag(const char *format, ...)
__attribute__((__nonnull__, __format__(printf, 1, 2)));
/*
* Register or unregister a file that contains supplementary diagnostics.
* Before any other output, all registered files will be read, line by line,
* and each line will be reported as a diagnostic as if it were passed to
* diag(). Nul characters are not supported in these files and will result in
* truncated output.
*/
void diag_file_add(const char *file)
__attribute__((__nonnull__));
void diag_file_remove(const char *file)
__attribute__((__nonnull__));
/* Allocate memory, reporting a fatal error with bail on failure. */
void *bcalloc(size_t, size_t)
__attribute__((__alloc_size__(1, 2), __malloc__, __warn_unused_result__));
void *bmalloc(size_t)
__attribute__((__alloc_size__(1), __malloc__, __warn_unused_result__));
void *breallocarray(void *, size_t, size_t)
__attribute__((__alloc_size__(2, 3), __malloc__, __warn_unused_result__));
void *brealloc(void *, size_t)
__attribute__((__alloc_size__(2), __malloc__, __warn_unused_result__));
char *bstrdup(const char *)
__attribute__((__malloc__, __nonnull__, __warn_unused_result__));
char *bstrndup(const char *, size_t)
__attribute__((__malloc__, __nonnull__, __warn_unused_result__));
/*
* Find a test file under BUILD or SOURCE, returning the full path. The
* returned path should be freed with test_file_path_free().
*/
char *test_file_path(const char *file)
__attribute__((__malloc__, __nonnull__, __warn_unused_result__));
void test_file_path_free(char *path);
/*
* Create a temporary directory relative to BUILD and return the path. The
* returned path should be freed with test_tmpdir_free.
*/
char *test_tmpdir(void)
__attribute__((__malloc__, __warn_unused_result__));
void test_tmpdir_free(char *path);
/*
* Register a cleanup function that is called when testing ends. All such
* registered functions will be run during atexit handling (and are therefore
* subject to all the same constraints and caveats as atexit functions).
*
* The function must return void and will be passed two arguments: an int that
* will be true if the test completed successfully and false otherwise, and an
* int that will be true if the cleanup function is run in the primary process
* (the one that called plan or plan_lazy) and false otherwise.
*/
typedef void (*test_cleanup_func)(int, int);
void test_cleanup_register(test_cleanup_func)
__attribute__((__nonnull__));
END_DECLS
#endif /* TAP_BASIC_H */
hkl-5.0.0.2569/tests/tap/macros.h 0000644 0001751 0001751 00000007365 13175414511 016520 0 ustar 00picca picca 0000000 0000000 /*
* Helpful macros for TAP header files.
*
* This is not, strictly speaking, related to TAP, but any TAP add-on is
* probably going to need these macros, so define them in one place so that
* everyone can pull them in.
*
* This file is part of C TAP Harness. The current version plus supporting
* documentation is at .
*
* Copyright 2008, 2012, 2013, 2015 Russ Allbery
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef TAP_MACROS_H
#define TAP_MACROS_H 1
/*
* __attribute__ is available in gcc 2.5 and later, but only with gcc 2.7
* could you use the __format__ form of the attributes, which is what we use
* (to avoid confusion with other macros), and only with gcc 2.96 can you use
* the attribute __malloc__. 2.96 is very old, so don't bother trying to get
* the other attributes to work with GCC versions between 2.7 and 2.96.
*/
#ifndef __attribute__
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
# define __attribute__(spec) /* empty */
# endif
#endif
/*
* We use __alloc_size__, but it was only available in fairly recent versions
* of GCC. Suppress warnings about the unknown attribute if GCC is too old.
* We know that we're GCC at this point, so we can use the GCC variadic macro
* extension, which will still work with versions of GCC too old to have C99
* variadic macro support.
*/
#if !defined(__attribute__) && !defined(__alloc_size__)
# if defined(__GNUC__) && !defined(__clang__)
# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
# define __alloc_size__(spec, args...) /* empty */
# endif
# endif
#endif
/* Suppress __warn_unused_result__ if gcc is too old. */
#if !defined(__attribute__) && !defined(__warn_unused_result__)
# if __GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4)
# define __warn_unused_result__ /* empty */
# endif
#endif
/*
* LLVM and Clang pretend to be GCC but don't support all of the __attribute__
* settings that GCC does. For them, suppress warnings about unknown
* attributes on declarations. This unfortunately will affect the entire
* compilation context, but there's no push and pop available.
*/
#if !defined(__attribute__) && (defined(__llvm__) || defined(__clang__))
# pragma GCC diagnostic ignored "-Wattributes"
#endif
/* Used for unused parameters to silence gcc warnings. */
#define UNUSED __attribute__((__unused__))
/*
* BEGIN_DECLS is used at the beginning of declarations so that C++
* compilers don't mangle their names. END_DECLS is used at the end.
*/
#undef BEGIN_DECLS
#undef END_DECLS
#ifdef __cplusplus
# define BEGIN_DECLS extern "C" {
# define END_DECLS }
#else
# define BEGIN_DECLS /* empty */
# define END_DECLS /* empty */
#endif
#endif /* TAP_MACROS_H */
hkl-5.0.0.2569/tests/tap/Makefile.am 0000644 0001751 0001751 00000000620 13175414511 017102 0 ustar 00picca picca 0000000 0000000 AM_CFLAGS = \
-I$(top_srcdir) \
-I$(abs_top_srcdir)/tests \
$(GLIB_CFLAGS) \
$(GSL_CFLAGS)
check_LIBRARIES = libtap.a
libtap_a_SOURCES = \
basic.c \
basic.h \
float.h \
float.c \
macros.h \
hkl-tap.h \
hkl-tap.c
# Support for GNU Flymake, in Emacs.
check-syntax: AM_CFLAGS += -fsyntax-only -pipe
check-syntax:
test -z "$(CHK_SOURCES)" || $(COMPILE) $(CHK_SOURCES)
.PHONY: check-syntax
hkl-5.0.0.2569/tests/tap/basic.c 0000644 0001751 0001751 00000055001 13175570520 016301 0 ustar 00picca picca 0000000 0000000 /*
* Some utility routines for writing tests.
*
* Here are a variety of utility routines for writing tests compatible with
* the TAP protocol. All routines of the form ok() or is*() take a test
* number and some number of appropriate arguments, check to be sure the
* results match the expected output using the arguments, and print out
* something appropriate for that test number. Other utility routines help in
* constructing more complex tests, skipping tests, reporting errors, setting
* up the TAP output format, or finding things in the test environment.
*
* This file is part of C TAP Harness. The current version plus supporting
* documentation is at .
*
* Copyright 2009, 2010, 2011, 2012, 2013, 2014, 2015
* Russ Allbery
* Copyright 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2011, 2012, 2013, 2014
* The Board of Trustees of the Leland Stanford Junior University
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include
#include
#include
#include
#include
#include
#ifdef _WIN32
# include
#else
# include
#endif
#include
#include
#include
/* Windows provides mkdir and rmdir under different names. */
#ifdef _WIN32
# define mkdir(p, m) _mkdir(p)
# define rmdir(p) _rmdir(p)
#endif
/*
* The test count. Always contains the number that will be used for the next
* test status. This is exported to callers of the library.
*/
unsigned long testnum = 1;
/*
* Status information stored so that we can give a test summary at the end of
* the test case. We store the planned final test and the count of failures.
* We can get the highest test count from testnum.
*/
static unsigned long _planned = 0;
static unsigned long _failed = 0;
/*
* Store the PID of the process that called plan() and only summarize
* results when that process exits, so as to not misreport results in forked
* processes.
*/
static pid_t _process = 0;
/*
* If true, we're doing lazy planning and will print out the plan based on the
* last test number at the end of testing.
*/
static int _lazy = 0;
/*
* If true, the test was aborted by calling bail(). Currently, this is only
* used to ensure that we pass a false value to any cleanup functions even if
* all tests to that point have passed.
*/
static int _aborted = 0;
/*
* Registered cleanup functions. These are stored as a linked list and run in
* registered order by finish when the test program exits. Each function is
* passed a boolean value indicating whether all tests were successful.
*/
struct cleanup_func {
test_cleanup_func func;
struct cleanup_func *next;
};
static struct cleanup_func *cleanup_funcs = NULL;
/*
* Registered diag files. Any output found in these files will be printed out
* as if it were passed to diag() before any other output we do. This allows
* background processes to log to a file and have that output interleaved with
* the test output.
*/
struct diag_file {
char *name;
FILE *file;
char *buffer;
size_t bufsize;
struct diag_file *next;
};
static struct diag_file *diag_files = NULL;
/*
* Print a specified prefix and then the test description. Handles turning
* the argument list into a va_args structure suitable for passing to
* print_desc, which has to be done in a macro. Assumes that format is the
* argument immediately before the variadic arguments.
*/
#define PRINT_DESC(prefix, format) \
do { \
if (format != NULL) { \
va_list args; \
if (prefix != NULL) \
printf("%s", prefix); \
va_start(args, format); \
vprintf(format, args); \
va_end(args); \
} \
} while (0)
/*
* Form a new string by concatenating multiple strings. The arguments must be
* terminated by (const char *) 0.
*
* This function only exists because we can't assume asprintf. We can't
* simulate asprintf with snprintf because we're only assuming SUSv3, which
* does not require that snprintf with a NULL buffer return the required
* length. When those constraints are relaxed, this should be ripped out and
* replaced with asprintf or a more trivial replacement with snprintf.
*/
static char *
concat(const char *first, ...)
{
va_list args;
char *result;
const char *string;
size_t offset;
size_t length = 0;
/*
* Find the total memory required. Ensure we don't overflow length. See
* the comment for breallocarray for why we're using UINT_MAX here.
*/
va_start(args, first);
for (string = first; string != NULL; string = va_arg(args, const char *)) {
if (length >= UINT_MAX - strlen(string))
bail("strings too long in concat");
length += strlen(string);
}
va_end(args);
length++;
/* Create the string. */
result = bmalloc(length);
va_start(args, first);
offset = 0;
for (string = first; string != NULL; string = va_arg(args, const char *)) {
memcpy(result + offset, string, strlen(string));
offset += strlen(string);
}
va_end(args);
result[offset] = '\0';
return result;
}
/*
* Check all registered diag_files for any output. We only print out the
* output if we see a complete line; otherwise, we wait for the next newline.
*/
static void
check_diag_files(void)
{
struct diag_file *file;
fpos_t where;
size_t length;
int size, incomplete;
/*
* Walk through each file and read each line of output available. The
* general scheme here used is as follows: try to read a line of output at
* a time. If we get NULL, check for EOF; on EOF, advance to the next
* file.
*
* If we get some data, see if it ends in a newline. If it doesn't end in
* a newline, we have one of two cases: our buffer isn't large enough, in
* which case we resize it and try again, or we have incomplete data in
* the file, in which case we rewind the file and will try again next
* time.
*/
for (file = diag_files; file != NULL; file = file->next) {
clearerr(file->file);
/* Store the current position in case we have to rewind. */
if (fgetpos(file->file, &where) < 0)
sysbail("cannot get position in %s", file->name);
/* Continue until we get EOF or an incomplete line of data. */
incomplete = 0;
while (!feof(file->file) && !incomplete) {
size = file->bufsize > INT_MAX ? INT_MAX : (int) file->bufsize;
if (fgets(file->buffer, size, file->file) == NULL) {
if (ferror(file->file))
sysbail("cannot read from %s", file->name);
continue;
}
/*
* See if the line ends in a newline. If not, see which error
* case we have. Use UINT_MAX as a substitute for SIZE_MAX (see
* the comment for breallocarray).
*/
length = strlen(file->buffer);
if (file->buffer[length - 1] != '\n') {
if (length < file->bufsize - 1)
incomplete = 1;
else {
if (file->bufsize >= UINT_MAX - BUFSIZ)
sysbail("line too long in %s", file->name);
file->bufsize += BUFSIZ;
file->buffer = brealloc(file->buffer, file->bufsize);
}
/*
* On either incomplete lines or too small of a buffer, rewind
* and read the file again (on the next pass, if incomplete).
* It's simpler than trying to double-buffer the file.
*/
if (fsetpos(file->file, &where) < 0)
sysbail("cannot set position in %s", file->name);
continue;
}
/* We saw a complete line. Print it out. */
printf("# %s", file->buffer);
}
}
}
/*
* Our exit handler. Called on completion of the test to report a summary of
* results provided we're still in the original process. This also handles
* printing out the plan if we used plan_lazy(), although that's suppressed if
* we never ran a test (due to an early bail, for example), and running any
* registered cleanup functions.
*/
static void
finish(void)
{
int success, primary;
struct cleanup_func *current;
unsigned long highest = testnum - 1;
struct diag_file *file, *tmp;
/* Check for pending diag_file output. */
check_diag_files();
/* Free the diag_files. */
file = diag_files;
while (file != NULL) {
tmp = file;
file = file->next;
fclose(tmp->file);
free(tmp->name);
free(tmp->buffer);
free(tmp);
}
diag_files = NULL;
/*
* Determine whether all tests were successful, which is needed before
* calling cleanup functions since we pass that fact to the functions.
*/
if (_planned == 0 && _lazy)
_planned = highest;
success = (!_aborted && _planned == highest && _failed == 0);
/*
* If there are any registered cleanup functions, we run those first. We
* always run them, even if we didn't run a test. Don't do anything
* except free the diag_files and call cleanup functions if we aren't the
* primary process (the process in which plan or plan_lazy was called),
* and tell the cleanup functions that fact.
*/
primary = (_process == 0 || getpid() == _process);
while (cleanup_funcs != NULL) {
cleanup_funcs->func(success, primary);
current = cleanup_funcs;
cleanup_funcs = cleanup_funcs->next;
free(current);
}
if (!primary)
return;
/* Don't do anything further if we never planned a test. */
if (_planned == 0)
return;
/* If we're aborting due to bail, don't print summaries. */
if (_aborted)
return;
/* Print out the lazy plan if needed. */
fflush(stderr);
if (_lazy && _planned > 0)
printf("1..%lu\n", _planned);
/* Print out a summary of the results. */
if (_planned > highest)
diag("Looks like you planned %lu test%s but only ran %lu", _planned,
(_planned > 1 ? "s" : ""), highest);
else if (_planned < highest)
diag("Looks like you planned %lu test%s but ran %lu extra", _planned,
(_planned > 1 ? "s" : ""), highest - _planned);
else if (_failed > 0)
diag("Looks like you failed %lu test%s of %lu", _failed,
(_failed > 1 ? "s" : ""), _planned);
else if (_planned != 1)
diag("All %lu tests successful or skipped", _planned);
else
diag("%lu test successful or skipped", _planned);
}
/*
* Initialize things. Turns on line buffering on stdout and then prints out
* the number of tests in the test suite. We intentionally don't check for
* pending diag_file output here, since it should really come after the plan.
*/
void
plan(unsigned long count)
{
if (setvbuf(stdout, NULL, _IOLBF, BUFSIZ) != 0)
sysdiag("cannot set stdout to line buffered");
fflush(stderr);
printf("1..%lu\n", count);
testnum = 1;
_planned = count;
_process = getpid();
if (atexit(finish) != 0) {
sysdiag("cannot register exit handler");
diag("cleanups will not be run");
}
}
/*
* Initialize things for lazy planning, where we'll automatically print out a
* plan at the end of the program. Turns on line buffering on stdout as well.
*/
void
plan_lazy(void)
{
if (setvbuf(stdout, NULL, _IOLBF, BUFSIZ) != 0)
sysdiag("cannot set stdout to line buffered");
testnum = 1;
_process = getpid();
_lazy = 1;
if (atexit(finish) != 0)
sysbail("cannot register exit handler to display plan");
}
/*
* Skip the entire test suite and exits. Should be called instead of plan(),
* not after it, since it prints out a special plan line. Ignore diag_file
* output here, since it's not clear if it's allowed before the plan.
*/
void
skip_all(const char *format, ...)
{
fflush(stderr);
printf("1..0 # skip");
PRINT_DESC(" ", format);
putchar('\n');
exit(0);
}
/*
* Takes a boolean success value and assumes the test passes if that value
* is true and fails if that value is false.
*/
int
ok(int success, const char *format, ...)
{
fflush(stderr);
check_diag_files();
printf("%sok %lu", success ? "" : "not ", testnum++);
if (!success)
_failed++;
PRINT_DESC(" - ", format);
putchar('\n');
return success;
}
/*
* Same as ok(), but takes the format arguments as a va_list.
*/
int
okv(int success, const char *format, va_list args)
{
fflush(stderr);
check_diag_files();
printf("%sok %lu", success ? "" : "not ", testnum++);
if (!success)
_failed++;
if (format != NULL) {
printf(" - ");
vprintf(format, args);
}
putchar('\n');
return success;
}
/*
* Skip a test.
*/
void
skip(const char *reason, ...)
{
fflush(stderr);
check_diag_files();
printf("ok %lu # skip", testnum++);
PRINT_DESC(" ", reason);
putchar('\n');
}
/*
* Report the same status on the next count tests.
*/
int
ok_block(unsigned long count, int success, const char *format, ...)
{
unsigned long i;
fflush(stderr);
check_diag_files();
for (i = 0; i < count; i++) {
printf("%sok %lu", success ? "" : "not ", testnum++);
if (!success)
_failed++;
PRINT_DESC(" - ", format);
putchar('\n');
}
return success;
}
/*
* Skip the next count tests.
*/
void
skip_block(unsigned long count, const char *reason, ...)
{
unsigned long i;
fflush(stderr);
check_diag_files();
for (i = 0; i < count; i++) {
printf("ok %lu # skip", testnum++);
PRINT_DESC(" ", reason);
putchar('\n');
}
}
/*
* Takes an expected integer and a seen integer and assumes the test passes
* if those two numbers match.
*/
int
is_int(long wanted, long seen, const char *format, ...)
{
int success;
fflush(stderr);
check_diag_files();
success = (wanted == seen);
if (success)
printf("ok %lu", testnum++);
else {
diag("wanted: %ld", wanted);
diag(" seen: %ld", seen);
printf("not ok %lu", testnum++);
_failed++;
}
PRINT_DESC(" - ", format);
putchar('\n');
return success;
}
/*
* Takes a string and what the string should be, and assumes the test passes
* if those strings match (using strcmp).
*/
int
is_string(const char *wanted, const char *seen, const char *format, ...)
{
int success;
if (wanted == NULL)
wanted = "(null)";
if (seen == NULL)
seen = "(null)";
fflush(stderr);
check_diag_files();
success = (strcmp(wanted, seen) == 0);
if (success)
printf("ok %lu", testnum++);
else {
diag("wanted: %s", wanted);
diag(" seen: %s", seen);
printf("not ok %lu", testnum++);
_failed++;
}
PRINT_DESC(" - ", format);
putchar('\n');
return success;
}
/*
* Takes an expected unsigned long and a seen unsigned long and assumes the
* test passes if the two numbers match. Otherwise, reports them in hex.
*/
int
is_hex(unsigned long wanted, unsigned long seen, const char *format, ...)
{
int success;
fflush(stderr);
check_diag_files();
success = (wanted == seen);
if (success)
printf("ok %lu", testnum++);
else {
diag("wanted: %lx", (unsigned long) wanted);
diag(" seen: %lx", (unsigned long) seen);
printf("not ok %lu", testnum++);
_failed++;
}
PRINT_DESC(" - ", format);
putchar('\n');
return success;
}
/*
* Bail out with an error.
*/
void
bail(const char *format, ...)
{
va_list args;
_aborted = 1;
fflush(stderr);
check_diag_files();
fflush(stdout);
printf("Bail out! ");
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
exit(255);
}
/*
* Bail out with an error, appending strerror(errno).
*/
void
sysbail(const char *format, ...)
{
va_list args;
int oerrno = errno;
_aborted = 1;
fflush(stderr);
check_diag_files();
fflush(stdout);
printf("Bail out! ");
va_start(args, format);
vprintf(format, args);
va_end(args);
printf(": %s\n", strerror(oerrno));
exit(255);
}
/*
* Report a diagnostic to stderr. Always returns 1 to allow embedding in
* compound statements.
*/
int
diag(const char *format, ...)
{
va_list args;
fflush(stderr);
check_diag_files();
fflush(stdout);
printf("# ");
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
return 1;
}
/*
* Report a diagnostic to stderr, appending strerror(errno). Always returns 1
* to allow embedding in compound statements.
*/
int
sysdiag(const char *format, ...)
{
va_list args;
int oerrno = errno;
fflush(stderr);
check_diag_files();
fflush(stdout);
printf("# ");
va_start(args, format);
vprintf(format, args);
va_end(args);
printf(": %s\n", strerror(oerrno));
return 1;
}
/*
* Register a new file for diag_file processing.
*/
void
diag_file_add(const char *name)
{
struct diag_file *file, *prev;
file = bcalloc(1, sizeof(struct diag_file));
file->name = bstrdup(name);
file->file = fopen(file->name, "r");
if (file->file == NULL)
sysbail("cannot open %s", name);
file->buffer = bmalloc(BUFSIZ);
file->bufsize = BUFSIZ;
if (diag_files == NULL)
diag_files = file;
else {
for (prev = diag_files; prev->next != NULL; prev = prev->next)
;
prev->next = file;
}
}
/*
* Remove a file from diag_file processing. If the file is not found, do
* nothing, since there are some situations where it can be removed twice
* (such as if it's removed from a cleanup function, since cleanup functions
* are called after freeing all the diag_files).
*/
void
diag_file_remove(const char *name)
{
struct diag_file *file;
struct diag_file **prev = &diag_files;
for (file = diag_files; file != NULL; file = file->next) {
if (strcmp(file->name, name) == 0) {
*prev = file->next;
fclose(file->file);
free(file->name);
free(file->buffer);
free(file);
return;
}
prev = &file->next;
}
}
/*
* Allocate cleared memory, reporting a fatal error with bail on failure.
*/
void *
bcalloc(size_t n, size_t size)
{
void *p;
p = calloc(n, size);
if (p == NULL)
sysbail("failed to calloc %lu", (unsigned long)(n * size));
return p;
}
/*
* Allocate memory, reporting a fatal error with bail on failure.
*/
void *
bmalloc(size_t size)
{
void *p;
p = malloc(size);
if (p == NULL)
sysbail("failed to malloc %lu", (unsigned long) size);
return p;
}
/*
* Reallocate memory, reporting a fatal error with bail on failure.
*/
void *
brealloc(void *p, size_t size)
{
p = realloc(p, size);
if (p == NULL)
sysbail("failed to realloc %lu bytes", (unsigned long) size);
return p;
}
/*
* The same as brealloc, but determine the size by multiplying an element
* count by a size, similar to calloc. The multiplication is checked for
* integer overflow.
*
* We should technically use SIZE_MAX here for the overflow check, but
* SIZE_MAX is C99 and we're only assuming C89 + SUSv3, which does not
* guarantee that it exists. They do guarantee that UINT_MAX exists, and we
* can assume that UINT_MAX <= SIZE_MAX.
*
* (In theory, C89 and C99 permit size_t to be smaller than unsigned int, but
* I disbelieve in the existence of such systems and they will have to cope
* without overflow checks.)
*/
void *
breallocarray(void *p, size_t n, size_t size)
{
if (n > 0 && UINT_MAX / n <= size)
bail("reallocarray too large");
p = realloc(p, n * size);
if (p == NULL)
sysbail("failed to realloc %lu bytes", (unsigned long) (n * size));
return p;
}
/*
* Copy a string, reporting a fatal error with bail on failure.
*/
char *
bstrdup(const char *s)
{
char *p;
size_t len;
len = strlen(s) + 1;
p = malloc(len);
if (p == NULL)
sysbail("failed to strdup %lu bytes", (unsigned long) len);
memcpy(p, s, len);
return p;
}
/*
* Copy up to n characters of a string, reporting a fatal error with bail on
* failure. Don't use the system strndup function, since it may not exist and
* the TAP library doesn't assume any portability support.
*/
char *
bstrndup(const char *s, size_t n)
{
const char *p;
char *copy;
size_t length;
/* Don't assume that the source string is nul-terminated. */
for (p = s; (size_t) (p - s) < n && *p != '\0'; p++)
;
length = (size_t) (p - s);
copy = malloc(length + 1);
if (p == NULL)
sysbail("failed to strndup %lu bytes", (unsigned long) length);
memcpy(copy, s, length);
copy[length] = '\0';
return copy;
}
/*
* Locate a test file. Given the partial path to a file, look under BUILD and
* then SOURCE for the file and return the full path to the file. Returns
* NULL if the file doesn't exist. A non-NULL return should be freed with
* test_file_path_free().
*/
char *
test_file_path(const char *file)
{
char *base;
char *path = NULL;
const char *envs[] = { "BUILD", "SOURCE", NULL };
int i;
for (i = 0; envs[i] != NULL; i++) {
base = getenv(envs[i]);
if (base == NULL)
continue;
path = concat(base, "/", file, (const char *) 0);
if (access(path, R_OK) == 0)
break;
free(path);
path = NULL;
}
return path;
}
/*
* Free a path returned from test_file_path(). This function exists primarily
* for Windows, where memory must be freed from the same library domain that
* it was allocated from.
*/
void
test_file_path_free(char *path)
{
free(path);
}
/*
* Create a temporary directory, tmp, under BUILD if set and the current
* directory if it does not. Returns the path to the temporary directory in
* newly allocated memory, and calls bail on any failure. The return value
* should be freed with test_tmpdir_free.
*
* This function uses sprintf because it attempts to be independent of all
* other portability layers. The use immediately after a memory allocation
* should be safe without using snprintf or strlcpy/strlcat.
*/
char *
test_tmpdir(void)
{
const char *build;
char *path = NULL;
build = getenv("BUILD");
if (build == NULL)
build = ".";
path = concat(build, "/tmp", (const char *) 0);
if (access(path, X_OK) < 0)
if (mkdir(path, 0777) < 0)
sysbail("error creating temporary directory %s", path);
return path;
}
/*
* Free a path returned from test_tmpdir() and attempt to remove the
* directory. If we can't delete the directory, don't worry; something else
* that hasn't yet cleaned up may still be using it.
*/
void
test_tmpdir_free(char *path)
{
if (path != NULL)
rmdir(path);
free(path);
}
/*
* Register a cleanup function that is called when testing ends. All such
* registered functions will be run by finish.
*/
void
test_cleanup_register(test_cleanup_func func)
{
struct cleanup_func *cleanup, **last;
cleanup = bmalloc(sizeof(struct cleanup_func));
cleanup->func = func;
cleanup->next = NULL;
last = &cleanup_funcs;
while (*last != NULL)
last = &(*last)->next;
*last = cleanup;
}
hkl-5.0.0.2569/tests/tap/float.h 0000644 0001751 0001751 00000003233 13175570520 016332 0 ustar 00picca picca 0000000 0000000 /*
* Floating point check function for the TAP protocol.
*
* This file is part of C TAP Harness. The current version plus supporting
* documentation is at .
*
* Copyright 2008, 2010, 2012, 2014 Russ Allbery
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef TAP_FLOAT_H
#define TAP_FLOAT_H 1
#include
BEGIN_DECLS
/* Check an expected value against a seen value within epsilon. */
int is_double(double wanted, double seen, double epsilon,
const char *format, ...)
__attribute__((__format__(printf, 4, 5)));
END_DECLS
#endif /* TAP_FLOAT_H */
hkl-5.0.0.2569/tests/tap/float.c 0000644 0001751 0001751 00000005040 13175570520 016323 0 ustar 00picca picca 0000000 0000000 /*
* Utility routines for writing floating point tests.
*
* Currently provides only one function, which checks whether a double is
* equal to an expected value within a given epsilon. This is broken into a
* separate source file from the rest of the basic C TAP library because it
* may require linking with -lm on some platforms, and the package may not
* otherwise care about floating point.
*
* This file is part of C TAP Harness. The current version plus supporting
* documentation is at .
*
* Copyright 2008, 2010, 2012, 2013, 2014, 2015 Russ Allbery
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/* Required for isnan() and isinf(). */
#if defined(__STRICT_ANSI__) || defined(PEDANTIC)
# ifndef _XOPEN_SOURCE
# define _XOPEN_SOURCE 600
# endif
#endif
#include
#include
#include
#include
#include
/*
* Takes an expected double and a seen double and assumes the test passes if
* those two numbers are within delta of each other.
*/
int
is_double(double wanted, double seen, double epsilon, const char *format, ...)
{
va_list args;
int success;
va_start(args, format);
fflush(stderr);
if ((isnan(wanted) && isnan(seen))
|| (isinf(wanted) && isinf(wanted) == isinf(seen))
|| fabs(wanted - seen) <= epsilon) {
success = 1;
okv(1, format, args);
} else {
success = 0;
diag("wanted: %g", wanted);
diag(" seen: %g", seen);
okv(0, format, args);
}
return success;
}
hkl-5.0.0.2569/tests/tap/hkl-tap.h 0000644 0001751 0001751 00000004164 13447477011 016574 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#ifndef __HKL_TAP_H__
#define __HKL_TAP_H__
#include "hkl.h"
#include "hkl/api2/hkl2.h"
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
/* BEWARE here we are using a GCC extension */
#define DIAG(_success) \
({ typeof(_success) __success = (_success); \
if(!__success) \
diag("status: %d " __FILE__ ":" TOSTRING(__LINE__) ":%s", (__success) , __func__); \
__success; \
})
G_BEGIN_DECLS
extern void is_quaternion(const HklQuaternion *wanted, const HklQuaternion *seen, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
extern void is_matrix(const HklMatrix *wanted, const HklMatrix *seen, const char *format, ...)
__attribute__((__format__(printf, 3, 4)));
extern int check_pseudoaxes_v(HklEngine *engine, ...);
extern int check_pseudoaxes(HklEngine *engine,
double expected[], uint len);
extern void hkl_tap_engine_pseudo_axes_randomize(HklEngine *self,
double values[], size_t n_values,
HklUnitEnum unit_type) HKL_ARG_NONNULL(1, 2);
extern void hkl_tap_engine_parameters_randomize(HklEngine *self) HKL_ARG_NONNULL(1);
extern HklGeometryList *hkl_engine_set_values_v(HklEngine *self, ...);
G_END_DECLS
#endif /* __HKL_TAP_H__ */
hkl-5.0.0.2569/tests/tap/Makefile.in 0000644 0001751 0001751 00000047405 13574156672 017145 0 ustar 00picca picca 0000000 0000000 # Makefile.in generated by automake 1.16.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2018 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = { \
if test -z '$(MAKELEVEL)'; then \
false; \
elif test -n '$(MAKE_HOST)'; then \
true; \
elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
true; \
else \
false; \
fi; \
}
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
subdir = tests/tap
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/gtk-doc.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
ARFLAGS = cru
AM_V_AR = $(am__v_AR_@AM_V@)
am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
am__v_AR_0 = @echo " AR " $@;
am__v_AR_1 =
libtap_a_AR = $(AR) $(ARFLAGS)
libtap_a_LIBADD =
am_libtap_a_OBJECTS = basic.$(OBJEXT) float.$(OBJEXT) \
hkl-tap.$(OBJEXT)
libtap_a_OBJECTS = $(am_libtap_a_OBJECTS)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/config/depcomp
am__maybe_remake_depfiles = depfiles
am__depfiles_remade = ./$(DEPDIR)/basic.Po ./$(DEPDIR)/float.Po \
./$(DEPDIR)/hkl-tap.Po
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 =
LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
$(AM_CFLAGS) $(CFLAGS)
AM_V_CC = $(am__v_CC_@AM_V@)
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
am__v_CC_0 = @echo " CC " $@;
am__v_CC_1 =
CCLD = $(CC)
LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
am__v_CCLD_0 = @echo " CCLD " $@;
am__v_CCLD_1 =
SOURCES = $(libtap_a_SOURCES)
DIST_SOURCES = $(libtap_a_SOURCES)
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates. Input order is
# *not* preserved.
am__uniquify_input = $(AWK) '\
BEGIN { nonempty = 0; } \
{ items[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in items) print i; }; } \
'
# Make sure the list of sources is unique. This is necessary because,
# e.g., the same source file might be shared among _SOURCES variables
# for different programs/libraries.
am__define_uniq_tagged_files = \
list='$(am__tagged_files)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/config/depcomp
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ALLOCA = @ALLOCA@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AR = @AR@
ASY = @ASY@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BULLET_CFLAGS = @BULLET_CFLAGS@
BULLET_LIBS = @BULLET_LIBS@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DLLTOOL = @DLLTOOL@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EMACS = @EMACS@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
G3D_CFLAGS = @G3D_CFLAGS@
G3D_LIBS = @G3D_LIBS@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@
GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
GLIB_LIBS = @GLIB_LIBS@
GLIB_MKENUMS = @GLIB_MKENUMS@
GLU_CFLAGS = @GLU_CFLAGS@
GLU_LIBS = @GLU_LIBS@
GNUPLOT = @GNUPLOT@
GOBJECT_CFLAGS = @GOBJECT_CFLAGS@
GOBJECT_LIBS = @GOBJECT_LIBS@
GOBJECT_QUERY = @GOBJECT_QUERY@
GREP = @GREP@
GSL_CFLAGS = @GSL_CFLAGS@
GSL_CONFIG = @GSL_CONFIG@
GSL_LIBS = @GSL_LIBS@
GTKDOC_CHECK = @GTKDOC_CHECK@
GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
GTKDOC_MKPDF = @GTKDOC_MKPDF@
GTKDOC_REBASE = @GTKDOC_REBASE@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_LIBS = @GTK_LIBS@
HDF5_CFLAGS = @HDF5_CFLAGS@
HDF5_LIBS = @HDF5_LIBS@
HTML_DIR = @HTML_DIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
INTROSPECTION_CFLAGS = @INTROSPECTION_CFLAGS@
INTROSPECTION_COMPILER = @INTROSPECTION_COMPILER@
INTROSPECTION_GENERATE = @INTROSPECTION_GENERATE@
INTROSPECTION_GIRDIR = @INTROSPECTION_GIRDIR@
INTROSPECTION_LIBS = @INTROSPECTION_LIBS@
INTROSPECTION_MAKEFILE = @INTROSPECTION_MAKEFILE@
INTROSPECTION_SCANNER = @INTROSPECTION_SCANNER@
INTROSPECTION_TYPELIBDIR = @INTROSPECTION_TYPELIBDIR@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
MAKEINFO = @MAKEINFO@
MANIFEST_TOOL = @MANIFEST_TOOL@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
VMAJ = @VMAJ@
YAML_CFLAGS = @YAML_CFLAGS@
YAML_LIBS = @YAML_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
release_info = @release_info@
runstatedir = @runstatedir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
version_info = @version_info@
AM_CFLAGS = \
-I$(top_srcdir) \
-I$(abs_top_srcdir)/tests \
$(GLIB_CFLAGS) \
$(GSL_CFLAGS)
check_LIBRARIES = libtap.a
libtap_a_SOURCES = \
basic.c \
basic.h \
float.h \
float.c \
macros.h \
hkl-tap.h \
hkl-tap.c
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/tap/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu tests/tap/Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
clean-checkLIBRARIES:
-test -z "$(check_LIBRARIES)" || rm -f $(check_LIBRARIES)
libtap.a: $(libtap_a_OBJECTS) $(libtap_a_DEPENDENCIES) $(EXTRA_libtap_a_DEPENDENCIES)
$(AM_V_at)-rm -f libtap.a
$(AM_V_AR)$(libtap_a_AR) libtap.a $(libtap_a_OBJECTS) $(libtap_a_LIBADD)
$(AM_V_at)$(RANLIB) libtap.a
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/basic.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/float.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-tap.Po@am__quote@ # am--include-marker
$(am__depfiles_remade):
@$(MKDIR_P) $(@D)
@echo '# dummy' >$@-t && $(am__mv) $@-t $@
am--depfiles: $(am__depfiles_remade)
.c.o:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
.c.obj:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(am__tagged_files)
$(am__define_uniq_tagged_files); mkid -fID $$unique
tags: tags-am
TAGS: tags
tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
set x; \
here=`pwd`; \
$(am__define_uniq_tagged_files); \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: ctags-am
CTAGS: ctags
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
$(am__define_uniq_tagged_files); \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
cscopelist: cscopelist-am
cscopelist-am: $(am__tagged_files)
list='$(am__tagged_files)'; \
case "$(srcdir)" in \
[\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
*) sdir=$(subdir)/$(srcdir) ;; \
esac; \
for i in $$list; do \
if test -f "$$i"; then \
echo "$(subdir)/$$i"; \
else \
echo "$$sdir/$$i"; \
fi; \
done >> $(top_builddir)/cscope.files
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
distdir-am: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
$(MAKE) $(AM_MAKEFLAGS) $(check_LIBRARIES)
check: check-am
all-am: Makefile
installdirs:
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-checkLIBRARIES clean-generic clean-libtool \
mostlyclean-am
distclean: distclean-am
-rm -f ./$(DEPDIR)/basic.Po
-rm -f ./$(DEPDIR)/float.Po
-rm -f ./$(DEPDIR)/hkl-tap.Po
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f ./$(DEPDIR)/basic.Po
-rm -f ./$(DEPDIR)/float.Po
-rm -f ./$(DEPDIR)/hkl-tap.Po
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am:
.MAKE: check-am install-am install-strip
.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
clean-checkLIBRARIES clean-generic clean-libtool cscopelist-am \
ctags ctags-am distclean distclean-compile distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags tags-am uninstall uninstall-am
.PRECIOUS: Makefile
# Support for GNU Flymake, in Emacs.
check-syntax: AM_CFLAGS += -fsyntax-only -pipe
check-syntax:
test -z "$(CHK_SOURCES)" || $(COMPILE) $(CHK_SOURCES)
.PHONY: check-syntax
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
hkl-5.0.0.2569/tests/hkl-lattice-t.c 0000644 0001751 0001751 00000024527 13447477011 017112 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#define CHECK_PARAM(_lattice, _param, _value) \
is_double((_value), \
hkl_parameter_value_get(hkl_lattice_## _param ##_get(_lattice), \
HKL_UNIT_DEFAULT), \
HKL_EPSILON, __func__);
#define CHECK_LATTICE(_lattice, _a, _b, _c, _alpha, _beta, _gamma) do { \
CHECK_PARAM(_lattice, a, _a); \
CHECK_PARAM(_lattice, b, _b); \
CHECK_PARAM(_lattice, c, _c); \
CHECK_PARAM(_lattice, alpha, _alpha); \
CHECK_PARAM(_lattice, beta, _beta); \
CHECK_PARAM(_lattice, gamma, _gamma); \
}while(0);
#define SET_PARAM(_lattice, _param, _value) do { \
GError *error; \
HklParameter *p = hkl_parameter_new_copy(hkl_lattice_ ## _param ## _get(_lattice)); \
ok(hkl_parameter_value_set(p, _value, HKL_UNIT_DEFAULT, NULL), __func__); \
ok(TRUE == hkl_lattice_ ## _param ## _set(_lattice, p, NULL), __func__); \
error = NULL; \
ok(TRUE == hkl_lattice_ ## _param ## _set(_lattice, p, &error), __func__); \
ok(error == NULL, __func__); \
hkl_parameter_free(p); \
}while(0);
\
#define SET_LATTICE(_lattice, _a, _b, _c, _alpha, _beta, _gamma) do{ \
SET_PARAM(_lattice, a, _a); \
SET_PARAM(_lattice, b, _b); \
SET_PARAM(_lattice, c, _c); \
SET_PARAM(_lattice, alpha, _alpha); \
SET_PARAM(_lattice, beta, _beta); \
SET_PARAM(_lattice, gamma, _gamma); \
}while(0);
static void new(void)
{
HklLattice *lattice;
GError *error;
/* can not set this lattice */
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
NULL);
ok(NULL == lattice, __func__);
/* check GError generation */
error = NULL;
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
&error);
ok(NULL == lattice, __func__);
ok(error != NULL, __func__);
g_clear_error(&error);
/* but can create this one */
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
NULL);
ok(0 == !lattice, __func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
hkl_lattice_free(lattice);
/* but can create this one and no GError are produce */
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
&error);
ok(0 == !lattice, __func__);
ok(error == NULL, __func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
hkl_lattice_free(lattice);
}
static void new_copy(void)
{
HklLattice *lattice;
HklLattice *copy;
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
NULL);
/* copy constructor */
copy = hkl_lattice_new_copy(lattice);
CHECK_LATTICE(copy,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
hkl_lattice_free(lattice);
hkl_lattice_free(copy);
}
static void set(void)
{
HklLattice *lattice;
GError *error;
lattice = hkl_lattice_new_default();
/* can not set this lattice */
ok(FALSE == hkl_lattice_set(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
/* can not set this lattice with GError */
error = NULL;
ok(FALSE == hkl_lattice_set(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, &error),
__func__);
ok(error != NULL, __func__);
g_clear_error(&error);
/* can set this lattice */
ok(TRUE == hkl_lattice_set(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
/* can set this lattice with no GError set */
ok(TRUE == hkl_lattice_set(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, &error),
__func__);
ok(error == NULL, __func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
/* can set this lattice in HKL_UNIT_USER with no GError set */
ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54, 90, 91, 92,
HKL_UNIT_USER, NULL),
__func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
/* can set this lattice in HKL_UNIT_USER with no GError set */
ok(TRUE == hkl_lattice_set(lattice,
1.54, 1.54, 1.54, 90, 91, 90,
HKL_UNIT_USER, &error),
__func__);
ok(error == NULL, __func__);
CHECK_LATTICE(lattice,
1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
/* check individual accessor */
SET_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
CHECK_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
hkl_lattice_free(lattice);
}
static void reciprocal(void)
{
HklLattice *lattice;
HklLattice *reciprocal;
lattice = hkl_lattice_new_default();
reciprocal = hkl_lattice_new_default();
/* cubic */
ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU / 1.54, HKL_TAU / 1.54, HKL_TAU / 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
/* orthorombic */
ok(TRUE == hkl_lattice_set(lattice,
1., 3., 4.,
90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU / 1., HKL_TAU / 3., HKL_TAU / 4.,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
/* hexagonal1 */
ok(TRUE == hkl_lattice_set(lattice,
1., 2., 1.,
90 * HKL_DEGTORAD, 120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU * 2. / sqrt(3.), HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.),
90. * HKL_DEGTORAD, 60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
/* hexagonal2 */
ok(TRUE == hkl_lattice_set(lattice, 2., 1., 1.,
120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.), HKL_TAU * 2. / sqrt(3.),
60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
/* triclinic1 */
ok(TRUE == hkl_lattice_set(lattice, 9.32, 8.24, 13.78,
91.23 * HKL_DEGTORAD, 93.64 * HKL_DEGTORAD, 122.21 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU * 0.1273130168,HKL_TAU * 0.1437422974,HKL_TAU * 0.0728721120,
1.5052513337, 1.482101482, 1.0055896011);
/* triclinic2 */
ok(TRUE == hkl_lattice_set(lattice, 18.423, 18.417,
18.457, 89.99 * HKL_DEGTORAD, 89.963 * HKL_DEGTORAD, 119.99 * HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL),
__func__);
ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
CHECK_LATTICE(reciprocal,
HKL_TAU * 0.0626708259,HKL_TAU * 0.0626912310,HKL_TAU * 0.0541800061,
1.5713705262, 1.5716426508, 1.0473718249);
hkl_lattice_free(lattice);
hkl_lattice_free(reciprocal);
}
static void volume(void)
{
HklLattice *lattice;
HklLattice *reciprocal;
lattice = hkl_lattice_new_default();
reciprocal = hkl_lattice_new_default();
/* cubic */
DIAG(hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
HKL_UNIT_DEFAULT, NULL));
CHECK_PARAM(lattice, volume, 1.54*1.54*1.54);
hkl_lattice_reciprocal(lattice, reciprocal);
CHECK_PARAM(reciprocal, volume, (HKL_TAU * HKL_TAU * HKL_TAU)/(1.54*1.54*1.54));
hkl_lattice_free(lattice);
hkl_lattice_free(reciprocal);
}
static void get_B(void)
{
HklMatrix *B_ref = hkl_matrix_new_full(HKL_TAU / 1.54, 0, 0,
0, HKL_TAU / 1.54, 0,
0, 0, HKL_TAU / 1.54);
HklLattice *lattice;
HklMatrix *B = hkl_matrix_new();
/* cubic */
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
NULL);
hkl_lattice_get_B(lattice, B);
is_matrix(B_ref, B, __func__);
hkl_lattice_free(lattice);
hkl_matrix_free(B);
hkl_matrix_free(B_ref);
}
static void get_1_B(void)
{
HklMatrix *I_ref = hkl_matrix_new_full(1, 0, 0,
0, 1, 0,
0, 0, 1);
HklLattice *lattice;
HklMatrix *I = hkl_matrix_new();
HklMatrix *B_1 = hkl_matrix_new();
/* cubic */
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
NULL);
hkl_lattice_get_B(lattice, I);
hkl_lattice_get_1_B(lattice, B_1);
/* B times B^-1 = Identity */
hkl_matrix_times_matrix(I, B_1);
is_matrix(I_ref, I, __func__);
hkl_lattice_free(lattice);
hkl_matrix_free(B_1);
hkl_matrix_free(I);
hkl_matrix_free(I_ref);
}
int main(void)
{
plan(139);
new();
new_copy();
set();
reciprocal();
volume();
get_B();
get_1_B();
return 0;
}
hkl-5.0.0.2569/tests/hkl-bench-t.c 0000644 0001751 0001751 00000013422 13447477011 016534 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include
#include
#include
#include "hkl.h"
static void hkl_test_bench_run_real(HklEngine *engine, HklGeometry *geometry,
double values[], size_t n_values, size_t n)
{
size_t i;
const darray_string *modes = hkl_engine_modes_names_get(engine);
const char **mode;
/* pseudo -> geometry */
darray_foreach(mode, *modes){
double min, max, mean;
const darray_string *parameters;
size_t n_params;
if (FALSE == hkl_engine_current_mode_set(engine, *mode, NULL))
continue;
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if (n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine,
params, n_params,
HKL_UNIT_DEFAULT);
values[0] = 1;
if(FALSE == hkl_engine_parameters_values_set(engine,
params, n_params,
HKL_UNIT_DEFAULT, NULL))
continue;
}
mean = max = 0;
min = 1000; /* arbitrary value always greater than the real min */
for(i=0; i max ? t : max;
mean += t;
}
fprintf(stdout, "\"%s\" \"%s\" \"%s\" (%d/%d) iterations %f / %f / %f [min/mean/max] ms each\n",
hkl_geometry_name_get(geometry),
hkl_engine_name_get(engine),
*mode, n, i, min, mean/n, max);
}
}
static void hkl_test_bench_run_v(HklEngineList *engines, HklGeometry *geometry,
char const *name, unsigned int n, ...)
{
va_list ap;
size_t i;
HklEngine *engine = hkl_engine_list_engine_get_by_name(engines, name, NULL);
size_t n_values = darray_size(*hkl_engine_pseudo_axis_names_get(engine));
double values[n_values];
va_start(ap, n);
for(i=0; i 1)
n = atoi(argv[1]);
else
n = 10;
hkl_test_bench_k6c(n);
hkl_test_bench_eulerians();
ok(TRUE == TRUE, __func__);
return 0;
}
hkl-5.0.0.2569/tests/bindings/ 0000755 0001751 0001751 00000000000 13574157075 016075 5 ustar 00picca picca 0000000 0000000 hkl-5.0.0.2569/tests/bindings/python.py 0000755 0001751 0001751 00000036376 13574136244 020005 0 ustar 00picca picca 0000000 0000000 #!/usr/bin/env python3
"""
This file is part of the hkl library.
The hkl library 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.
The hkl library 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 the hkl library. If not, see .
Copyright (C) 2012-2013 Synchrotron SOLEIL
L'Orme des Merisiers Saint-Aubin
BP 48 91192 GIF-sur-YVETTE CEDEX
Authors: Picca Frédéric-Emmanuel
"""
import math
import unittest
from gi.repository import GLib
import gi
gi.require_version("Hkl", "5.0")
from gi.repository import Hkl
class TestAPI(unittest.TestCase):
"""Test all the Hkl API, if something brakes here it means that API
has changed !!!
"""
def test_vector_api(self):
"""
enforce the Vector api
"""
v = Hkl.Vector()
self.assertTrue(type(v) == Hkl.Vector)
self.assertTrue(type(v.data) == list)
self.assertTrue(3 == len(v.data))
self.assertTrue(v.data == [0.0, 0.0, 0.0])
v.init(1, 2, 3)
self.assertTrue(v.data == [1.0, 2.0, 3.0])
del v
def test_quaternion_api(self):
"""
enforce the Vector api
"""
q = Hkl.Quaternion()
self.assertTrue(type(q) == Hkl.Quaternion)
self.assertTrue(type(q.data) == list)
self.assertTrue(4 == len(q.data))
del q
def test_factory_api(self):
"""
enforce the Factory API
"""
# factories dict
factories = Hkl.factories()
for key, factory in factories.items():
self.assertTrue(type(key) == str)
self.assertTrue(type(factory) == Hkl.Factory)
# create all the geometry and engines
geometry = factory.create_new_geometry()
self.assertTrue(type(geometry) == Hkl.Geometry)
engines = factory.create_new_engine_list()
self.assertTrue(type(engines) == Hkl.EngineList)
del factories
def test_detector_api(self):
"""
enforce the detector API
"""
# create an 0D HklDetector
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
self.assertTrue(type(detector) is Hkl.Detector)
del detector
def test_geometry_api(self):
"""
enforce the geometry API
"""
# get the config for a given geometry and create the
# corresponding HklGeometry
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
sample = Hkl.Sample.new("toto")
# source access
wavelength = 1.
geometry.wavelength_set(wavelength, Hkl.UnitEnum.USER)
self.assertTrue(wavelength == geometry.wavelength_get(Hkl.UnitEnum.USER)) # noqa
# set the geometry axes values
values_w = [0, 30, 0, 0, 0, 60]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
values_r = geometry.axis_values_get(Hkl.UnitEnum.USER)
# check that the read and write values of the geometry are
# almost equals
for r, w in zip(values_w, values_r):
self.assertAlmostEqual(r, w)
# check that we can access the axes
axis_names = geometry.axis_names_get()
for name in axis_names:
axis = geometry.axis_get(name)
axis.min_max_set(0, math.radians(180), Hkl.UnitEnum.USER)
v = axis.axis_v_get()
q = axis.quaternion_get()
geometry.axis_set(name, axis)
# check xxx_rotation_get
q = geometry.sample_rotation_get(sample)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
q = geometry.detector_rotation_get(detector)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
del sample
del detector
del geometry
def test_engine_api(self):
"""
enforce the HklEngine API
"""
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
sample = Hkl.Sample.new("toto")
lattice = sample.lattice_get()
lattice.set(1.54, 1.54, 1.54, 90, 90, 90, Hkl.UnitEnum.USER)
sample.lattice_set(lattice)
# compute all the pseudo axes managed by all engines
engines = factory.create_new_engine_list()
engines.init(geometry, detector, sample)
engines.get()
# get the hkl engine and do a computation
hkl = engines.engine_get_by_name("hkl")
values = hkl.pseudo_axis_values_get(Hkl.UnitEnum.USER)
# check for all modes
for mode in hkl.modes_names_get():
self.assertTrue(type(mode) is str)
# set the hkl engine and get the results
for _ in range(100):
try:
solutions = hkl.pseudo_axis_values_set(values,
Hkl.UnitEnum.USER)
self.assertTrue(type(solutions) is Hkl.GeometryList)
for item in solutions.items():
self.assertTrue(type(item) is Hkl.GeometryListItem)
self.assertTrue(type(item.geometry_get()) is Hkl.Geometry)
values[1] += .01
except GLib.GError as err:
print(values, err)
# check that all the values computed are reachable
for engine in engines.engines_get():
self.assertTrue(type(engine) is Hkl.Engine)
self.assertTrue(type(engine.name_get()) is str)
self.assertTrue(type(engine.pseudo_axis_names_get()) is list)
self.assertTrue(type(engine.modes_names_get()) is list)
self.assertTrue(len(engine.modes_names_get()))
for mode in engine.modes_names_get():
self.assertTrue(type(mode) is str)
values = engine.pseudo_axis_values_get(Hkl.UnitEnum.USER)
self.assertTrue(type(values) is list)
for value in values:
self.assertTrue(type(value) is float)
# check that all engine parameters and axes are reachables
for engine in engines.engines_get():
for mode in engine.modes_names_get():
engine.current_mode_set(mode)
parameters = engine.parameters_names_get()
self.assertTrue(type(parameters) is list)
[self.assertTrue(type(_) is str) for _ in parameters]
# all together
values = engine.parameters_values_get(Hkl.UnitEnum.USER)
[self.assertTrue(type(_) is float) for _ in values]
engine.parameters_values_set(values, Hkl.UnitEnum.USER)
# one by one
for parameter in parameters:
p = engine.parameter_get(parameter)
self.assertTrue(type(p.description_get()) is str)
# check that parameters are writable.
values = engine.parameters_values_get(Hkl.UnitEnum.USER)
values = [1.] * len(values)
engine.parameters_values_set(values, Hkl.UnitEnum.USER)
[self.assertTrue(ref == v)
for ref, v in zip(values,
engine.parameters_values_get(Hkl.UnitEnum.USER))]
axes_r = engine.axis_names_get(Hkl.EngineAxisNamesGet.READ)
self.assertTrue(type(axes_r) is list)
[self.assertTrue(type(_) is str) for _ in axes_r]
axes_w = engine.axis_names_get(Hkl.EngineAxisNamesGet.WRITE)
self.assertTrue(type(axes_w) is list)
[self.assertTrue(type(_) is str) for _ in axes_w]
# check all the capabilities
for engine in engines.engines_get():
capabilities = engine.capabilities_get()
self.assertTrue(capabilities & Hkl.EngineCapabilities.READABLE)
if engine.name_get() not in ["incidence", "emergence"]:
self.assertTrue(capabilities & Hkl.EngineCapabilities.WRITABLE)
if engine.name_get() == "psi":
self.assertTrue(capabilities & Hkl.EngineCapabilities.INITIALIZABLE)
# check initialized_get/set
for engine in engines.engines_get():
initialized = engine.initialized_get()
capabilities = engine.capabilities_get()
if capabilities & Hkl.EngineCapabilities.INITIALIZABLE:
engine.initialized_set(False)
self.assertTrue(False == engine.initialized_get())
engine.initialized_set(True)
self.assertTrue(True == engine.initialized_get())
# check all the dependencies
for engine in engines.engines_get():
dependencies = engine.dependencies_get()
self.assertTrue(dependencies & Hkl.EngineDependencies.AXES)
def test_engine_list_api(self):
factories = Hkl.factories()
for key, factory in factories.items():
# print("diffractometer geometry factory = " + str(key))
engines = factory.create_new_engine_list()
# check the parameters
names = engines.parameters_names_get()
self.assertTrue(type(names) is list)
[self.assertTrue(type(_) is str) for _ in names]
# get/set the parameters
for name in names:
p = engines.parameter_get(name)
self.assertTrue(type(p) is Hkl.Parameter)
engines.parameter_set(name, p)
# check that we can get/set the parameters values
values = engines.parameters_values_get(Hkl.UnitEnum.USER)
[self.assertTrue(type(_) is float) for _ in values]
engines.parameters_values_set(values, Hkl.UnitEnum.USER)
@unittest.skip("for testing figures")
def test_doc_example(self):
# execfile("../../Documentation/sphinx/source/bindings/python.py")
execfile(
"../../Documentation/sphinx/source/pyplots/trajectory_simple.py")
execfile(
"../../Documentation/sphinx/source/pyplots/trajectory_full.py")
self.assertTrue(False)
def test_lattice_api(self):
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54,
math.radians(90.),
math.radians(90.),
math.radians(90.))
lattice2 = lattice.copy()
# check all the accessors
a = lattice.a_get()
b = lattice.b_get()
c = lattice.c_get()
alpha = lattice.alpha_get()
beta = lattice.beta_get()
gamma = lattice.gamma_get()
lattice.a_set(a)
lattice.b_set(b)
lattice.c_set(c)
lattice.alpha_set(alpha)
lattice.beta_set(beta)
lattice.gamma_set(gamma)
# change the lattice parameter by expanding the tuple from
# the get method. the lattice should not change.
a, b, c, alpha, beta, gamma = lattice.get(Hkl.UnitEnum.DEFAULT)
lattice.set(a, b, c, alpha, beta, gamma, Hkl.UnitEnum.DEFAULT)
# now change the lattice parameter
lattice.set(1, 2, 3, 90, 90, 90, Hkl.UnitEnum.USER)
# this new lattice is different from the one in the sample
self.assertTrue(lattice.get(Hkl.UnitEnum.DEFAULT)
!= lattice2.get(Hkl.UnitEnum.DEFAULT))
del lattice2
del lattice
def test_sample_api(self):
"""
enforce the HklSample API
"""
# create a sample
sample = Hkl.Sample.new("toto")
self.assertTrue(sample.name_get() == "toto")
# check that the copy constructor is working
copy = sample.copy()
self.assertTrue(copy.name_get() == sample.name_get())
# we can change the name of the copy without affecting the original
copy.name_set("titi")
self.assertTrue(copy.name_get() != sample.name_get())
# set the lattice parameters
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54,
math.radians(90.),
math.radians(90.),
math.radians(90.))
sample.lattice_set(lattice)
# change the lattice parameter by expanding the tuple from
# the get method. the lattice should not change.
a, b, c, alpha, beta, gamma = lattice.get(Hkl.UnitEnum.DEFAULT)
lattice.set(a, b, c, alpha, beta, gamma, Hkl.UnitEnum.DEFAULT)
# this new lattice is identical to the one from the sample
v = lattice.get(Hkl.UnitEnum.DEFAULT)
self.assertTrue(v == sample.lattice_get().get(Hkl.UnitEnum.DEFAULT))
# now change the lattice parameter
lattice.set(1, 2, 3, 90, 90, 90, Hkl.UnitEnum.USER)
# this new lattice is different from the one in the sample
v = lattice.get(Hkl.UnitEnum.DEFAULT)
self.assertTrue(v != sample.lattice_get().get(Hkl.UnitEnum.DEFAULT))
# gives access to the ux, uy, uz part
ux = sample.ux_get()
uy = sample.uy_get()
uz = sample.uz_get()
sample.ux_set(ux)
sample.uy_set(uy)
sample.uz_set(uz)
# read and write the U matrix
U = sample.U_get()
UB = sample.UB_get()
sample.UB_set(UB)
# get the reciprocal lattice
reciprocal = lattice.copy()
lattice.reciprocal(reciprocal)
# get the lattice volume
lattice.volume_get()
del sample
del lattice
def test_reflection_api(self):
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
sample = Hkl.Sample.new("toto")
# add reflection
r1 = sample.add_reflection(geometry, detector, 1, 1, 1)
r2 = sample.add_reflection(geometry, detector, 1, 1, 1)
# get the hkl part
self.assertTrue(r2.hkl_get() == (1.0, 1.0, 1.0))
r2.hkl_set(1, 0, 1)
self.assertTrue(r2.hkl_get() == (1.0, 0.0, 1.0))
# get the flag part
flag = r1.flag_get()
r1.flag_set(flag)
# get the geometry part
g = r1.geometry_get()
r1.geometry_set(g)
# compute the angles
sample.get_reflection_measured_angle(r1, r2)
sample.get_reflection_theoretical_angle(r1, r2)
# remove all the reflections
reflections = sample.reflections_get()
for reflection in reflections:
sample.del_reflection(reflection)
del reflections
del sample
if __name__ == '__main__':
unittest.main(verbosity=2)
hkl-5.0.0.2569/tests/bindings/trajectory.py 0000755 0001751 0001751 00000010675 13574136244 020644 0 ustar 00picca picca 0000000 0000000 #!/usr/bin/env python3
import math
import numpy
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
from matplotlib import rcParams
from gi.repository import GLib
import gi
gi.require_version("Hkl", "5.0")
from gi.repository import Hkl
def compute_hkl_trajectories(engines, engine, hkl1=None, hkl2=None, n=100):
"""
compute all the trajectories for a given engine already configured
"""
if not hkl1:
hkl1 = [0, 0, 1]
if not hkl2:
hkl2 = [0, 1, 1]
h = numpy.linspace(hkl1[0], hkl2[0], n + 1)
k = numpy.linspace(hkl1[1], hkl2[1], n + 1)
l = numpy.linspace(hkl1[2], hkl2[2], n + 1)
# set the hkl engine and get the results
trajectories = []
for hh, kk, ll in zip(h, k, l):
try:
solutions = engine.pseudo_axis_values_set([hh, kk, ll],
Hkl.UnitEnum.USER)
first_solution = solutions.items()[0]
for i, item in enumerate(solutions.items()):
try:
trajectories[i]
except IndexError:
trajectories.append([])
values = item.geometry_get().axis_values_get(Hkl.UnitEnum.USER)
trajectories[i].append(values)
engines.select_solution(first_solution)
except GLib.GError as err:
pass
return trajectories
def _plot_legend(axes):
plt.subplot(3, 4, 1)
plt.title("legend")
print("legende", 1)
for name in axes:
plt.plot([0, 0], label=name)
plt.legend()
def plot_hkl_trajectory(filename, geometry, engines,
hkl1=None, hkl2=None, n=100):
"""
plot the trajectory for a engine. It is possible to limit the
number of trajectory using the max_traj keyword
"""
axis_names = geometry.axis_names_get()
hkl = engines.engine_get_by_name("hkl")
page = 1
plt.clf()
plt.suptitle("\"" + filename + "\" " + repr(
hkl1) + " -> " + repr(hkl2) + " page " + str(page))
_plot_legend(axis_names)
idx = 2
for mode in hkl.modes_names_get():
hkl.current_mode_set(mode)
trajectories = compute_hkl_trajectories(engines, hkl, hkl1=hkl1, hkl2=hkl2, n=n)
print("\"" + filename + "\"", idx, mode, len(trajectories))
plt.subplot(3, 4, idx)
plt.title(mode)
if not len(trajectories):
plt.text(0.5, 0.5, "Failed", size=20, rotation=0.,
ha="center", va="center",
bbox=dict(boxstyle="round",
ec=(1., 0.5, 0.5),
fc=(1., 0.8, 0.8),
)
)
plt.draw()
else:
plt.ylim(-180, 180)
if len(trajectories[0]) == 1:
plt.plot(trajectories[0], 'o-')
else:
plt.plot(trajectories[0], '-')
idx += 1
if idx > 12:
pp.savefig()
plt.clf()
page += 1
_plot_legend(axis_names)
plt.suptitle(filename + " " + repr(
hkl1) + " -> " + repr(hkl2) + " page " + str(page))
idx = 2
pp.savefig()
pp = PdfPages('trajectories.pdf')
rcParams['font.size'] = 6
def main():
sample = Hkl.Sample.new("toto")
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54,
math.radians(90.),
math.radians(90.),
math.radians(90.))
sample.lattice_set(lattice)
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
for key, factory in Hkl.factories().items():
geometry = factory.create_new_geometry()
engines = factory.create_new_engine_list()
# here we set the detector arm with only positiv values for
# now tth or delta arm
for axis in geometry.axis_names_get():
if axis in ["tth", "delta"]:
tmp = geometry.axis_get(axis)
tmp.min_max_set(0, 180., Hkl.UnitEnum.USER)
geometry.axis_set(axis, tmp)
engines.init(geometry, detector, sample)
engines_names = [engine.name_get() for engine in engines.engines_get()]
if 'hkl' in engines_names:
plot_hkl_trajectory(key, geometry, engines,
hkl1=[0, 0, 1], hkl2=[0, 1, 1], n=100)
pp.close()
if __name__ == '__main__':
main()
hkl-5.0.0.2569/tests/bindings/Makefile.am 0000644 0001751 0001751 00000001033 13574136244 020121 0 ustar 00picca picca 0000000 0000000 TESTS_ENVIRONMENT=env GI_TYPELIB_PATH=$(top_builddir)/hkl DATADIR=$(srcdir) $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la
TESTS = python.py trajectory.py polarisation.py
EXTRA_DIST = $(TESTS) crystal.ini
ipython:
env GI_TYPELIB_PATH=$(top_builddir)/hkl $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la ipython3 -i -c "from gi.repository import Hkl"
gdb:
env GI_TYPELIB_PATH=$(top_builddir)/hkl $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la gdb python3
CLEANFILES = trajectories.pdf
hkl-5.0.0.2569/tests/bindings/polarisation.py 0000755 0001751 0001751 00000031417 13574136244 021157 0 ustar 00picca picca 0000000 0000000 #!/usr/bin/env python3
import os
import math
import unittest
from collections import namedtuple
from gi.repository import GLib
import gi
gi.require_version("Hkl", "5.0")
from gi.repository import Hkl
from numpy import (array, cross, dot, empty, hstack, reshape, vstack)
from numpy.linalg import inv, norm
#########
# Types #
#########
Detector = namedtuple('Detector', ['type'])
Diffractometer = namedtuple('Diffractometer', ['dtype', 'sample',
'detector', 'source', 'engine'])
Engine = namedtuple('Engine', ['name', 'mode'])
Lattice = namedtuple('Lattice', ['a', 'b', 'c', 'alpha', 'beta', 'gamma'])
Reflection = namedtuple('Reflection', ['hkl', 'values'])
Sample = namedtuple('Sample', ['lattice', 'or0', 'or1', 'ux', 'uy', 'uz'])
Source = namedtuple('Source', ['wavelength', 'energy'])
HklDiffractometer = namedtuple('HklDiffractometer', ['sample', 'detector',
'geometry', 'engines'])
##################
# Helper methods #
##################
def hkl_matrix_to_numpy(m):
M = empty((3, 3))
for i in range(3):
for j in range(3):
M[i, j] = m.get(i, j)
return M
def from_numpy_to_hkl_vector(v):
V = Hkl.Vector()
V.init(v[0], v[1], v[2])
return V
#########################
# Hkl Type constructors #
#########################
def new_hkl_sample(config):
# sample
sample = Hkl.Sample.new("test")
lattice = Hkl.Lattice.new(config.lattice.a,
config.lattice.b,
config.lattice.c,
math.radians(config.lattice.alpha),
math.radians(config.lattice.beta),
math.radians(config.lattice.gamma))
sample.lattice_set(lattice)
parameter = sample.ux_get()
parameter.value_set(config.ux, Hkl.UnitEnum.USER)
sample.ux_set(parameter)
parameter = sample.uy_get()
parameter.value_set(config.uy, Hkl.UnitEnum.USER)
sample.uy_set(parameter)
parameter = sample.uz_get()
parameter.value_set(config.uz, Hkl.UnitEnum.USER)
sample.uz_set(parameter)
return sample
def new_hkl_detector(config):
return Hkl.Detector.factory_new(config.type)
def new_hkl_geometry(dtype, wavelength, init_values):
factory = Hkl.factories()[dtype]
geometry = factory.create_new_geometry()
geometry.axis_values_set(init_values, Hkl.UnitEnum.USER)
geometry.wavelength_set(wavelength, Hkl.UnitEnum.USER)
return geometry
def new_hkl_engines(dtype):
factory = Hkl.factories()[dtype]
engines = factory.create_new_engine_list()
return engines
def new_hkl_diffractometer(config):
sample = new_hkl_sample(config.sample)
detector = new_hkl_detector(config.detector)
# add reflection or0
geometry = new_hkl_geometry(config.dtype,
config.source.wavelength,
config.sample.or0.values)
or0 = sample.add_reflection(geometry, detector,
config.sample.or0.hkl[0],
config.sample.or0.hkl[1],
config.sample.or0.hkl[2])
# add reflection or1
geometry.axis_values_set(config.sample.or1.values,
Hkl.UnitEnum.USER)
or1 = sample.add_reflection(geometry, detector,
config.sample.or1.hkl[0],
config.sample.or1.hkl[1],
config.sample.or1.hkl[2])
# compute UB with or0 and or1
# sample.compute_UB_busing_levy(or0, or1)
# UB = hkl_matrix_to_numpy(sample.UB_get())
# compute angles for reciprocal lattice vector h, k, l
engines = new_hkl_engines(config.dtype)
# set the engine mode
engine = engines.engine_get_by_name(config.engine.name)
engine.current_mode_set(config.engine.mode)
return HklDiffractometer(sample, geometry, detector, engines)
#################
# Config parser #
#################
def find(filename):
if os.path.exists(filename):
return filename
else:
datadir = os.getenv('DATADIR')
if datadir:
filename = os.path.join(datadir, filename)
if os.path.exists(filename):
return filename
else:
raise Exception("Can not find: " + filename)
else:
raise Exception("Cannot find: " + filename)
def parse_reflection(line):
ref = line.split()
hkl = [float(x) for x in ref[2:5]]
angles = [float(x) for x in ref[7:13]]
return Reflection(hkl, angles)
def parse(filename, dtype):
with open(filename, 'r') as f:
for line in f:
if str(line).find('Wavelength') != -1:
wavelength = float(line.split()[1])
energy = 12.39842 / wavelength
if str(line).find('A') != -1 and str(line).find('B') != -1 and str(line).find('C') != -1:
abc = line.split()
a = float(abc[1])
b = float(abc[3])
c = float(abc[5])
if str(line).find('Alpha') != -1 and str(line).find('Beta') != -1 and str(line).find('Gamma') != -1:
abg = line.split()
alpha = float(abg[1])
beta = float(abg[3])
gamma = float(abg[5])
if str(line).find('R0') != -1:
or0 = parse_reflection(line)
if str(line).find('R1') != -1:
or1 = parse_reflection(line)
if str(line).find('Ux') != -1 and str(line).find('Uy') != -1 and str(line).find('Uz') != -1:
uxuyuz = line.split()
ux = float(uxuyuz[1])
uy = float(uxuyuz[3])
uz = float(uxuyuz[5])
if str(line).find('Engine') != -1:
engine_name = line.split()[1]
if str(line).find('Mode') != -1:
mode_name = line.split()[1]
lattice = Lattice(a, b, c, alpha, beta, gamma)
sample = Sample(lattice, or0, or1, ux, uy, uz)
detector = Detector(0)
source = Source(wavelength, energy)
engine = Engine(engine_name, mode_name)
return Diffractometer(dtype, sample, detector, source, engine)
######################
# hight level method #
######################
def ca(config, hkl, engine_name='hkl'):
sample, geometry, detector, engines = new_hkl_diffractometer(config)
engines.init(geometry, detector, sample)
engine = engines.engine_get_by_name(engine_name)
solutions = engine.pseudo_axis_values_set(hkl,
Hkl.UnitEnum.USER)
first_solution = solutions.items()[0]
values = first_solution.geometry_get().axis_values_get(Hkl.UnitEnum.USER)
return Reflection(hkl, values)
def get_UB(config):
sample, geometry, detector, engines = new_hkl_diffractometer(config)
return hkl_matrix_to_numpy(sample.UB_get())
def get_R_and_P(config, values):
sample, geometry, detector, engines = new_hkl_diffractometer(config)
geometry.axis_values_set(values, Hkl.UnitEnum.USER)
R = hkl_matrix_to_numpy(geometry.sample_rotation_get(sample).to_matrix())
P = hkl_matrix_to_numpy(geometry.detector_rotation_get(detector).to_matrix())
return R, P
##############
# Unit tests #
##############
class Polarisation(unittest.TestCase):
def test_petraIII(self):
dtype = "E6C"
# RUBh = kf - ki = (P ki - ki) = (P - I) ki
config = parse(find('crystal.ini'), dtype)
print(config)
gaga = ca(config, [0.5, 14.5, 0.43])
print(gaga)
UB = get_UB(config)
print("UB: ")
print(UB)
# the hkl vectors a*, b*, c* expressed in the laboratory basis for the current Q
# transformation matrix T reciprocal space --> laboratory
# values_w = [0, 34.16414, 79.52420, 0, 0, 38.29633]
# values_w = [0, 35.06068, 80.78517, 0, 0, 43.91934]
# values_w = [0, 36.45961, 81.75533, 0, 0, 49.7139]
# values_w = [0, 38.24551, 82.52447, 0, 0, 55.68957]
# values_w = [0, 40.34955, 83.14900, 0, 0, 61.86603]
# values_w = [0, 42.73321, 83.66607, 0, 0, 68.27333]
# values_w = [0, 45.37981, 84.10117, 0, 0, 74.95312]
# values_w = [0, 48.29079, 84.47230, 0, 0, 81.96226]
values_w = [0, 51.48568, 84.79259, 0, 0, 89.37964] # mu, omega, chi, phi, gamma, delta
R, P = get_R_and_P(config, values_w)
print("R: ")
print(R)
print("P: ")
print(P)
RUB = dot(R, UB)
print("RUB: ")
print(RUB)
astar = dot(RUB, [1, 0, 0])
bstar = dot(RUB, [0, 1, 0])
cstar = dot(RUB, [0, 0, 1])
# transformation matrix: reciprocal space --> laboratory
T = hstack((reshape(astar, (3, 1)),
reshape(bstar, (3, 1)),
reshape(cstar, (3, 1))))
Tbis = vstack((reshape(astar, (1, 3)),
reshape(bstar, (1, 3)),
reshape(cstar, (1, 3))))
# transformation matrix: laboratory --> reciprocal space
Tinv = inv(T)
print('')
# print 'cstar in laboratory frame :',cstar
# print 'cstar in laboratory frame from T:',dot(T, hkl)
# print 'cstar in rec. space from Tinv :',dot(Tinv, dot(T, hkl))
# compute kf
ki = array([1, 0, 0]) * math.pi * 2 / config.source.wavelength
kf = dot(P, ki)
# compute Q
Q = kf - ki
print('')
print('Energy (keV):', config.source)
print('Lattice parameters:', config.sample.lattice)
print('1st orienting reflection:', config.sample.or0.hkl, 'with angles: ', config.sample.or0.values)
print('2nd orienting reflection:', config.sample.or1.hkl, 'with angles: ', config.sample.or1.values)
print('')
print('UB matrix:')
print(UB)
print('')
print('Transformation matrix T(reciprocal space)--> laboratory frame:')
print(T,)
print('')
print('')
print('Transformation matrix T(laboratory frame)--> reciprocal space :')
print(Tinv)
# compute Q
# hkl = [0.5, 6.5, 0.43]
# hkl = [0.5, 7.5, 0.43]
# hkl = [0.5, 8.5, 0.43]
# hkl = [0.5, 9.5, 0.43]
# hkl = [0.5, 10.5, 0.43]
# hkl = [0.5, 11.5, 0.43]
# hkl = [0.5, 12.5, 0.43]
# hkl = [0.5, 13.5, 0.43]
hkl = [0.5, 14.5, 0.43]
'''
print ''
print 'Q in lab. frame from code :', dot(dot(R, UB), hkl), ', normalized:',(dot(dot(R, UB), hkl))/norm(dot(dot(R, UB), hkl)), ', norm:', norm(dot(dot(R, UB), hkl))
print 'Q in lab. frame from T :', dot(T, hkl), ', normalized:', (dot(T, hkl))/norm(dot(T, hkl)), ', norm:', norm(dot(T, hkl))
print 'Q in lab. frame from ki, kf :', Q, ', normalized:', Q/norm(Q),', norm:', norm(Q)
print ''
print 'Q in rec. space from Tinv of T :', dot(Tinv, dot(T, hkl))
print ''
print 'difference factor:',(norm(dot(T, hkl)))/(norm(Q))
print ''
print 'kf',kf,', norm:',norm(kf)
print 'ki',ki,', norm:',norm(ki)
'''
print('')
print('Q in rec. space from Tinv of T :', dot(Tinv, dot(T, hkl)))
print('')
#
# compute u1, u2, u3 in reciprocal space coordinates
# u1,u2,u3 in laboratory frame
u1xyz = ki+kf
u2xyz = cross(ki, kf)
u3xyz = ki-kf
# print '(u1,u2,u3) in laboratory frame:',u1xyz,u2xyz,u3xyz
# u1,u2,u3 in reciprocal space
u1 = dot(Tinv, u1xyz) / norm(dot(Tinv, u1xyz))
u2 = dot(Tinv, u2xyz) / norm(dot(Tinv, u2xyz))
u3 = dot(Tinv, u3xyz) / norm(dot(Tinv, u3xyz))
u1 = dot(Tinv, u1xyz)
u2 = dot(Tinv, u2xyz)
u3 = dot(Tinv, u3xyz)
print('(u1,u2,u3) in reciprocal space from Tinv, unnormalized:',\
u1, u2, u3)
print('(u1,u2,u3) in reciprocal space from Tinv, normalized to 1:',\
dot(Tinv, u1xyz) / norm(dot(Tinv, u1xyz)), \
dot(Tinv, u2xyz) / norm(dot(Tinv, u2xyz)), \
dot(Tinv, u3xyz) / norm(dot(Tinv, u3xyz)))
# print '(u1,u2,u3) in reciprocal space from Tinv:', \
# dot(Tinv, u1xyz), dot(Tinv, u2xyz), dot(Tinv, u3xyz)
print('')
# TRANSFORMATION MATRIX reciprocal lattice basis to u1 u2 u3 basis
ABC = hstack((reshape([1, 0, 0], (3, 1)),
reshape([0, 1, 0], (3, 1)),
reshape([0, 0, 1], (3, 1))))
U = hstack((reshape(u1, (3, 1)),
reshape(u2, (3, 1)),
reshape(u3, (3, 1))))
M = dot(ABC, inv(U))
print('Transformation matrix reciprocal lattice basis to u1 u2 u3 basis:')
print(M)
# keep in order to pass the test
self.assertTrue(True)
if __name__ == '__main__':
unittest.main(verbosity=2)
hkl-5.0.0.2569/tests/bindings/crystal.ini 0000644 0001751 0001751 00000001105 13175570520 020243 0 ustar 00picca picca 0000000 0000000 Created at 2016-06-02 14:12
Crystal EuPtIn4_eh1_ver
Wavelength 1.62751693358
A 4.542 B 16.955 C 7.389
Alpha 90.0 Beta 90.0 Gamma 90.0
R0 0 0.0 8.0 0.0 0 1 0.0 22.31594 89.1377 0.0 0.0 45.15857
R1 1 0.0 12.0 1.0 0 1 0.0 34.96232 78.3139 0.0 0.0 71.8007
Engine hkl
Mode constant_phi_vertical
PsiRef not available in current engine mode
AutoEnergyUpdate 1
U00 1.381 U01 -0.002 U02 -0.054
U10 0.005 U11 0.371 U12 -0.013
U20 0.087 U21 0.006 U22 0.849
Ux 0.878929693221 Uy -3.6132870009 Uz 0.263869539307
SaveDirectory /home/p09user/crystals/
hkl-5.0.0.2569/tests/bindings/Makefile.in 0000644 0001751 0001751 00000067722 13574156672 020162 0 ustar 00picca picca 0000000 0000000 # Makefile.in generated by automake 1.16.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2018 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = { \
if test -z '$(MAKELEVEL)'; then \
false; \
elif test -n '$(MAKE_HOST)'; then \
true; \
elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
true; \
else \
false; \
fi; \
}
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
subdir = tests/bindings
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/gtk-doc.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
SOURCES =
DIST_SOURCES =
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
am__tty_colors_dummy = \
mgn= red= grn= lgn= blu= brg= std=; \
am__color_tests=no
am__tty_colors = { \
$(am__tty_colors_dummy); \
if test "X$(AM_COLOR_TESTS)" = Xno; then \
am__color_tests=no; \
elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
am__color_tests=yes; \
elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
am__color_tests=yes; \
fi; \
if test $$am__color_tests = yes; then \
red='[0;31m'; \
grn='[0;32m'; \
lgn='[1;32m'; \
blu='[1;34m'; \
mgn='[0;35m'; \
brg='[1m'; \
std='[m'; \
fi; \
}
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
test -z "$$files" \
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
$(am__cd) "$$dir" && rm -f $$files; }; \
}
am__recheck_rx = ^[ ]*:recheck:[ ]*
am__global_test_result_rx = ^[ ]*:global-test-result:[ ]*
am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]*
# A command that, given a newline-separated list of test names on the
# standard input, print the name of the tests that are to be re-run
# upon "make recheck".
am__list_recheck_tests = $(AWK) '{ \
recheck = 1; \
while ((rc = (getline line < ($$0 ".trs"))) != 0) \
{ \
if (rc < 0) \
{ \
if ((getline line2 < ($$0 ".log")) < 0) \
recheck = 0; \
break; \
} \
else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
{ \
recheck = 0; \
break; \
} \
else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
{ \
break; \
} \
}; \
if (recheck) \
print $$0; \
close ($$0 ".trs"); \
close ($$0 ".log"); \
}'
# A command that, given a newline-separated list of test names on the
# standard input, create the global log from their .trs and .log files.
am__create_global_log = $(AWK) ' \
function fatal(msg) \
{ \
print "fatal: making $@: " msg | "cat >&2"; \
exit 1; \
} \
function rst_section(header) \
{ \
print header; \
len = length(header); \
for (i = 1; i <= len; i = i + 1) \
printf "="; \
printf "\n\n"; \
} \
{ \
copy_in_global_log = 1; \
global_test_result = "RUN"; \
while ((rc = (getline line < ($$0 ".trs"))) != 0) \
{ \
if (rc < 0) \
fatal("failed to read from " $$0 ".trs"); \
if (line ~ /$(am__global_test_result_rx)/) \
{ \
sub("$(am__global_test_result_rx)", "", line); \
sub("[ ]*$$", "", line); \
global_test_result = line; \
} \
else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
copy_in_global_log = 0; \
}; \
if (copy_in_global_log) \
{ \
rst_section(global_test_result ": " $$0); \
while ((rc = (getline line < ($$0 ".log"))) != 0) \
{ \
if (rc < 0) \
fatal("failed to read from " $$0 ".log"); \
print line; \
}; \
printf "\n"; \
}; \
close ($$0 ".trs"); \
close ($$0 ".log"); \
}'
# Restructured Text title.
am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
# Solaris 10 'make', and several other traditional 'make' implementations,
# pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it
# by disabling -e (using the XSI extension "set +e") if it's set.
am__sh_e_setup = case $$- in *e*) set +e;; esac
# Default flags passed to test drivers.
am__common_driver_flags = \
--color-tests "$$am__color_tests" \
--enable-hard-errors "$$am__enable_hard_errors" \
--expect-failure "$$am__expect_failure"
# To be inserted before the command running the test. Creates the
# directory for the log if needed. Stores in $dir the directory
# containing $f, in $tst the test, in $log the log. Executes the
# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
# passes TESTS_ENVIRONMENT. Set up options for the wrapper that
# will run the test scripts (or their associated LOG_COMPILER, if
# thy have one).
am__check_pre = \
$(am__sh_e_setup); \
$(am__vpath_adj_setup) $(am__vpath_adj) \
$(am__tty_colors); \
srcdir=$(srcdir); export srcdir; \
case "$@" in \
*/*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \
*) am__odir=.;; \
esac; \
test "x$$am__odir" = x"." || test -d "$$am__odir" \
|| $(MKDIR_P) "$$am__odir" || exit $$?; \
if test -f "./$$f"; then dir=./; \
elif test -f "$$f"; then dir=; \
else dir="$(srcdir)/"; fi; \
tst=$$dir$$f; log='$@'; \
if test -n '$(DISABLE_HARD_ERRORS)'; then \
am__enable_hard_errors=no; \
else \
am__enable_hard_errors=yes; \
fi; \
case " $(XFAIL_TESTS) " in \
*[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \
am__expect_failure=yes;; \
*) \
am__expect_failure=no;; \
esac; \
$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
# A shell command to get the names of the tests scripts with any registered
# extension removed (i.e., equivalently, the names of the test logs, with
# the '.log' extension removed). The result is saved in the shell variable
# '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly,
# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
# since that might cause problem with VPATH rewrites for suffix-less tests.
# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
am__set_TESTS_bases = \
bases='$(TEST_LOGS)'; \
bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
bases=`echo $$bases`
RECHECK_LOGS = $(TEST_LOGS)
AM_RECURSIVE_TARGETS = check recheck
TEST_SUITE_LOG = test-suite.log
TEST_EXTENSIONS = @EXEEXT@ .test
LOG_DRIVER = $(SHELL) $(top_srcdir)/config/test-driver
LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
am__set_b = \
case '$@' in \
*/*) \
case '$*' in \
*/*) b='$*';; \
*) b=`echo '$@' | sed 's/\.log$$//'`; \
esac;; \
*) \
b='$*';; \
esac
am__test_logs1 = $(TESTS:=.log)
am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
TEST_LOGS = $(am__test_logs2:.test.log=.log)
TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/config/test-driver
TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
$(TEST_LOG_FLAGS)
am__DIST_COMMON = $(srcdir)/Makefile.in \
$(top_srcdir)/config/test-driver
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ALLOCA = @ALLOCA@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AR = @AR@
ASY = @ASY@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BULLET_CFLAGS = @BULLET_CFLAGS@
BULLET_LIBS = @BULLET_LIBS@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DLLTOOL = @DLLTOOL@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EMACS = @EMACS@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
G3D_CFLAGS = @G3D_CFLAGS@
G3D_LIBS = @G3D_LIBS@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@
GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
GLIB_LIBS = @GLIB_LIBS@
GLIB_MKENUMS = @GLIB_MKENUMS@
GLU_CFLAGS = @GLU_CFLAGS@
GLU_LIBS = @GLU_LIBS@
GNUPLOT = @GNUPLOT@
GOBJECT_CFLAGS = @GOBJECT_CFLAGS@
GOBJECT_LIBS = @GOBJECT_LIBS@
GOBJECT_QUERY = @GOBJECT_QUERY@
GREP = @GREP@
GSL_CFLAGS = @GSL_CFLAGS@
GSL_CONFIG = @GSL_CONFIG@
GSL_LIBS = @GSL_LIBS@
GTKDOC_CHECK = @GTKDOC_CHECK@
GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
GTKDOC_MKPDF = @GTKDOC_MKPDF@
GTKDOC_REBASE = @GTKDOC_REBASE@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_LIBS = @GTK_LIBS@
HDF5_CFLAGS = @HDF5_CFLAGS@
HDF5_LIBS = @HDF5_LIBS@
HTML_DIR = @HTML_DIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
INTROSPECTION_CFLAGS = @INTROSPECTION_CFLAGS@
INTROSPECTION_COMPILER = @INTROSPECTION_COMPILER@
INTROSPECTION_GENERATE = @INTROSPECTION_GENERATE@
INTROSPECTION_GIRDIR = @INTROSPECTION_GIRDIR@
INTROSPECTION_LIBS = @INTROSPECTION_LIBS@
INTROSPECTION_MAKEFILE = @INTROSPECTION_MAKEFILE@
INTROSPECTION_SCANNER = @INTROSPECTION_SCANNER@
INTROSPECTION_TYPELIBDIR = @INTROSPECTION_TYPELIBDIR@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
MAKEINFO = @MAKEINFO@
MANIFEST_TOOL = @MANIFEST_TOOL@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
VMAJ = @VMAJ@
YAML_CFLAGS = @YAML_CFLAGS@
YAML_LIBS = @YAML_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
release_info = @release_info@
runstatedir = @runstatedir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
version_info = @version_info@
TESTS_ENVIRONMENT = env GI_TYPELIB_PATH=$(top_builddir)/hkl DATADIR=$(srcdir) $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la
TESTS = python.py trajectory.py polarisation.py
EXTRA_DIST = $(TESTS) crystal.ini
CLEANFILES = trajectories.pdf
all: all-am
.SUFFIXES:
.SUFFIXES: .log .test .test$(EXEEXT) .trs
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/bindings/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu tests/bindings/Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
tags TAGS:
ctags CTAGS:
cscope cscopelist:
# Recover from deleted '.trs' file; this should ensure that
# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
# both 'foo.log' and 'foo.trs'. Break the recipe in two subshells
# to avoid problems with "make -n".
.log.trs:
rm -f $< $@
$(MAKE) $(AM_MAKEFLAGS) $<
# Leading 'am--fnord' is there to ensure the list of targets does not
# expand to empty, as could happen e.g. with make check TESTS=''.
am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
am--force-recheck:
@:
$(TEST_SUITE_LOG): $(TEST_LOGS)
@$(am__set_TESTS_bases); \
am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
redo_bases=`for i in $$bases; do \
am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
done`; \
if test -n "$$redo_bases"; then \
redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
if $(am__make_dryrun); then :; else \
rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
fi; \
fi; \
if test -n "$$am__remaking_logs"; then \
echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
"recursion detected" >&2; \
elif test -n "$$redo_logs"; then \
am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
fi; \
if $(am__make_dryrun); then :; else \
st=0; \
errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
for i in $$redo_bases; do \
test -f $$i.trs && test -r $$i.trs \
|| { echo "$$errmsg $$i.trs" >&2; st=1; }; \
test -f $$i.log && test -r $$i.log \
|| { echo "$$errmsg $$i.log" >&2; st=1; }; \
done; \
test $$st -eq 0 || exit 1; \
fi
@$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
ws='[ ]'; \
results=`for b in $$bases; do echo $$b.trs; done`; \
test -n "$$results" || results=/dev/null; \
all=` grep "^$$ws*:test-result:" $$results | wc -l`; \
pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \
fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \
skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \
xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
if test `expr $$fail + $$xpass + $$error` -eq 0; then \
success=true; \
else \
success=false; \
fi; \
br='==================='; br=$$br$$br$$br$$br; \
result_count () \
{ \
if test x"$$1" = x"--maybe-color"; then \
maybe_colorize=yes; \
elif test x"$$1" = x"--no-color"; then \
maybe_colorize=no; \
else \
echo "$@: invalid 'result_count' usage" >&2; exit 4; \
fi; \
shift; \
desc=$$1 count=$$2; \
if test $$maybe_colorize = yes && test $$count -gt 0; then \
color_start=$$3 color_end=$$std; \
else \
color_start= color_end=; \
fi; \
echo "$${color_start}# $$desc $$count$${color_end}"; \
}; \
create_testsuite_report () \
{ \
result_count $$1 "TOTAL:" $$all "$$brg"; \
result_count $$1 "PASS: " $$pass "$$grn"; \
result_count $$1 "SKIP: " $$skip "$$blu"; \
result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
result_count $$1 "FAIL: " $$fail "$$red"; \
result_count $$1 "XPASS:" $$xpass "$$red"; \
result_count $$1 "ERROR:" $$error "$$mgn"; \
}; \
{ \
echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \
$(am__rst_title); \
create_testsuite_report --no-color; \
echo; \
echo ".. contents:: :depth: 2"; \
echo; \
for b in $$bases; do echo $$b; done \
| $(am__create_global_log); \
} >$(TEST_SUITE_LOG).tmp || exit 1; \
mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \
if $$success; then \
col="$$grn"; \
else \
col="$$red"; \
test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \
fi; \
echo "$${col}$$br$${std}"; \
echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \
echo "$${col}$$br$${std}"; \
create_testsuite_report --maybe-color; \
echo "$$col$$br$$std"; \
if $$success; then :; else \
echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \
if test -n "$(PACKAGE_BUGREPORT)"; then \
echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \
fi; \
echo "$$col$$br$$std"; \
fi; \
$$success || exit 1
check-TESTS:
@list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list
@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
@set +e; $(am__set_TESTS_bases); \
log_list=`for i in $$bases; do echo $$i.log; done`; \
trs_list=`for i in $$bases; do echo $$i.trs; done`; \
log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
exit $$?;
recheck: all
@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
@set +e; $(am__set_TESTS_bases); \
bases=`for i in $$bases; do echo $$i; done \
| $(am__list_recheck_tests)` || exit 1; \
log_list=`for i in $$bases; do echo $$i.log; done`; \
log_list=`echo $$log_list`; \
$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
am__force_recheck=am--force-recheck \
TEST_LOGS="$$log_list"; \
exit $$?
python.py.log: python.py
@p='python.py'; \
b='python.py'; \
$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
--log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT)
trajectory.py.log: trajectory.py
@p='trajectory.py'; \
b='trajectory.py'; \
$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
--log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT)
polarisation.py.log: polarisation.py
@p='polarisation.py'; \
b='polarisation.py'; \
$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
--log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT)
.test.log:
@p='$<'; \
$(am__set_b); \
$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
--log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT)
@am__EXEEXT_TRUE@.test$(EXEEXT).log:
@am__EXEEXT_TRUE@ @p='$<'; \
@am__EXEEXT_TRUE@ $(am__set_b); \
@am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \
@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT)
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
distdir-am: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
$(MAKE) $(AM_MAKEFLAGS) check-TESTS
check: check-am
all-am: Makefile
installdirs:
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
-test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am:
.MAKE: check-am install-am install-strip
.PHONY: all all-am check check-TESTS check-am clean clean-generic \
clean-libtool cscopelist-am ctags-am distclean \
distclean-generic distclean-libtool distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-generic \
mostlyclean-libtool pdf pdf-am ps ps-am recheck tags-am \
uninstall uninstall-am
.PRECIOUS: Makefile
ipython:
env GI_TYPELIB_PATH=$(top_builddir)/hkl $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la ipython3 -i -c "from gi.repository import Hkl"
gdb:
env GI_TYPELIB_PATH=$(top_builddir)/hkl $(LIBTOOL) --mode=execute -dlopen $(top_builddir)/hkl/libhkl.la gdb python3
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
hkl-5.0.0.2569/tests/hkl-unit-t.c 0000644 0001751 0001751 00000004517 13447477011 016441 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#include "hkl-unit-private.h"
static void compatible(void)
{
int res = TRUE;
res &= DIAG(hkl_unit_compatible(&hkl_unit_angle_deg, &hkl_unit_angle_rad));
res &= DIAG(!hkl_unit_compatible(&hkl_unit_angle_deg, &hkl_unit_length_nm));
res &= DIAG(!hkl_unit_compatible(&hkl_unit_angle_rad, &hkl_unit_length_nm));
/* mrad */
res &= DIAG(hkl_unit_compatible(&hkl_unit_angle_mrad, &hkl_unit_angle_deg));
res &= DIAG(hkl_unit_compatible(&hkl_unit_angle_mrad, &hkl_unit_angle_rad));
res &= DIAG(hkl_unit_compatible(&hkl_unit_angle_deg, &hkl_unit_angle_mrad));
res &= DIAG(hkl_unit_compatible(&hkl_unit_angle_rad, &hkl_unit_angle_mrad));
res &= DIAG(!hkl_unit_compatible(&hkl_unit_angle_mrad, &hkl_unit_length_nm));
res &= DIAG(!hkl_unit_compatible(&hkl_unit_length_nm, &hkl_unit_angle_mrad));
res &= DIAG(hkl_unit_compatible(NULL, NULL));
ok(res == TRUE, __func__);
}
static void factor(void)
{
is_double(HKL_DEGTORAD, hkl_unit_factor(&hkl_unit_angle_deg, &hkl_unit_angle_rad), HKL_EPSILON, __func__);
is_double(1e3, hkl_unit_factor(&hkl_unit_angle_rad, &hkl_unit_angle_mrad), HKL_EPSILON, __func__);
is_double(1.0,
hkl_unit_factor(&hkl_unit_angle_rad, &hkl_unit_angle_mrad) * hkl_unit_factor(&hkl_unit_angle_mrad, &hkl_unit_angle_rad),
HKL_EPSILON, __func__);
}
int main(void)
{
plan(4);
compatible();
factor();
return 0;
}
hkl-5.0.0.2569/tests/hkl-detector-t.c 0000644 0001751 0001751 00000006353 13447477011 017273 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include "hkl-axis-private.h" /* temporary */
#include "hkl-detector-private.h"
static void new(void)
{
HklDetector *detector1;
HklDetector *detector2;
detector1 = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
ok(1 == detector1->idx, __func__);
ok(NULL == detector1->holder, __func__);
detector2 = hkl_detector_new_copy(detector1);
ok(detector1->idx == detector2->idx, __func__);
ok(detector1->holder == detector2->holder, __func__);
hkl_detector_free(detector1);
hkl_detector_free(detector2);
}
static void attach_to_holder(void)
{
HklDetector *detector = NULL;
HklGeometry *geometry = NULL;
HklHolder *holder = NULL;
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
geometry = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
holder = hkl_geometry_add_holder(geometry);
hkl_detector_attach_to_holder(detector, holder);
ok(1 == detector->idx, __func__);
ok(holder == detector->holder, __func__);
hkl_geometry_free(geometry);
hkl_detector_free(detector);
}
static void compute_kf(void)
{
int res = TRUE;
HklDetector *detector = NULL;
HklGeometry *geometry = NULL;
HklHolder *holder = NULL;
HklVector kf;
HklVector kf_ref = {{0, HKL_TAU / HKL_SOURCE_DEFAULT_WAVE_LENGTH, 0}};
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
geometry = hkl_geometry_new(NULL, &hkl_geometry_operations_defaults);
/* add a fake first holder */
holder = hkl_geometry_add_holder(geometry);
/* for now all detectors MUST be connected to the second
* holder. We will decide about a better API to connect
* geometry and detector */
holder = hkl_geometry_add_holder(geometry);
hkl_holder_add_rotation(holder, "a", 1, 0, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(holder, "b", 0, 1, 0, &hkl_unit_angle_deg);
res &= DIAG(hkl_parameter_value_set(darray_item(geometry->axes, 0), M_PI_2, HKL_UNIT_DEFAULT, NULL));
res &= DIAG(hkl_parameter_value_set(darray_item(geometry->axes, 1), M_PI_2, HKL_UNIT_DEFAULT, NULL));
hkl_detector_attach_to_holder(detector, holder);
hkl_detector_compute_kf(detector, geometry, &kf);
res &= DIAG(0 == hkl_vector_cmp(&kf_ref, &kf));
ok(res, __func__);
hkl_geometry_free(geometry);
hkl_detector_free(detector);
}
int main(void)
{
plan(7);
new();
attach_to_holder();
compute_kf();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-soleil-sixs-med-t.c 0000644 0001751 0001751 00000014743 13447477011 022664 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2010 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#include "hkl-axis-private.h" /* temporary */
#define GET_AXIS(_geometries, _name) hkl_parameter_value_get( \
hkl_geometry_axis_get( \
hkl_geometry_list_item_geometry_get( \
hkl_geometry_list_items_first_get((geometries))), \
#_name, NULL), HKL_UNIT_USER)
#define GET_GAMMA(geometries) hkl_parameter_value_get( \
hkl_geometry_axis_get( \
hkl_geometry_list_item_geometry_get( \
hkl_geometry_list_items_first_get((geometries))), \
"gamma", NULL), HKL_UNIT_USER)
/* tests */
static void qper_qpar(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
double qper_qpar[2];
double gamma;
HklGeometryList *geometries;
static struct Sample gaas = {
.name = "test",
.lattice=Cubic(1.54),
.ux = -90.0 * HKL_DEGTORAD,
.uy = 0.0 * HKL_DEGTORAD,
.uz = 0.0 * HKL_DEGTORAD,
};
struct Geometry gconfig = SoleilSixsMed2_3(1.54, 0., 0.1, 0., 0., 90., 0.);
geometry = newGeometry(gconfig);
engines = newEngines(gconfig);
sample = newSample(gaas);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "qper_qpar", NULL);
/* the init part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
/* gamma must be positif */
qper_qpar[0] = 0.1;
qper_qpar[1] = 4.;
geometries = hkl_engine_pseudo_axis_values_set(engine, qper_qpar, ARRAY_SIZE(qper_qpar),
HKL_UNIT_DEFAULT, NULL);
if(geometries){
gamma = GET_GAMMA(geometries);
is_double(2.61077, gamma, HKL_EPSILON * 10, __func__);
hkl_geometry_list_free(geometries);
}
/* gamma must be negatif */
qper_qpar[0] = -0.1;
qper_qpar[1] = 4.;
geometries = hkl_engine_pseudo_axis_values_set(engine, qper_qpar, ARRAY_SIZE(qper_qpar),
HKL_UNIT_DEFAULT, NULL);
if(geometries){
gamma = GET_GAMMA(geometries);
is_double(-2.7956354, gamma, HKL_EPSILON * 10, __func__);
hkl_geometry_list_free(geometries);
}
ok(res, __func__);
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void med_2_3(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *hkl;
HklGeometry *geometry;
HklGeometryList *geometries;
HklDetector *detector;
HklSample *sample;
static double hkl_p[] = {1.95, 2, 6};
static struct Sample gaas = {
.name = "GaAs",
.lattice = Hexagonal(4.759, 12.992),
.ux = -90.59 * HKL_DEGTORAD,
.uy = -9.97 * HKL_DEGTORAD,
.uz = 176.35 * HKL_DEGTORAD,
};
static struct Geometry gconfig = SoleilSixsMed2_3(1.54980,
0, 1, -14.27, 99.62, 60.98, 0);
/* Wavelength 1.54980 */
/* Mode mu_fixed */
/* Ux -90.59 Uy -9.97 Uz 176.35 */
/* A 4.759 B 4.759 C 12.992 */
/* Alpha 90 Beta 90 Gamma 120 */
geometry = newGeometry(gconfig);
engines = newEngines(gconfig);
sample = newSample(gaas);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
hkl = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
res &= DIAG(hkl_engine_current_mode_set(hkl, "mu_fixed", NULL));
/* hkl 1.95, 2, 6 (should not fail) */
geometries = hkl_engine_pseudo_axis_values_set(hkl,
hkl_p, ARRAY_SIZE(hkl_p),
HKL_UNIT_DEFAULT, NULL);
res &= DIAG((geometries != NULL));
hkl_geometry_list_free(geometries);
ok(res == TRUE, __func__);
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void med_2_3_v2(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *hkl;
HklGeometry *geometry;
HklGeometryList *geometries;
HklDetector *detector;
HklSample *sample;
static double hkl_p[] = {1.95, 2, 6};
static double values[] = {1};
static struct Sample gaas = {
.name = "GaAs",
.lattice = Hexagonal(4.759, 12.992),
.ux = -90.59 * HKL_DEGTORAD,
.uy = -9.97 * HKL_DEGTORAD,
.uz = 176.35 * HKL_DEGTORAD,
};
static struct Geometry gconfig = SoleilSixsMed2_3_v2(1.54980,
1, -14.27, 99.62, 60.98, 10);
/* Wavelength 1.54980 */
/* Mode mu_fixed */
/* Ux -90.59 Uy -9.97 Uz 176.35 */
/* A 4.759 B 4.759 C 12.992 */
/* Alpha 90 Beta 90 Gamma 120 */
geometry = newGeometry(gconfig);
engines = newEngines(gconfig);
sample = newSample(gaas);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
hkl = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
/* hkl 1.95, 2, 6 (should not fail) */
geometries = hkl_engine_pseudo_axis_values_set(hkl,
hkl_p, ARRAY_SIZE(hkl_p),
HKL_UNIT_DEFAULT, NULL);
res &= DIAG((geometries != NULL));
/* check that eta_a did not moved */
is_double(10.0, GET_AXIS(geometries, eta_a), HKL_EPSILON * 10, __func__);
hkl_geometry_list_free(geometries);
/* now make it move */
res &= DIAG(hkl_engine_list_parameters_values_set(engines,
values, ARRAY_SIZE(values),
HKL_UNIT_USER, NULL));
geometries = hkl_engine_pseudo_axis_values_set(hkl,
hkl_p, ARRAY_SIZE(hkl_p),
HKL_UNIT_DEFAULT, NULL);
is_double(-80.079231, GET_AXIS(geometries, eta_a), HKL_EPSILON * 10, __func__);
hkl_geometry_list_free(geometries);
ok(res == TRUE, __func__);
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
int main(void)
{
plan(7);
qper_qpar();
med_2_3();
med_2_3_v2();
return 0;
}
hkl-5.0.0.2569/tests/Makefile.am 0000644 0001751 0001751 00000002761 13223175310 016321 0 ustar 00picca picca 0000000 0000000 SUBDIRS = tap .
if HAVE_INTROSPECTION
SUBDIRS += bindings
endif
all_tests = \
hkl-unit-t \
hkl-bench-t \
hkl-axis-t \
hkl-quaternion-t \
hkl-interval-t \
hkl-sample-t \
hkl-lattice-t \
hkl-source-t \
hkl-detector-t \
hkl-matrix-t \
hkl-vector-t \
hkl-geometry-t \
hkl-parameter-t \
hkl-pseudoaxis-t \
hkl-pseudoaxis-e4cv-t \
hkl-pseudoaxis-e4ch-t \
hkl-pseudoaxis-e6c-t \
hkl-pseudoaxis-k4cv-t \
hkl-pseudoaxis-k6c-t \
hkl-pseudoaxis-soleil-sirius-kappa-t \
hkl-pseudoaxis-soleil-sixs-med-t \
hkl-pseudoaxis-zaxis-t
AM_CPPFLAGS = -Wextra -D_DEFAULT_SOURCE \
-I$(top_srcdir) \
-I$(top_srcdir)/hkl \
-I$(top_srcdir)/tests \
$(GLIB_CFLAGS) \
$(GOBJECT_CFLAGS) \
$(GSL_CFLAGS)
AM_LDFLAGS = -Wl,--whole-archive,$(top_builddir)/hkl/.libs/libhkl.a,--no-whole-archive
LDADD = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a \
$(GLIB_LIBS) \
$(GOBJECT_LIBS) \
$(GSL_LIBS)
if HKL3D
all_tests += hkl3d-test-t
# force linkage with g++
nodist_EXTRA_hkl3d_test_t_SOURCES = dummy.cxx
AM_CPPFLAGS += -I$(top_srcdir)/hkl3d \
$(G3D_CFLAGS) \
$(BULLET_CFLAGS)
LDADD += $(top_builddir)/hkl3d/libhkl3d.la \
$(BULLET_LIBS)
endif
check_PROGRAMS = runtests $(all_tests)
## tap tests
check-local: $(check_PROGRAMS)
./runtests -v -s $(abs_top_srcdir) $(all_tests)
# Support for GNU Flymake, in Emacs.
check-syntax: AM_CFLAGS += -fsyntax-only -pipe
check-syntax:
test -z "$(CHK_SOURCES)" || $(COMPILE) $(CHK_SOURCES)
.PHONY: check-syntax
hkl-5.0.0.2569/tests/hkl-vector-t.c 0000644 0001751 0001751 00000014572 13447477011 016766 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include "hkl-vector-private.h" /* use to test also the private API */
static void init(void)
{
HklVector v;
hkl_vector_init(&v, 1, 2, 3);
is_double(1., v.data[0], HKL_EPSILON, __func__);
is_double(2., v.data[1], HKL_EPSILON, __func__);
is_double(3., v.data[2], HKL_EPSILON, __func__);
}
static void cmp(void)
{
HklVector v1 = {{0.0, 1.0, 2.0}};
HklVector v2 = {{1.0, 2.0, 3.0}};
ok(0 == hkl_vector_cmp(&v1, &v1), __func__);
ok(1 == hkl_vector_cmp(&v1, &v2), __func__);
}
static void is_opposite(void)
{
HklVector v_ref = {{0, 1, 2}};
HklVector v1 = {{1, 2, 3}};
HklVector v2 = {{0, -1, -2}};
ok(FALSE == hkl_vector_is_opposite(&v_ref, &v1), __func__);
ok(TRUE == hkl_vector_is_opposite(&v_ref, &v2), __func__);
}
static void norm2(void)
{
HklVector v1 = {{0.0, 1.0, 2.0}};
HklVector v2 = {{-1.0, 1.0, 2.0}};
is_double(sqrt(5.0), hkl_vector_norm2(&v1), HKL_EPSILON, __func__);
is_double(sqrt(6.0), hkl_vector_norm2(&v2), HKL_EPSILON, __func__);
}
static void normalize(void)
{
HklVector v_ref = {{1. /sqrt(2.), 1. / sqrt(2.), 0.}};
HklVector v = {{1., 1., 0.}};
hkl_vector_normalize(&v);
ok(0 == hkl_vector_cmp(&v_ref, &v), __func__);
}
static void scalar_product(void)
{
HklVector v = {{0.0, 1.0, 2.0}};
double scalar = hkl_vector_scalar_product(&v, &v);
is_double( 5.0, scalar, HKL_EPSILON, __func__ );
}
static void vectorial_product(void)
{
HklVector v = {{0.0, 1.0, 2.0}};
HklVector v1 = {{1.0, 2.0, 3.0}};
HklVector v_ref = {{-1.0, 2.0, -1.0}};
hkl_vector_vectorial_product(&v, &v1);
ok(0 == hkl_vector_cmp(&v_ref, &v), __func__);
}
static void angle(void)
{
double angle;
HklVector v = {{1., 0., 0.}};
HklVector v1 = {{1., 1., 0.}};
HklVector v2 = {{1., 1., .5}};
HklVector v3 = {{1., .5, -1}};
HklVector v4 = {{0., 1., 0.}};
HklVector v5 = {{0., -1., 0.}};
angle = hkl_vector_angle(&v, &v);
is_double(0., angle, HKL_EPSILON, __func__);
angle = hkl_vector_angle(&v, &v1);
is_double(acos(1./sqrt(2.)), angle, HKL_EPSILON, __func__);
angle = hkl_vector_angle(&v2, &v3);
is_double(acos(1./2.25), angle, HKL_EPSILON, __func__);
angle = hkl_vector_angle(&v, &v4);
is_double(90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
angle = hkl_vector_angle(&v, &v5);
is_double(90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
}
static void oriented_angle(void)
{
double angle;
HklVector v = {{1., 0., 0.}};
HklVector v1 = {{1., 1., 0.}};
HklVector v2 = {{0., 1., 0.}};
HklVector v3 = {{0., -1., 0.}};
HklVector ref = {{0, 0, 1}};
angle = hkl_vector_oriented_angle(&v, &v, &ref);
is_double(0., angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle(&v, &v1, &ref);
is_double(acos(1./sqrt(2.)), angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle(&v, &v2, &ref);
is_double(90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle(&v, &v3, &ref);
is_double(-90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
}
static void oriented_angle_points(void)
{
double angle;
HklVector v = {{1., 0., 1.}};
HklVector v1 = {{1., 1., 1.}};
HklVector v2 = {{0., 1., 1.}};
HklVector v3 = {{0., -1., 1.}};
HklVector ref = {{0, 0, 1}};
angle = hkl_vector_oriented_angle_points(&v, &ref, &v, &ref);
is_double(0., angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle_points(&v, &ref, &v1, &ref);
is_double(acos(1./sqrt(2.)), angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle_points(&v, &ref, &v2, &ref);
is_double(90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
angle = hkl_vector_oriented_angle_points(&v, &ref, &v3, &ref);
is_double(-90 * HKL_DEGTORAD, angle, HKL_EPSILON, __func__);
}
static void rotated_around_vector(void)
{
HklVector x = {{1, 0, 0}};
HklVector z = {{0, 0, 1}};
HklVector y_ref = {{0, 1, 0}};
hkl_vector_rotated_around_vector(&x, &z, 90*HKL_DEGTORAD);
ok(0 == hkl_vector_cmp(&y_ref, &x), __func__);
}
static void rotated_around_line(void)
{
HklVector x = {{1, 0, 0}};
HklVector c1 = {{0, 0, 0}};
HklVector c2 = {{0, 0, 1}};
HklVector x_ref = {{1, 0, 0}};
HklVector y_ref = {{0, 1, 0}};
hkl_vector_rotated_around_line(&x, 0*HKL_DEGTORAD, &c1, &c2);
ok(0 == hkl_vector_cmp(&x_ref, &x), __func__);
hkl_vector_rotated_around_line(&x, 90*HKL_DEGTORAD, &c1, &c2);
ok(0 == hkl_vector_cmp(&y_ref, &x), __func__);
}
static void times_matrix(void)
{
HklMatrix *m = hkl_matrix_new_full(1.0, 3.0,-2.0,
10.0, 5.0, 5.0,
-3.0, 2.0, 0.0);
HklVector v = {{1.0, 2.0, 3.0}};
HklVector v_ref = {{12., 19., 8.}};
hkl_vector_times_matrix(&v, m);
ok(0 == hkl_vector_cmp(&v_ref, &v), __func__);
hkl_matrix_free(m);
}
static void project_on_plan(void)
{
HklVector v;
HklVector v_ref = {{1, 0, 0}};
HklVector v1_ref = {{1, 0, 1}};
HklVector v2_ref = {{1, 0, -2}};
HklVector v1 = {{1, 0, 2}};
HklVector plan = {{0, 0, 1}};
HklVector point1 = {{0, 0, 1}};
HklVector point2 = {{0, 0, -2}};
v = v1;
hkl_vector_project_on_plan(&v, &plan);
ok(0 == hkl_vector_cmp(&v_ref, &v), __func__);
v = v1;
hkl_vector_project_on_plan_with_point(&v, &plan, &point1);
ok(0 == hkl_vector_cmp(&v1_ref, &v), __func__);
v = v1;
hkl_vector_project_on_plan_with_point(&v, &plan, &point2);
ok(0 == hkl_vector_cmp(&v2_ref, &v), __func__);
}
int main(void)
{
plan(32);
init();
cmp();
is_opposite();
norm2();
normalize();
scalar_product();
vectorial_product();
angle();
oriented_angle();
oriented_angle_points();
rotated_around_vector();
rotated_around_line();
times_matrix();
project_on_plan();
return 0;
}
hkl-5.0.0.2569/tests/hkl-interval-t.c 0000644 0001751 0001751 00000015741 13447477011 017307 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#define _GNU_SOURCE
#include "hkl.h"
#include
#include
#include "hkl-interval-private.h"
static void cmp(void)
{
HklInterval interval_ref = {-1, 1};
HklInterval interval;
interval = interval_ref;
ok(FALSE == hkl_interval_cmp(&interval_ref, &interval), __func__);
}
static void plus_interval(void)
{
HklInterval i_ref = {-2, 8};
HklInterval i1 = {-1, 4};
HklInterval i2 = {-1, 4};
hkl_interval_plus_interval(&i1, &i2);
ok(FALSE == hkl_interval_cmp(&i_ref, &i1), __func__);
}
static void plus_double(void)
{
HklInterval i_ref = {-1, 9};
HklInterval i1 = {-2, 8};
hkl_interval_plus_double(&i1, 1);
ok(FALSE == hkl_interval_cmp(&i_ref, &i1), __func__);
}
static void times_interval(void)
{
HklInterval i_ref = {-9, 36};
HklInterval i1 = {-1, 9};
HklInterval i2 = {-1, 4};
hkl_interval_times_interval(&i1, &i2);
ok(FALSE == hkl_interval_cmp(&i_ref, &i1), __func__);
}
static void times_double(void)
{
HklInterval i_ref = {-108, 27};
HklInterval i1 = {-9, 36};
hkl_interval_times_double(&i1, -3);
ok(FALSE == hkl_interval_cmp(&i_ref, &i1), __func__);
}
static void divides_double(void)
{
HklInterval i_ref = {-9, 36};
HklInterval i1 = {-108, 27};
hkl_interval_divides_double(&i1, -3);
ok(FALSE == hkl_interval_cmp(&i_ref, &i1), __func__);
}
static void contain_zero(void)
{
HklInterval i1 = {-9, 36};
HklInterval i2 = {-108, -27};
ok(TRUE == hkl_interval_contain_zero(&i1), __func__);
ok(FALSE == hkl_interval_contain_zero(&i2), __func__);
}
static void cosinus(void)
{
/* we will test all 16 cases. */
/* we devide the trigonometric circle in 4 from quaters */
/* 0 [0, pi/2[ */
/* 1 [pi/2, pi[ */
/* 2 [pi, 3*pi/2[ */
/* 3 [3*pi/2, 2*pi[ */
HklInterval i_ref;
HklInterval i;
double min;
double max;
#define COS(a, b, min_ref, max_ref) do { \
i.min = min = a * HKL_DEGTORAD; \
i.max = max = b * HKL_DEGTORAD; \
i_ref.min = min_ref; \
i_ref.max = max_ref; \
hkl_interval_cos(&i); \
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__); \
} while(0)
/* 1st max(0) */
/* min(0) */
COS(10, 14, cos(max), cos(min));
/* min(3) */
COS(-15, 14,cos(min), 1);
/* min(2) */
COS(-95, 14, cos(min), 1);
/* min(1) */
COS(-215, 14, -1, 1);
/* 2nd max(1) */
/* min(0) */
COS(10, 100, cos(max), cos(min));
/* min(3) */
COS(-20, 100, cos(max), 1);
/* min(2) */
COS(-110, 100, cos(min), 1);
COS(-95, 100, cos(max), 1);
/* min(1) */
COS(-190, 100,-1, 1);
/* 3rd max(2) */
/* min(0) */
COS(10, 190, -1, cos(min));
/* min(3) */
COS(95, 190, -1, cos(min));
COS(175, 190, -1, cos(max));
/* min(2) */
COS(185, 190, cos(min), cos(max));
COS(-95, 190, -1, 1);
/* min(1) */
COS(-45, 190, -1, 1);
/* 4th max(3) */
/* min(0) */
COS(-350, -30, -1, cos(min));
COS(-310, -30, -1, cos(max));
/* min(3) */
COS(-40, -30, cos(min), cos(max));
COS(-370, -30, -1, 1);
/* min(2) */
COS(-100, -30, cos(min), cos(max));
/* min(1) */
COS(-190, -30, -1, cos(max));
}
static void acosinus(void)
{
HklInterval i_ref = {acos(.5), acos(-.5)};
HklInterval i = {-.5, .5};
hkl_interval_acos(&i);
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__);
}
static void sinus(void)
{
/* we will test all 16 cases. */
/* we devide the trigonometric circle in 4 from quaters */
/* 0 [0, pi/2[ */
/* 1 [pi/2, pi[ */
/* 2 [pi, 3*pi/2[ */
/* 3 [3*pi/2, 2*pi[ */
HklInterval i_ref;
HklInterval i;
double min, max;
#define SIN(a,b, min_ref, max_ref) do { \
i.min = min = a * HKL_DEGTORAD; \
i.max = max = b * HKL_DEGTORAD; \
i_ref.min = min_ref; \
i_ref.max = max_ref; \
hkl_interval_sin(&i); \
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__); \
} while(0)
/* 1st max(0) */
/* min(0) */
SIN(10, 14,sin(min), sin(max));
SIN(-275, 14, -1, 1);
/* min(3) */
SIN(-15, 14, sin(min), sin(max));
/* min(2) */
SIN(-95, 14, -1, sin(max));
/* min(1) */
SIN(-185, 14, -1, sin(max));
SIN(-215, 14, -1, sin(min));
/* 2nd max(1) */
/* min(0) */
SIN(10, 100, sin(min), 1);
SIN(85, 100, sin(max), 1);
/* min(3) */
SIN(-20, 100, sin(min), 1);
/* min(2) */
SIN(-110, 100, -1, 1);
/* min(1) */
SIN(-190, 100, -1, 1);
SIN(95, 100, sin(max), sin(min));
/* 3rd max(2) */
/* min(0) */
SIN(10, 190, sin(max), 1);
/* min(3) */
SIN(95, 190, sin(max), sin(min));
/* min(2) */
SIN(-95, 190, -1, 1);
SIN(185, 190, sin(max), sin(min));
/* min(1) */
SIN(-5, 190, sin(max), 1);
SIN(-45, 190, sin(min), 1);
/* 4th max(3) */
/* min(0); */
SIN(-350, -30, -1, 1);
/* min(3); */
SIN(-40, -30, sin(min), sin(max));
SIN(-370, -30, -1, 1);
/* min(2); */
SIN(-100, -30, -1, sin(max));
SIN(-170, -30, -1, sin(min));
/* min(1); */
SIN(-190, -30, -1, sin(min));
}
static void asinus(void)
{
HklInterval i_ref = {asin(-.5), asin(.5)};
HklInterval i = {-.5, .5};
hkl_interval_asin(&i);
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__);
}
static void tangeante(void)
{
HklInterval i;
HklInterval i_ref;
double min, max;
#define TAN(a,b, min_ref, max_ref) do { \
i.min = min = a * HKL_DEGTORAD; \
i.max = max = b * HKL_DEGTORAD; \
i_ref.min = min_ref; \
i_ref.max = max_ref; \
hkl_interval_tan(&i); \
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__); \
} while(0)
TAN(-100, -89, -INFINITY, INFINITY);
/*
// The limit case is not yet ok
TAN(-100, 11, 12, -90);
r_ref.set(-hklconstantmathinfinity, tan(current), tan(consign), hklconstantmathinfinity);
ok(r_ref, r);
*/
}
static void atangeante(void)
{
HklInterval i_ref = {atan(-10.), atan(10)};
HklInterval i = {-10, 10};
hkl_interval_atan(&i);
ok(FALSE == hkl_interval_cmp(&i_ref, &i), __func__);
}
static void length(void)
{
HklInterval interval;
interval.min = 10;
interval.max = 11;
is_double(1., hkl_interval_length(&interval), HKL_EPSILON, __func__);
interval.min = -11;
interval.max = -10;
is_double(1., hkl_interval_length(&interval), HKL_EPSILON, __func__);
}
int main(void)
{
plan(59);
cmp();
plus_interval();
plus_double();
times_interval();
times_double();
divides_double();
contain_zero();
cosinus();
acosinus();
sinus();
asinus();
tangeante();
atangeante();
length();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-zaxis-t.c 0000644 0001751 0001751 00000004671 13447477011 021003 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
static void solution(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklGeometryList *geometries;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {1, 1, 0};
static struct Sample sconf = {
.name = "test",
.lattice = Cubic(5.432),
.ux = -90.0 * HKL_DEGTORAD,
.uy = 0.0 * HKL_DEGTORAD,
.uz = 0.0 * HKL_DEGTORAD,
};
struct Geometry gconf = Zaxis(0.842, 1., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(sconf);
/* use a 0D detector */
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
/* select the hkl pseudo axis */
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
/* compute the 1 1 0 */
geometries = hkl_engine_pseudo_axis_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if (geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, 3));
}
hkl_geometry_list_free(geometries);
}else
res = FALSE;
if(!res)
hkl_engine_fprintf(stdout, engine);
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
ok(res == TRUE, "solution");
}
int main(void)
{
plan(1);
solution();
return 0;
}
hkl-5.0.0.2569/tests/runtests.c 0000644 0001751 0001751 00000125004 13175570520 016324 0 ustar 00picca picca 0000000 0000000 /*
* Run a set of tests, reporting results.
*
* Usage:
*
* runtests [-hv] [-b ] [-s ] -l
* runtests [-hv] [-b ] [-s ] [ ...]
* runtests -o [-h] [-b ] [-s ]
*
* In the first case, expects a list of executables located in the given file,
* one line per executable. For each one, runs it as part of a test suite,
* reporting results. In the second case, use the same infrastructure, but
* run only the tests listed on the command line.
*
* Test output should start with a line containing the number of tests
* (numbered from 1 to this number), optionally preceded by "1..", although
* that line may be given anywhere in the output. Each additional line should
* be in the following format:
*
* ok
* not ok
* ok # skip
* not ok # todo
*
* where is the number of the test. An optional comment is permitted
* after the number if preceded by whitespace. ok indicates success, not ok
* indicates failure. "# skip" and "# todo" are a special cases of a comment,
* and must start with exactly that formatting. They indicate the test was
* skipped for some reason (maybe because it doesn't apply to this platform)
* or is testing something known to currently fail. The text following either
* "# skip" or "# todo" and whitespace is the reason.
*
* As a special case, the first line of the output may be in the form:
*
* 1..0 # skip some reason
*
* which indicates that this entire test case should be skipped and gives a
* reason.
*
* Any other lines are ignored, although for compliance with the TAP protocol
* all lines other than the ones in the above format should be sent to
* standard error rather than standard output and start with #.
*
* This is a subset of TAP as documented in Test::Harness::TAP or
* TAP::Parser::Grammar, which comes with Perl.
*
* If the -o option is given, instead run a single test and display all of its
* output. This is intended for use with failing tests so that the person
* running the test suite can get more details about what failed.
*
* If built with the C preprocessor symbols SOURCE and BUILD defined, C TAP
* Harness will export those values in the environment so that tests can find
* the source and build directory and will look for tests under both
* directories. These paths can also be set with the -b and -s command-line
* options, which will override anything set at build time.
*
* If the -v option is given, or the C_TAP_VERBOSE environment variable is set,
* display the full output of each test as it runs rather than showing a
* summary of the results of each test.
*
* Any bug reports, bug fixes, and improvements are very much welcome and
* should be sent to the e-mail address below. This program is part of C TAP
* Harness .
*
* Copyright 2000, 2001, 2004, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
* 2014, 2015 Russ Allbery
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/* Required for fdopen(), getopt(), and putenv(). */
#if defined(__STRICT_ANSI__) || defined(PEDANTIC)
# ifndef _XOPEN_SOURCE
# define _XOPEN_SOURCE 500
# endif
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* sys/time.h must be included before sys/resource.h on some platforms. */
#include
/* AIX 6.1 (and possibly later) doesn't have WCOREDUMP. */
#ifndef WCOREDUMP
# define WCOREDUMP(status) ((unsigned)(status) & 0x80)
#endif
/*
* POSIX requires that these be defined in , but they're not always
* available. If one of them has been defined, all the rest almost certainly
* have.
*/
#ifndef STDIN_FILENO
# define STDIN_FILENO 0
# define STDOUT_FILENO 1
# define STDERR_FILENO 2
#endif
/*
* Used for iterating through arrays. Returns the number of elements in the
* array (useful for a < upper bound in a for loop).
*/
#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
/*
* The source and build versions of the tests directory. This is used to set
* the SOURCE and BUILD environment variables and find test programs, if set.
* Normally, this should be set as part of the build process to the test
* subdirectories of $(abs_top_srcdir) and $(abs_top_builddir) respectively.
*/
#ifndef SOURCE
# define SOURCE NULL
#endif
#ifndef BUILD
# define BUILD NULL
#endif
/* Test status codes. */
enum test_status {
TEST_FAIL,
TEST_PASS,
TEST_SKIP,
TEST_INVALID
};
/* Really, just a boolean, but this is more self-documenting. */
enum test_verbose {
CONCISE = 0,
VERBOSE = 1
};
/* Indicates the state of our plan. */
enum plan_status {
PLAN_INIT, /* Nothing seen yet. */
PLAN_FIRST, /* Plan seen before any tests. */
PLAN_PENDING, /* Test seen and no plan yet. */
PLAN_FINAL /* Plan seen after some tests. */
};
/* Error exit statuses for test processes. */
#define CHILDERR_DUP 100 /* Couldn't redirect stderr or stdout. */
#define CHILDERR_EXEC 101 /* Couldn't exec child process. */
#define CHILDERR_STDIN 102 /* Couldn't open stdin file. */
#define CHILDERR_STDERR 103 /* Couldn't open stderr file. */
/* Structure to hold data for a set of tests. */
struct testset {
char *file; /* The file name of the test. */
char *path; /* The path to the test program. */
enum plan_status plan; /* The status of our plan. */
unsigned long count; /* Expected count of tests. */
unsigned long current; /* The last seen test number. */
unsigned int length; /* The length of the last status message. */
unsigned long passed; /* Count of passing tests. */
unsigned long failed; /* Count of failing lists. */
unsigned long skipped; /* Count of skipped tests (passed). */
unsigned long allocated; /* The size of the results table. */
enum test_status *results; /* Table of results by test number. */
unsigned int aborted; /* Whether the set was aborted. */
int reported; /* Whether the results were reported. */
int status; /* The exit status of the test. */
unsigned int all_skipped; /* Whether all tests were skipped. */
char *reason; /* Why all tests were skipped. */
};
/* Structure to hold a linked list of test sets. */
struct testlist {
struct testset *ts;
struct testlist *next;
};
/*
* Usage message. Should be used as a printf format with four arguments: the
* path to runtests, given three times, and the usage_description. This is
* split into variables to satisfy the pedantic ISO C90 limit on strings.
*/
static const char usage_message[] = "\
Usage: %s [-hv] [-b ] [-s ] ...\n\
%s [-hv] [-b ] [-s ] -l \n\
%s -o [-h] [-b ] [-s ] \n\
\n\
Options:\n\
-b Set the build directory to \n\
%s";
static const char usage_extra[] = "\
-l Take the list of tests to run from \n\
-o Run a single test rather than a list of tests\n\
-s Set the source directory to \n\
-v Show the full output of each test\n\
\n\
runtests normally runs each test listed on the command line. With the -l\n\
option, it instead runs every test listed in a file. With the -o option,\n\
it instead runs a single test and shows its complete output.\n";
/*
* Header used for test output. %s is replaced by the file name of the list
* of tests.
*/
static const char banner[] = "\n\
Running all tests listed in %s. If any tests fail, run the failing\n\
test program with runtests -o to see more details.\n\n";
/* Header for reports of failed tests. */
static const char header[] = "\n\
Failed Set Fail/Total (%) Skip Stat Failing Tests\n\
-------------------------- -------------- ---- ---- ------------------------";
/* Include the file name and line number in malloc failures. */
#define xcalloc(n, size) x_calloc((n), (size), __FILE__, __LINE__)
#define xmalloc(size) x_malloc((size), __FILE__, __LINE__)
#define xstrdup(p) x_strdup((p), __FILE__, __LINE__)
#define xreallocarray(p, n, size) \
x_reallocarray((p), (n), (size), __FILE__, __LINE__)
/*
* __attribute__ is available in gcc 2.5 and later, but only with gcc 2.7
* could you use the __format__ form of the attributes, which is what we use
* (to avoid confusion with other macros).
*/
#ifndef __attribute__
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
# define __attribute__(spec) /* empty */
# endif
#endif
/*
* We use __alloc_size__, but it was only available in fairly recent versions
* of GCC. Suppress warnings about the unknown attribute if GCC is too old.
* We know that we're GCC at this point, so we can use the GCC variadic macro
* extension, which will still work with versions of GCC too old to have C99
* variadic macro support.
*/
#if !defined(__attribute__) && !defined(__alloc_size__)
# if defined(__GNUC__) && !defined(__clang__)
# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)
# define __alloc_size__(spec, args...) /* empty */
# endif
# endif
#endif
/*
* LLVM and Clang pretend to be GCC but don't support all of the __attribute__
* settings that GCC does. For them, suppress warnings about unknown
* attributes on declarations. This unfortunately will affect the entire
* compilation context, but there's no push and pop available.
*/
#if !defined(__attribute__) && (defined(__llvm__) || defined(__clang__))
# pragma GCC diagnostic ignored "-Wattributes"
#endif
/* Declare internal functions that benefit from compiler attributes. */
static void sysdie(const char *, ...)
__attribute__((__nonnull__, __noreturn__, __format__(printf, 1, 2)));
static void *x_calloc(size_t, size_t, const char *, int)
__attribute__((__alloc_size__(1, 2), __malloc__, __nonnull__));
static void *x_malloc(size_t, const char *, int)
__attribute__((__alloc_size__(1), __malloc__, __nonnull__));
static void *x_reallocarray(void *, size_t, size_t, const char *, int)
__attribute__((__alloc_size__(2, 3), __malloc__, __nonnull__(4)));
static char *x_strdup(const char *, const char *, int)
__attribute__((__malloc__, __nonnull__));
/*
* Report a fatal error, including the results of strerror, and exit.
*/
static void
sysdie(const char *format, ...)
{
int oerrno;
va_list args;
oerrno = errno;
fflush(stdout);
fprintf(stderr, "runtests: ");
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
fprintf(stderr, ": %s\n", strerror(oerrno));
exit(1);
}
/*
* Allocate zeroed memory, reporting a fatal error and exiting on failure.
*/
static void *
x_calloc(size_t n, size_t size, const char *file, int line)
{
void *p;
n = (n > 0) ? n : 1;
size = (size > 0) ? size : 1;
p = calloc(n, size);
if (p == NULL)
sysdie("failed to calloc %lu bytes at %s line %d",
(unsigned long) size, file, line);
return p;
}
/*
* Allocate memory, reporting a fatal error and exiting on failure.
*/
static void *
x_malloc(size_t size, const char *file, int line)
{
void *p;
p = malloc(size);
if (p == NULL)
sysdie("failed to malloc %lu bytes at %s line %d",
(unsigned long) size, file, line);
return p;
}
/*
* Reallocate memory, reporting a fatal error and exiting on failure.
*
* We should technically use SIZE_MAX here for the overflow check, but
* SIZE_MAX is C99 and we're only assuming C89 + SUSv3, which does not
* guarantee that it exists. They do guarantee that UINT_MAX exists, and we
* can assume that UINT_MAX <= SIZE_MAX. And we should not be allocating
* anything anywhere near that large.
*
* (In theory, C89 and C99 permit size_t to be smaller than unsigned int, but
* I disbelieve in the existence of such systems and they will have to cope
* without overflow checks.)
*/
static void *
x_reallocarray(void *p, size_t n, size_t size, const char *file, int line)
{
if (n > 0 && UINT_MAX / n <= size)
sysdie("realloc too large at %s line %d", file, line);
p = realloc(p, n * size);
if (p == NULL)
sysdie("failed to realloc %lu bytes at %s line %d",
(unsigned long) (n * size), file, line);
return p;
}
/*
* Copy a string, reporting a fatal error and exiting on failure.
*/
static char *
x_strdup(const char *s, const char *file, int line)
{
char *p;
size_t len;
len = strlen(s) + 1;
p = malloc(len);
if (p == NULL)
sysdie("failed to strdup %lu bytes at %s line %d",
(unsigned long) len, file, line);
memcpy(p, s, len);
return p;
}
/*
* Form a new string by concatenating multiple strings. The arguments must be
* terminated by (const char *) 0.
*
* This function only exists because we can't assume asprintf. We can't
* simulate asprintf with snprintf because we're only assuming SUSv3, which
* does not require that snprintf with a NULL buffer return the required
* length. When those constraints are relaxed, this should be ripped out and
* replaced with asprintf or a more trivial replacement with snprintf.
*/
static char *
concat(const char *first, ...)
{
va_list args;
char *result;
const char *string;
size_t offset;
size_t length = 0;
/*
* Find the total memory required. Ensure we don't overflow length. We
* aren't guaranteed to have SIZE_MAX, so use UINT_MAX as an acceptable
* substitute (see the x_nrealloc comments).
*/
va_start(args, first);
for (string = first; string != NULL; string = va_arg(args, const char *)) {
if (length >= UINT_MAX - strlen(string)) {
errno = EINVAL;
sysdie("strings too long in concat");
}
length += strlen(string);
}
va_end(args);
length++;
/* Create the string. */
result = xmalloc(length);
va_start(args, first);
offset = 0;
for (string = first; string != NULL; string = va_arg(args, const char *)) {
memcpy(result + offset, string, strlen(string));
offset += strlen(string);
}
va_end(args);
result[offset] = '\0';
return result;
}
/*
* Given a struct timeval, return the number of seconds it represents as a
* double. Use difftime() to convert a time_t to a double.
*/
static double
tv_seconds(const struct timeval *tv)
{
return difftime(tv->tv_sec, 0) + tv->tv_usec * 1e-6;
}
/*
* Given two struct timevals, return the difference in seconds.
*/
static double
tv_diff(const struct timeval *tv1, const struct timeval *tv0)
{
return tv_seconds(tv1) - tv_seconds(tv0);
}
/*
* Given two struct timevals, return the sum in seconds as a double.
*/
static double
tv_sum(const struct timeval *tv1, const struct timeval *tv2)
{
return tv_seconds(tv1) + tv_seconds(tv2);
}
/*
* Given a pointer to a string, skip any leading whitespace and return a
* pointer to the first non-whitespace character.
*/
static const char *
skip_whitespace(const char *p)
{
while (isspace((unsigned char)(*p)))
p++;
return p;
}
/*
* Start a program, connecting its stdout to a pipe on our end and its stderr
* to /dev/null, and storing the file descriptor to read from in the two
* argument. Returns the PID of the new process. Errors are fatal.
*/
static pid_t
test_start(const char *path, int *fd)
{
int fds[2], infd, errfd;
pid_t child;
/* Create a pipe used to capture the output from the test program. */
if (pipe(fds) == -1) {
puts("ABORTED");
fflush(stdout);
sysdie("can't create pipe");
}
/* Fork a child process, massage the file descriptors, and exec. */
child = fork();
switch (child) {
case -1:
puts("ABORTED");
fflush(stdout);
sysdie("can't fork");
/* In the child. Set up our standard output. */
case 0:
close(fds[0]);
close(STDOUT_FILENO);
if (dup2(fds[1], STDOUT_FILENO) < 0)
_exit(CHILDERR_DUP);
close(fds[1]);
/* Point standard input at /dev/null. */
close(STDIN_FILENO);
infd = open("/dev/null", O_RDONLY);
if (infd < 0)
_exit(CHILDERR_STDIN);
if (infd != STDIN_FILENO) {
if (dup2(infd, STDIN_FILENO) < 0)
_exit(CHILDERR_DUP);
close(infd);
}
/* Point standard error at /dev/null. */
close(STDERR_FILENO);
errfd = open("/dev/null", O_WRONLY);
if (errfd < 0)
_exit(CHILDERR_STDERR);
if (errfd != STDERR_FILENO) {
if (dup2(errfd, STDERR_FILENO) < 0)
_exit(CHILDERR_DUP);
close(errfd);
}
/* Now, exec our process. */
if (execl(path, path, (char *) 0) == -1)
_exit(CHILDERR_EXEC);
/* In parent. Close the extra file descriptor. */
default:
close(fds[1]);
break;
}
*fd = fds[0];
return child;
}
/*
* Back up over the output saying what test we were executing.
*/
static void
test_backspace(struct testset *ts)
{
unsigned int i;
if (!isatty(STDOUT_FILENO))
return;
for (i = 0; i < ts->length; i++)
putchar('\b');
for (i = 0; i < ts->length; i++)
putchar(' ');
for (i = 0; i < ts->length; i++)
putchar('\b');
ts->length = 0;
}
/*
* Allocate or resize the array of test results to be large enough to contain
* the test number in.
*/
static void
resize_results(struct testset *ts, unsigned long n)
{
unsigned long i;
size_t s;
/* If there's already enough space, return quickly. */
if (n <= ts->allocated)
return;
/*
* If no space has been allocated, do the initial allocation. Otherwise,
* resize. Start with 32 test cases and then add 1024 with each resize to
* try to reduce the number of reallocations.
*/
if (ts->allocated == 0) {
s = (n > 32) ? n : 32;
ts->results = xcalloc(s, sizeof(enum test_status));
} else {
s = (n > ts->allocated + 1024) ? n : ts->allocated + 1024;
ts->results = xreallocarray(ts->results, s, sizeof(enum test_status));
}
/* Set the results for the newly-allocated test array. */
for (i = ts->allocated; i < s; i++)
ts->results[i] = TEST_INVALID;
ts->allocated = s;
}
/*
* Report an invalid test number and set the appropriate flags. Pulled into a
* separate function since we do this in several places.
*/
static void
invalid_test_number(struct testset *ts, long n, enum test_verbose verbose)
{
if (!verbose)
test_backspace(ts);
printf("ABORTED (invalid test number %ld)\n", n);
ts->aborted = 1;
ts->reported = 1;
}
/*
* Read the plan line of test output, which should contain the range of test
* numbers. We may initialize the testset structure here if we haven't yet
* seen a test. Return true if initialization succeeded and the test should
* continue, false otherwise.
*/
static int
test_plan(const char *line, struct testset *ts, enum test_verbose verbose)
{
long n;
/*
* Accept a plan without the leading 1.. for compatibility with older
* versions of runtests. This will only be allowed if we've not yet seen
* a test result.
*/
line = skip_whitespace(line);
if (strncmp(line, "1..", 3) == 0)
line += 3;
/*
* Get the count and check it for validity.
*
* If we have something of the form "1..0 # skip foo", the whole file was
* skipped; record that. If we do skip the whole file, zero out all of
* our statistics, since they're no longer relevant.
*
* strtol is called with a second argument to advance the line pointer
* past the count to make it simpler to detect the # skip case.
*/
n = strtol(line, (char **) &line, 10);
if (n == 0) {
line = skip_whitespace(line);
if (*line == '#') {
line = skip_whitespace(line + 1);
if (strncasecmp(line, "skip", 4) == 0) {
line = skip_whitespace(line + 4);
if (*line != '\0') {
ts->reason = xstrdup(line);
ts->reason[strlen(ts->reason) - 1] = '\0';
}
ts->all_skipped = 1;
ts->aborted = 1;
ts->count = 0;
ts->passed = 0;
ts->skipped = 0;
ts->failed = 0;
return 0;
}
}
}
if (n <= 0) {
puts("ABORTED (invalid test count)");
ts->aborted = 1;
ts->reported = 1;
return 0;
}
/*
* If we are doing lazy planning, check the plan against the largest test
* number that we saw and fail now if we saw a check outside the plan
* range.
*/
if (ts->plan == PLAN_PENDING && (unsigned long) n < ts->count) {
invalid_test_number(ts, (long) ts->count, verbose);
return 0;
}
/*
* Otherwise, allocated or resize the results if needed and update count,
* and then record that we've seen a plan.
*/
resize_results(ts, (unsigned long) n);
ts->count = (unsigned long) n;
if (ts->plan == PLAN_INIT)
ts->plan = PLAN_FIRST;
else if (ts->plan == PLAN_PENDING)
ts->plan = PLAN_FINAL;
return 1;
}
/*
* Given a single line of output from a test, parse it and return the success
* status of that test. Anything printed to stdout not matching the form
* /^(not )?ok \d+/ is ignored. Sets ts->current to the test number that just
* reported status.
*/
static void
test_checkline(const char *line, struct testset *ts,
enum test_verbose verbose)
{
enum test_status status = TEST_PASS;
const char *bail;
char *end;
long number;
unsigned long current;
int outlen;
/* Before anything, check for a test abort. */
bail = strstr(line, "Bail out!");
if (bail != NULL) {
bail = skip_whitespace(bail + strlen("Bail out!"));
if (*bail != '\0') {
size_t length;
length = strlen(bail);
if (bail[length - 1] == '\n')
length--;
if (!verbose)
test_backspace(ts);
printf("ABORTED (%.*s)\n", (int) length, bail);
ts->reported = 1;
}
ts->aborted = 1;
return;
}
/*
* If the given line isn't newline-terminated, it was too big for an
* fgets(), which means ignore it.
*/
if (line[strlen(line) - 1] != '\n')
return;
/* If the line begins with a hash mark, ignore it. */
if (line[0] == '#')
return;
/* If we haven't yet seen a plan, look for one. */
if (ts->plan == PLAN_INIT && isdigit((unsigned char)(*line))) {
if (!test_plan(line, ts, verbose))
return;
} else if (strncmp(line, "1..", 3) == 0) {
if (ts->plan == PLAN_PENDING) {
if (!test_plan(line, ts, verbose))
return;
} else {
if (!verbose)
test_backspace(ts);
puts("ABORTED (multiple plans)");
ts->aborted = 1;
ts->reported = 1;
return;
}
}
/* Parse the line, ignoring something we can't parse. */
if (strncmp(line, "not ", 4) == 0) {
status = TEST_FAIL;
line += 4;
}
if (strncmp(line, "ok", 2) != 0)
return;
line = skip_whitespace(line + 2);
errno = 0;
number = strtol(line, &end, 10);
if (errno != 0 || end == line)
current = ts->current + 1;
else if (number <= 0) {
invalid_test_number(ts, number, verbose);
return;
} else
current = (unsigned long) number;
if (current > ts->count && ts->plan == PLAN_FIRST) {
invalid_test_number(ts, (long) current, verbose);
return;
}
/* We have a valid test result. Tweak the results array if needed. */
if (ts->plan == PLAN_INIT || ts->plan == PLAN_PENDING) {
ts->plan = PLAN_PENDING;
resize_results(ts, current);
if (current > ts->count)
ts->count = current;
}
/*
* Handle directives. We should probably do something more interesting
* with unexpected passes of todo tests.
*/
while (isdigit((unsigned char)(*line)))
line++;
line = skip_whitespace(line);
if (*line == '#') {
line = skip_whitespace(line + 1);
if (strncasecmp(line, "skip", 4) == 0)
status = TEST_SKIP;
if (strncasecmp(line, "todo", 4) == 0)
status = (status == TEST_FAIL) ? TEST_SKIP : TEST_FAIL;
}
/* Make sure that the test number is in range and not a duplicate. */
if (ts->results[current - 1] != TEST_INVALID) {
if (!verbose)
test_backspace(ts);
printf("ABORTED (duplicate test number %lu)\n", current);
ts->aborted = 1;
ts->reported = 1;
return;
}
/* Good results. Increment our various counters. */
switch (status) {
case TEST_PASS: ts->passed++; break;
case TEST_FAIL: ts->failed++; break;
case TEST_SKIP: ts->skipped++; break;
case TEST_INVALID: break;
}
ts->current = current;
ts->results[current - 1] = status;
if (!verbose && isatty(STDOUT_FILENO)) {
test_backspace(ts);
if (ts->plan == PLAN_PENDING)
outlen = printf("%lu/?", current);
else
outlen = printf("%lu/%lu", current, ts->count);
ts->length = (outlen >= 0) ? (unsigned int) outlen : 0;
fflush(stdout);
}
}
/*
* Print out a range of test numbers, returning the number of characters it
* took up. Takes the first number, the last number, the number of characters
* already printed on the line, and the limit of number of characters the line
* can hold. Add a comma and a space before the range if chars indicates that
* something has already been printed on the line, and print ... instead if
* chars plus the space needed would go over the limit (use a limit of 0 to
* disable this).
*/
static unsigned int
test_print_range(unsigned long first, unsigned long last, unsigned long chars,
unsigned int limit)
{
unsigned int needed = 0;
unsigned long n;
for (n = first; n > 0; n /= 10)
needed++;
if (last > first) {
for (n = last; n > 0; n /= 10)
needed++;
needed++;
}
if (chars > 0)
needed += 2;
if (limit > 0 && chars + needed > limit) {
needed = 0;
if (chars <= limit) {
if (chars > 0) {
printf(", ");
needed += 2;
}
printf("...");
needed += 3;
}
} else {
if (chars > 0)
printf(", ");
if (last > first)
printf("%lu-", first);
printf("%lu", last);
}
return needed;
}
/*
* Summarize a single test set. The second argument is 0 if the set exited
* cleanly, a positive integer representing the exit status if it exited
* with a non-zero status, and a negative integer representing the signal
* that terminated it if it was killed by a signal.
*/
static void
test_summarize(struct testset *ts, int status)
{
unsigned long i;
unsigned long missing = 0;
unsigned long failed = 0;
unsigned long first = 0;
unsigned long last = 0;
if (ts->aborted) {
fputs("ABORTED", stdout);
if (ts->count > 0)
printf(" (passed %lu/%lu)", ts->passed, ts->count - ts->skipped);
} else {
for (i = 0; i < ts->count; i++) {
if (ts->results[i] == TEST_INVALID) {
if (missing == 0)
fputs("MISSED ", stdout);
if (first && i == last)
last = i + 1;
else {
if (first)
test_print_range(first, last, missing - 1, 0);
missing++;
first = i + 1;
last = i + 1;
}
}
}
if (first)
test_print_range(first, last, missing - 1, 0);
first = 0;
last = 0;
for (i = 0; i < ts->count; i++) {
if (ts->results[i] == TEST_FAIL) {
if (missing && !failed)
fputs("; ", stdout);
if (failed == 0)
fputs("FAILED ", stdout);
if (first && i == last)
last = i + 1;
else {
if (first)
test_print_range(first, last, failed - 1, 0);
failed++;
first = i + 1;
last = i + 1;
}
}
}
if (first)
test_print_range(first, last, failed - 1, 0);
if (!missing && !failed) {
fputs(!status ? "ok" : "dubious", stdout);
if (ts->skipped > 0) {
if (ts->skipped == 1)
printf(" (skipped %lu test)", ts->skipped);
else
printf(" (skipped %lu tests)", ts->skipped);
}
}
}
if (status > 0)
printf(" (exit status %d)", status);
else if (status < 0)
printf(" (killed by signal %d%s)", -status,
WCOREDUMP(ts->status) ? ", core dumped" : "");
putchar('\n');
}
/*
* Given a test set, analyze the results, classify the exit status, handle a
* few special error messages, and then pass it along to test_summarize() for
* the regular output. Returns true if the test set ran successfully and all
* tests passed or were skipped, false otherwise.
*/
static int
test_analyze(struct testset *ts)
{
if (ts->reported)
return 0;
if (ts->all_skipped) {
if (ts->reason == NULL)
puts("skipped");
else
printf("skipped (%s)\n", ts->reason);
return 1;
} else if (WIFEXITED(ts->status) && WEXITSTATUS(ts->status) != 0) {
switch (WEXITSTATUS(ts->status)) {
case CHILDERR_DUP:
if (!ts->reported)
puts("ABORTED (can't dup file descriptors)");
break;
case CHILDERR_EXEC:
if (!ts->reported)
puts("ABORTED (execution failed -- not found?)");
break;
case CHILDERR_STDIN:
case CHILDERR_STDERR:
if (!ts->reported)
puts("ABORTED (can't open /dev/null)");
break;
default:
test_summarize(ts, WEXITSTATUS(ts->status));
break;
}
return 0;
} else if (WIFSIGNALED(ts->status)) {
test_summarize(ts, -WTERMSIG(ts->status));
return 0;
} else if (ts->plan != PLAN_FIRST && ts->plan != PLAN_FINAL) {
puts("ABORTED (no valid test plan)");
ts->aborted = 1;
return 0;
} else {
test_summarize(ts, 0);
return (ts->failed == 0);
}
}
/*
* Runs a single test set, accumulating and then reporting the results.
* Returns true if the test set was successfully run and all tests passed,
* false otherwise.
*/
static int
test_run(struct testset *ts, enum test_verbose verbose)
{
pid_t testpid, child;
int outfd, status;
unsigned long i;
FILE *output;
char buffer[BUFSIZ];
/* Run the test program. */
testpid = test_start(ts->path, &outfd);
output = fdopen(outfd, "r");
if (!output) {
puts("ABORTED");
fflush(stdout);
sysdie("fdopen failed");
}
/*
* Pass each line of output to test_checkline(), and print the line if
* verbosity is requested.
*/
while (!ts->aborted && fgets(buffer, sizeof(buffer), output)) {
if (verbose)
printf("%s", buffer);
test_checkline(buffer, ts, verbose);
}
if (ferror(output) || ts->plan == PLAN_INIT)
ts->aborted = 1;
if (!verbose)
test_backspace(ts);
/*
* Consume the rest of the test output, close the output descriptor,
* retrieve the exit status, and pass that information to test_analyze()
* for eventual output.
*/
while (fgets(buffer, sizeof(buffer), output))
if (verbose)
printf("%s", buffer);
fclose(output);
child = waitpid(testpid, &ts->status, 0);
if (child == (pid_t) -1) {
if (!ts->reported) {
puts("ABORTED");
fflush(stdout);
}
sysdie("waitpid for %u failed", (unsigned int) testpid);
}
if (ts->all_skipped)
ts->aborted = 0;
status = test_analyze(ts);
/* Convert missing tests to failed tests. */
for (i = 0; i < ts->count; i++) {
if (ts->results[i] == TEST_INVALID) {
ts->failed++;
ts->results[i] = TEST_FAIL;
status = 0;
}
}
return status;
}
/* Summarize a list of test failures. */
static void
test_fail_summary(const struct testlist *fails)
{
struct testset *ts;
unsigned int chars;
unsigned long i, first, last, total;
puts(header);
/* Failed Set Fail/Total (%) Skip Stat Failing (25)
-------------------------- -------------- ---- ---- -------------- */
for (; fails; fails = fails->next) {
ts = fails->ts;
total = ts->count - ts->skipped;
printf("%-26.26s %4lu/%-4lu %3.0f%% %4lu ", ts->file, ts->failed,
total, total ? (ts->failed * 100.0) / total : 0,
ts->skipped);
if (WIFEXITED(ts->status))
printf("%4d ", WEXITSTATUS(ts->status));
else
printf(" -- ");
if (ts->aborted) {
puts("aborted");
continue;
}
chars = 0;
first = 0;
last = 0;
for (i = 0; i < ts->count; i++) {
if (ts->results[i] == TEST_FAIL) {
if (first != 0 && i == last)
last = i + 1;
else {
if (first != 0)
chars += test_print_range(first, last, chars, 19);
first = i + 1;
last = i + 1;
}
}
}
if (first != 0)
test_print_range(first, last, chars, 19);
putchar('\n');
}
}
/*
* Check whether a given file path is a valid test. Currently, this checks
* whether it is executable and is a regular file. Returns true or false.
*/
static int
is_valid_test(const char *path)
{
struct stat st;
if (access(path, X_OK) < 0)
return 0;
if (stat(path, &st) < 0)
return 0;
if (!S_ISREG(st.st_mode))
return 0;
return 1;
}
/*
* Given the name of a test, a pointer to the testset struct, and the source
* and build directories, find the test. We try first relative to the current
* directory, then in the build directory (if not NULL), then in the source
* directory. In each of those directories, we first try a "-t" extension and
* then a ".t" extension. When we find an executable program, we return the
* path to that program. If none of those paths are executable, just fill in
* the name of the test as is.
*
* The caller is responsible for freeing the path member of the testset
* struct.
*/
static char *
find_test(const char *name, const char *source, const char *build)
{
char *path = NULL;
const char *bases[3], *suffix, *base;
unsigned int i, j;
const char *suffixes[3] = { "-t", ".t", "" };
/* Possible base directories. */
bases[0] = ".";
bases[1] = build;
bases[2] = source;
/* Try each suffix with each base. */
for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
suffix = suffixes[i];
for (j = 0; j < ARRAY_SIZE(bases); j++) {
base = bases[j];
if (base == NULL)
continue;
path = concat(base, "/", name, suffix, (const char *) 0);
if (is_valid_test(path))
return path;
free(path);
path = NULL;
}
}
if (path == NULL)
path = xstrdup(name);
return path;
}
/*
* Read a list of tests from a file, returning the list of tests as a struct
* testlist. Reports an error to standard error and exits if the list of
* tests cannot be read.
*/
static struct testlist *
read_test_list(const char *filename)
{
FILE *file;
unsigned int line;
size_t length;
char buffer[BUFSIZ];
const char *testname;
struct testlist *listhead, *current;
/* Create the initial container list that will hold our results. */
listhead = xcalloc(1, sizeof(struct testlist));
current = NULL;
/*
* Open our file of tests to run and read it line by line, creating a new
* struct testlist and struct testset for each line.
*/
file = fopen(filename, "r");
if (file == NULL)
sysdie("can't open %s", filename);
line = 0;
while (fgets(buffer, sizeof(buffer), file)) {
line++;
length = strlen(buffer) - 1;
if (buffer[length] != '\n') {
fprintf(stderr, "%s:%u: line too long\n", filename, line);
exit(1);
}
buffer[length] = '\0';
/* Skip comments, leading spaces, and blank lines. */
testname = skip_whitespace(buffer);
if (strlen(testname) == 0)
continue;
if (testname[0] == '#')
continue;
/* Allocate the new testset structure. */
if (current == NULL)
current = listhead;
else {
current->next = xcalloc(1, sizeof(struct testlist));
current = current->next;
}
current->ts = xcalloc(1, sizeof(struct testset));
current->ts->plan = PLAN_INIT;
current->ts->file = xstrdup(testname);
}
fclose(file);
/* Return the results. */
return listhead;
}
/*
* Build a list of tests from command line arguments. Takes the argv and argc
* representing the command line arguments and returns a newly allocated test
* list. The caller is responsible for freeing.
*/
static struct testlist *
build_test_list(char *argv[], int argc)
{
int i;
struct testlist *listhead, *current;
/* Create the initial container list that will hold our results. */
listhead = xcalloc(1, sizeof(struct testlist));
current = NULL;
/* Walk the list of arguments and create test sets for them. */
for (i = 0; i < argc; i++) {
if (current == NULL)
current = listhead;
else {
current->next = xcalloc(1, sizeof(struct testlist));
current = current->next;
}
current->ts = xcalloc(1, sizeof(struct testset));
current->ts->plan = PLAN_INIT;
current->ts->file = xstrdup(argv[i]);
}
/* Return the results. */
return listhead;
}
/* Free a struct testset. */
static void
free_testset(struct testset *ts)
{
free(ts->file);
free(ts->path);
free(ts->results);
free(ts->reason);
free(ts);
}
/*
* Run a batch of tests. Takes two additional parameters: the root of the
* source directory and the root of the build directory. Test programs will
* be first searched for in the current directory, then the build directory,
* then the source directory. Returns true iff all tests passed, and always
* frees the test list that's passed in.
*/
static int
test_batch(struct testlist *tests, const char *source, const char *build,
enum test_verbose verbose)
{
size_t length, i;
size_t longest = 0;
unsigned int count = 0;
struct testset *ts;
struct timeval start, end;
struct rusage stats;
struct testlist *failhead = NULL;
struct testlist *failtail = NULL;
struct testlist *current, *next;
int succeeded;
unsigned long total = 0;
unsigned long passed = 0;
unsigned long skipped = 0;
unsigned long failed = 0;
unsigned long aborted = 0;
/* Walk the list of tests to find the longest name. */
for (current = tests; current != NULL; current = current->next) {
length = strlen(current->ts->file);
if (length > longest)
longest = length;
}
/*
* Add two to longest and round up to the nearest tab stop. This is how
* wide the column for printing the current test name will be.
*/
longest += 2;
if (longest % 8)
longest += 8 - (longest % 8);
/* Start the wall clock timer. */
gettimeofday(&start, NULL);
/* Now, plow through our tests again, running each one. */
for (current = tests; current != NULL; current = current->next) {
ts = current->ts;
/* Print out the name of the test file. */
fputs(ts->file, stdout);
if (verbose)
fputs("\n\n", stdout);
else
for (i = strlen(ts->file); i < longest; i++)
putchar('.');
if (isatty(STDOUT_FILENO))
fflush(stdout);
/* Run the test. */
ts->path = find_test(ts->file, source, build);
succeeded = test_run(ts, verbose);
fflush(stdout);
if (verbose)
putchar('\n');
/* Record cumulative statistics. */
aborted += ts->aborted;
total += ts->count + ts->all_skipped;
passed += ts->passed;
skipped += ts->skipped + ts->all_skipped;
failed += ts->failed;
count++;
/* If the test fails, we shuffle it over to the fail list. */
if (!succeeded) {
if (failhead == NULL) {
failhead = xmalloc(sizeof(struct testset));
failtail = failhead;
} else {
failtail->next = xmalloc(sizeof(struct testset));
failtail = failtail->next;
}
failtail->ts = ts;
failtail->next = NULL;
}
}
total -= skipped;
/* Stop the timer and get our child resource statistics. */
gettimeofday(&end, NULL);
getrusage(RUSAGE_CHILDREN, &stats);
/* Summarize the failures and free the failure list. */
if (failhead != NULL) {
test_fail_summary(failhead);
while (failhead != NULL) {
next = failhead->next;
free(failhead);
failhead = next;
}
}
/* Free the memory used by the test lists. */
while (tests != NULL) {
next = tests->next;
free_testset(tests->ts);
free(tests);
tests = next;
}
/* Print out the final test summary. */
putchar('\n');
if (aborted != 0) {
if (aborted == 1)
printf("Aborted %lu test set", aborted);
else
printf("Aborted %lu test sets", aborted);
printf(", passed %lu/%lu tests", passed, total);
}
else if (failed == 0)
fputs("All tests successful", stdout);
else
printf("Failed %lu/%lu tests, %.2f%% okay", failed, total,
(total - failed) * 100.0 / total);
if (skipped != 0) {
if (skipped == 1)
printf(", %lu test skipped", skipped);
else
printf(", %lu tests skipped", skipped);
}
puts(".");
printf("Files=%u, Tests=%lu", count, total);
printf(", %.2f seconds", tv_diff(&end, &start));
printf(" (%.2f usr + %.2f sys = %.2f CPU)\n",
tv_seconds(&stats.ru_utime), tv_seconds(&stats.ru_stime),
tv_sum(&stats.ru_utime, &stats.ru_stime));
return (failed == 0 && aborted == 0);
}
/*
* Run a single test case. This involves just running the test program after
* having done the environment setup and finding the test program.
*/
static void
test_single(const char *program, const char *source, const char *build)
{
char *path;
path = find_test(program, source, build);
if (execl(path, path, (char *) 0) == -1)
sysdie("cannot exec %s", path);
}
/*
* Main routine. Set the SOURCE and BUILD environment variables and then,
* given a file listing tests, run each test listed.
*/
int
main(int argc, char *argv[])
{
int option;
int status = 0;
int single = 0;
enum test_verbose verbose = CONCISE;
char *source_env = NULL;
char *build_env = NULL;
const char *program;
const char *shortlist;
const char *list = NULL;
const char *source = SOURCE;
const char *build = BUILD;
struct testlist *tests;
program = argv[0];
while ((option = getopt(argc, argv, "b:hl:os:v")) != EOF) {
switch (option) {
case 'b':
build = optarg;
break;
case 'h':
printf(usage_message, program, program, program, usage_extra);
exit(0);
case 'l':
list = optarg;
break;
case 'o':
single = 1;
break;
case 's':
source = optarg;
break;
case 'v':
verbose = VERBOSE;
break;
default:
exit(1);
}
}
argv += optind;
argc -= optind;
if ((list == NULL && argc < 1) || (list != NULL && argc > 0)) {
fprintf(stderr, usage_message, program, program, program, usage_extra);
exit(1);
}
/*
* If C_TAP_VERBOSE is set in the environment, that also turns on verbose
* mode.
*/
if (getenv("C_TAP_VERBOSE") != NULL)
verbose = VERBOSE;
/* Set SOURCE and BUILD environment variables. */
if (source != NULL) {
source_env = concat("SOURCE=", source, (const char *) 0);
if (putenv(source_env) != 0)
sysdie("cannot set SOURCE in the environment");
}
if (build != NULL) {
build_env = concat("BUILD=", build, (const char *) 0);
if (putenv(build_env) != 0)
sysdie("cannot set BUILD in the environment");
}
/* Run the tests as instructed. */
if (single)
test_single(argv[0], source, build);
else if (list != NULL) {
shortlist = strrchr(list, '/');
if (shortlist == NULL)
shortlist = list;
else
shortlist++;
printf(banner, shortlist);
tests = read_test_list(list);
status = test_batch(tests, source, build, verbose) ? 0 : 1;
} else {
tests = build_test_list(argv, argc);
status = test_batch(tests, source, build, verbose) ? 0 : 1;
}
/* For valgrind cleanliness, free all our memory. */
if (source_env != NULL) {
putenv((char *) "SOURCE=");
free(source_env);
}
if (build_env != NULL) {
putenv((char *) "BUILD=");
free(build_env);
}
exit(status);
}
hkl-5.0.0.2569/tests/hkl-axis-t.c 0000644 0001751 0001751 00000025366 13464522142 016426 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#include
static void new(void)
{
HklParameter *axis;
static HklVector v = {{1, 0, 0}};
double min, max;
axis = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
is_string("rotation", hkl_parameter_name_get(axis), __func__);
hkl_parameter_min_max_get(axis, &min, &max, HKL_UNIT_DEFAULT);
is_double(-M_PI, min, HKL_EPSILON, __func__);
is_double(M_PI, max, HKL_EPSILON, __func__);
is_double(0., hkl_parameter_value_get(axis, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
ok(TRUE == hkl_parameter_fit_get(axis), __func__);
hkl_parameter_free(axis);
axis = hkl_parameter_new_translation("translation", &v, &hkl_unit_length_mm);
is_string("translation", hkl_parameter_name_get(axis), __func__);
hkl_parameter_min_max_get(axis, &min, &max, HKL_UNIT_DEFAULT);
is_double(-DBL_MAX, min, HKL_EPSILON, __func__);
is_double(DBL_MAX, max, HKL_EPSILON, __func__);
is_double(0., hkl_parameter_value_get(axis, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
ok(TRUE == hkl_parameter_fit_get(axis), __func__);
hkl_parameter_free(axis);
}
static void get_quaternions(void)
{
static HklVector v_ref = {{1, 0, 0}};
static HklQuaternion q1_ref = {{1, 0, 0, 0}};
static HklQuaternion q2_ref = {{M_SQRT1_2, -M_SQRT1_2, 0, 0}};
HklParameter *axis;
axis = hkl_parameter_new_rotation("rotation", &v_ref, &hkl_unit_angle_deg);
is_quaternion(&q1_ref, hkl_parameter_quaternion_get(axis), __func__);
ok(TRUE == hkl_parameter_value_set(axis, -M_PI_2, HKL_UNIT_DEFAULT, NULL), __func__);
is_quaternion(&q2_ref, hkl_parameter_quaternion_get(axis), __func__);
hkl_parameter_free(axis);
axis = hkl_parameter_new_translation("translation", &v_ref, &hkl_unit_length_mm);
ok(NULL == hkl_parameter_quaternion_get(axis), __func__);
hkl_parameter_free(axis);
}
static void copy(void)
{
static HklVector v = {{1, 0, 0}};
static HklQuaternion q_ref = {{M_SQRT1_2, -M_SQRT1_2, 0, 0}};
HklParameter *axis;
HklParameter *copy;
double min, max;
axis = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
ok(TRUE == hkl_parameter_value_set(axis, -M_PI_2, HKL_UNIT_DEFAULT, NULL), __func__);
copy = hkl_parameter_new_copy(axis);
is_string("rotation", hkl_parameter_name_get(copy), __func__);
hkl_parameter_min_max_get(copy, &min, &max, HKL_UNIT_DEFAULT);
is_double(-M_PI, min, HKL_EPSILON, __func__);
is_double(M_PI, max, HKL_EPSILON, __func__);
is_double(-M_PI_2, hkl_parameter_value_get(copy, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
ok(TRUE == hkl_parameter_fit_get(copy), __func__);
is_quaternion(&q_ref, hkl_parameter_quaternion_get(copy), __func__);
hkl_parameter_free(axis);
hkl_parameter_free(copy);
axis = hkl_parameter_new_translation("translation", &v, &hkl_unit_length_mm);
ok(TRUE == hkl_parameter_value_set(axis, 100, HKL_UNIT_DEFAULT, NULL), __func__);
copy = hkl_parameter_new_copy(axis);
is_string("translation", hkl_parameter_name_get(copy), __func__);
hkl_parameter_min_max_get(copy, &min, &max, HKL_UNIT_DEFAULT);
is_double(-DBL_MAX, min, HKL_EPSILON, __func__);
is_double(DBL_MAX, max, HKL_EPSILON, __func__);
is_double(100, hkl_parameter_value_get(copy, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
ok(TRUE == hkl_parameter_fit_get(copy), __func__);
ok(NULL == hkl_parameter_quaternion_get(copy), __func__);
hkl_parameter_free(axis);
hkl_parameter_free(copy);
}
static void is_valid(void)
{
static HklVector v = {{1, 0, 0}};
HklParameter *axis;
int res = TRUE;
axis = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 45, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_min_max_set(axis, -270, 0.0, HKL_UNIT_USER, NULL));
res &= DIAG(FALSE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -45, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_min_max_set(axis, 350, 450, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 45, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -45, HKL_UNIT_USER, NULL));
res &= DIAG(FALSE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_min_max_set(axis, -10, 90, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 405, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -405, HKL_UNIT_USER, NULL));
res &= DIAG(FALSE == hkl_parameter_is_valid(axis));
hkl_parameter_free(axis);
axis = hkl_parameter_new_translation("translation", &v, &hkl_unit_length_mm);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 45, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_min_max_set(axis, -270, 0, HKL_UNIT_USER, NULL));
res &= DIAG(FALSE == hkl_parameter_is_valid(axis));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -45, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_is_valid(axis));
hkl_parameter_free(axis);
ok(res == TRUE, __func__);
}
static void set_value_smallest_in_range(void)
{
HklParameter *axis;
static HklVector v = {{1, 0, 0}};
int res = TRUE;
axis = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
/* can not set a parameter value with a NaN */
res &= DIAG(FALSE == hkl_parameter_value_set(axis, NAN, HKL_UNIT_USER, NULL));
res &= DIAG(FALSE == hkl_parameter_value_set(axis, NAN, HKL_UNIT_DEFAULT, NULL));
res &= DIAG(TRUE == hkl_parameter_min_max_set(axis, -190, 190, HKL_UNIT_USER, NULL));
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 185, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-175., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 545, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-175., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -185, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-185., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 175, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-185., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, 190, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-170., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
res &= DIAG(TRUE == hkl_parameter_value_set(axis, -190, HKL_UNIT_USER, NULL));
hkl_parameter_value_set_smallest_in_range(axis);
is_double(-190., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
hkl_parameter_free(axis);
ok(res == TRUE, __func__);
}
static void get_value_closest(void)
{
HklParameter *axis1, *axis2;
static HklVector v = {{1, 0, 0}};
axis1 = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
axis2 = hkl_parameter_new_rotation("rotation", &v, &hkl_unit_angle_deg);
ok(TRUE == hkl_parameter_value_set(axis1, 0, HKL_UNIT_USER, NULL), __func__);
ok(TRUE == hkl_parameter_value_set(axis2, 0, HKL_UNIT_USER, NULL), __func__);
is_double(0., hkl_parameter_value_get_closest(axis1,
axis2),
HKL_EPSILON, __func__);
/* change the range of axis1 */
ok(TRUE == hkl_parameter_min_max_set(axis1, -270, 180, HKL_UNIT_USER, NULL), __func__);
ok(TRUE == hkl_parameter_value_set(axis1, 100, HKL_UNIT_USER, NULL), __func__);
ok(TRUE == hkl_parameter_value_set(axis2, -75, HKL_UNIT_USER, NULL), __func__);
is_double(100 * HKL_DEGTORAD, hkl_parameter_value_get_closest(axis1,
axis2),
HKL_EPSILON, __func__);
ok(TRUE == hkl_parameter_value_set(axis2, -85, HKL_UNIT_USER, NULL), __func__);
is_double(-260 * HKL_DEGTORAD, hkl_parameter_value_get_closest(axis1,
axis2),
HKL_EPSILON, __func__);
hkl_parameter_free(axis2);
hkl_parameter_free(axis1);
}
static void transformation_cmp(void)
{
int res = TRUE;
HklParameter *axis1, *axis2, *translation1, *translation2;
static HklVector v1 = {{1, 0, 0}};
static HklVector v2 = {{0, 1, 0}};
axis1 = hkl_parameter_new_rotation("rotation", &v1, &hkl_unit_angle_deg);
axis2 = hkl_parameter_new_rotation("rotation", &v2, &hkl_unit_angle_deg);
translation1 = hkl_parameter_new_translation("translation", &v1, &hkl_unit_length_mm);
translation2 = hkl_parameter_new_translation("translation", &v2, &hkl_unit_length_mm);
res &= DIAG(0 == hkl_parameter_transformation_cmp(axis1, axis1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(axis1, axis2));
res &= DIAG(0 != hkl_parameter_transformation_cmp(axis1, translation1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(axis1, translation2));
res &= DIAG(0 != hkl_parameter_transformation_cmp(axis2, translation1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(axis2, translation2));
res &= DIAG(0 == hkl_parameter_transformation_cmp(translation1, translation1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(translation1, translation2));
res &= DIAG(0 != hkl_parameter_transformation_cmp(translation1, axis1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(translation1, axis2));
res &= DIAG(0 != hkl_parameter_transformation_cmp(translation2, axis1));
res &= DIAG(0 != hkl_parameter_transformation_cmp(translation2, axis2));
ok(res == TRUE, __func__);
hkl_parameter_free(translation2);
hkl_parameter_free(translation1);
hkl_parameter_free(axis2);
hkl_parameter_free(axis1);
}
int main(void)
{
plan(46);
new();
get_quaternions();
copy();
is_valid();
set_value_smallest_in_range();
get_value_closest();
transformation_cmp();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-k6c-t.c 0000644 0001751 0001751 00000017252 13447477011 020327 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
static void degenerated(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {0, 1, 0};
struct Geometry gconf = K6c(1.54, 0., 0., 0., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes){
const darray_string *parameters;
HklGeometryList *geometries;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
if (!strcasecmp(*mode, "constant_chi_vertical")){
size_t n_params = darray_size(*parameters);
double params[n_params];
hkl_engine_parameters_values_get(engine,
params, n_params,
HKL_UNIT_DEFAULT);
params[0] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine,
params, n_params,
HKL_UNIT_DEFAULT, NULL));
}
if (!strcasecmp(*mode, "constant_incidence")){
size_t n_params = darray_size(*parameters);
double params[n_params];
hkl_engine_parameters_values_get(engine,
params, n_params,
HKL_UNIT_DEFAULT);
params[3] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine,
params, n_params,
HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine,
hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if (geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry, hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl)));
}
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "degenerated");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void eulerians(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
const HklGeometryListItem *item;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = K6c(1.54, 0., 0., 0., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "eulerians", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes){
const darray_string *parameters;
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if (n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine,
params, n_params,
HKL_UNIT_DEFAULT);
params[0] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine,
params, n_params,
HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_set_values_v(engine, 0., 90. * HKL_DEGTORAD, 0.);
if (geometries) {
res &= DIAG(hkl_geometry_list_n_items_get(geometries) == 2);
/* first solution = -180, -90, 180 */
item = hkl_geometry_list_items_first_get(geometries);
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, -180. * HKL_DEGTORAD, -90. * HKL_DEGTORAD, 180. * HKL_DEGTORAD));
/* second solution = 0, 90, 0 */
item = hkl_geometry_list_items_next_get(geometries, item);
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, 0., 90. * HKL_DEGTORAD, 0.));
/* no more solution */
res &= DIAG(hkl_geometry_list_items_next_get(geometries, item) == NULL);
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "eulerians");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void q2(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = K6c(1.54, 0., 30., 0., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "q2", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double q, alpha;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(q=0.1; q<1.; q += 0.1)
for(alpha = -M_PI; alpha.
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
* Jens Krüger
*/
#include "hkl.h"
#include
#include
#include "hkl/ccan/generator/generator.h"
#include "hkl-geometry-private.h"
#include "hkl-trajectory-private.h"
static void getter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4ch(1.54, 0., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
/* geometry -> pseudo */
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., 1., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., -90., 60.));
res &= DIAG(check_pseudoaxes_v(engine, -1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 180., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., -1., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 0., 135., 90.));
res &= DIAG(check_pseudoaxes_v(engine, 1., -1., 0.));
ok(res == TRUE, "getter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void degenerated(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const char **mode;
const darray_string *modes;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4ch(1.54, 0., 0., 0., 0.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes){
static double values[] = {0, 0, 1};
const darray_string *parameters;
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if (n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
values[0] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine, values, ARRAY_SIZE(values),
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, values, 3));
}
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "degenerated");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void psi_getter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
double hkl[3];
struct Geometry gconf = E4ch(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
/* the getter part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
hkl[0] = 1, hkl[1] = 0, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 0.));
/* here Q and _ref are colinear must FAIL */
hkl[0] = 0, hkl[1] = 1, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(!check_pseudoaxes_v(engine, 0.));
hkl[0] = -1, hkl[1] = 0, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 180. * HKL_DEGTORAD));
hkl[0] = 0, hkl[1] = 0, hkl[2] = -1;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 90. * HKL_DEGTORAD));
/* Q and _ref are colinear so must FAIL */
hkl[0] = 0, hkl[1] = -1, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(!check_pseudoaxes_v(engine, 0.));
ok(res == TRUE, "psi getter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void psi_setter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {1, 0, 0};
struct Geometry gconf = E4ch(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double psi;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(psi=-180 * HKL_DEGTORAD;psi<180 * HKL_DEGTORAD;psi += HKL_DEGTORAD){
HklGeometryList *geometries;
geometries = hkl_engine_pseudo_axis_values_set(engine, &psi, 1,
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, psi));
}
hkl_geometry_list_free(geometries);
}
}
}
ok(res == TRUE, "psi setter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void q(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4ch(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "q", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double q;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(q=-1.; q<1.; q += 0.1){
HklGeometryList *geometries;
geometries = hkl_engine_pseudo_axis_values_set(engine, &q, 1,
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, &q, 1));
}
hkl_geometry_list_free(geometries);
}
}
}
ok(res == TRUE, "q");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void hkl_psi_constant_horizontal(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklGeometryList *geometries;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {1, 0, 1};
static double hkl2[] = {1, 1, 0};
struct Geometry gconf = E4ch(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
res &= DIAG(hkl_engine_current_mode_set(engine, "psi_constant", NULL));
/* the init part */
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl2, ARRAY_SIZE(hkl2),
HKL_UNIT_DEFAULT, NULL));
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
geometries = hkl_engine_pseudo_axis_values_set(engine,
hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl)));
}
hkl_geometry_list_free(geometries);
}
ok(res == TRUE, "psi constant horizontal");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void petra3_p01(void)
{
int res = TRUE;
HklGeometryList *solutions;
struct Sample sample = {
.name = "Sample",
.lattice = Tetragonal(5.4, 11.9),
.ux = -90 * HKL_DEGTORAD,
.uy = 9 * HKL_DEGTORAD,
.uz = -45 * HKL_DEGTORAD,
};
struct Geometry gconfig = E4ch(4.3687,
0., 0., 6., 0.);
struct Mode mode = ModeHklE4CHConstantPhi;
/* move between each step */
struct Trajectory tconfig1 = TrajectoryHklFromTo(0, 0, 4, 1, 1, 4, 30, mode);
solutions = Trajectory_solve(tconfig1, gconfig, sample, TRUE);
res &= DIAG(NULL != solutions);
hkl_geometry_list_free(solutions);
ok(res == TRUE, __func__);
}
int main(void)
{
plan(7);
getter();
degenerated();
psi_getter();
psi_setter();
q();
hkl_psi_constant_horizontal();
petra3_p01();
return 0;
}
hkl-5.0.0.2569/tests/hkl-quaternion-t.c 0000644 0001751 0001751 00000010462 13447477011 017643 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#include "hkl-vector-private.h"
#include "hkl-quaternion-private.h"
static void assignment(void)
{
HklQuaternion q = {{1, 0, 0, 0}};
HklQuaternion copy = q;
is_double(1., copy.data[0], HKL_EPSILON, __func__);
is_double(0., copy.data[1], HKL_EPSILON, __func__);
is_double(0., copy.data[2], HKL_EPSILON, __func__);
is_double(0., copy.data[3], HKL_EPSILON, __func__);
}
static void cmp(void)
{
HklQuaternion q_ref = {{1., 2., 3., 4.}};
HklQuaternion q = {{1., 2., 3., 4.}};
HklQuaternion q1 = {{1., 1., 3., 4.}};
ok(TRUE == hkl_quaternion_cmp(&q_ref, &q), __func__);
ok(FALSE == hkl_quaternion_cmp(&q_ref, &q1), __func__);
/* test the assignation */
q1 = q_ref;
ok(TRUE == hkl_quaternion_cmp(&q_ref, &q1), __func__);
}
static void init_from_vector(void)
{
HklQuaternion q_ref = {{0, 1, -1, .5}};
HklVector v = {{1., -1., .5}};
HklQuaternion q;
hkl_quaternion_init_from_vector(&q, &v);
ok(TRUE == hkl_quaternion_cmp(&q_ref, &q), __func__);
}
static void init_from_angle_and_axe(void)
{
HklQuaternion q_ref1 = {{1, 0, 0, 0}};
HklQuaternion q_ref2 = {{sqrt(2.)/2., sqrt(2./9.), -sqrt(2./9.), sqrt(1./18.)}};
HklVector v_ref2 = {{1., -1., .5}};
HklQuaternion q;
hkl_quaternion_init_from_angle_and_axe(&q, 0, &v_ref2);
ok(TRUE == hkl_quaternion_cmp(&q_ref1, &q), __func__);
hkl_quaternion_init_from_angle_and_axe(&q, 90. * HKL_DEGTORAD, &v_ref2);
ok(TRUE == hkl_quaternion_cmp(&q_ref2, &q), __func__);
}
static void times_quaternion(void)
{
HklQuaternion q_ref = {{-28., 4., 6., 8.}};
HklQuaternion q = {{1., 2., 3., 4.}};
hkl_quaternion_times_quaternion(&q, &q);
ok(TRUE == hkl_quaternion_cmp(&q_ref, &q), __func__);
}
static void norm2(void)
{
HklQuaternion q = {{1., 2., 3., 4.}};
is_double(sqrt(30.), hkl_quaternion_norm2(&q), HKL_EPSILON, __func__);
}
static void conjugate(void)
{
HklQuaternion q_ref = {{1., -2., -3., -4.}};
HklQuaternion q = {{1., 2., 3., 4.}};
hkl_quaternion_conjugate(&q);
ok(TRUE == hkl_quaternion_cmp(&q_ref, &q), __func__);
}
static void to_matrix(void)
{
HklQuaternion q_ref = {{1./sqrt(2), 0, 0, 1./sqrt(2)}};
HklMatrix *m_ref = hkl_matrix_new_full(0,-1, 0,
1, 0, 0,
0, 0, 1);
HklMatrix *m = hkl_matrix_new();
hkl_quaternion_to_matrix(&q_ref, m);
is_matrix(m_ref, m, __func__);
hkl_matrix_free(m_ref);
hkl_matrix_free(m);
}
static void to_angle_and_axe(void)
{
HklVector v_ref = {{0 ,0, 1}};
HklVector v_null = {{0 ,0, 0}};
HklQuaternion q_I = {{1, 0, 0, 0}};
int i;
double angle_ref;
double angle;
HklVector v;
HklQuaternion q;
/* test the q = (1, 0, 0, 0) solution axe == (0, 0, 0) and angle = 0. */
hkl_quaternion_to_angle_and_axe(&q_I, &angle, &v);
ok(0 == hkl_vector_cmp(&v_null, &v), __func__);
is_double(0., angle, HKL_EPSILON, __func__);
/* test other cases */
for(i=-180; i<180; i++) {
angle_ref = i * HKL_DEGTORAD;
hkl_quaternion_init_from_angle_and_axe(&q, angle_ref, &v_ref);
hkl_quaternion_to_angle_and_axe(&q, &angle, &v);
if (!hkl_vector_cmp(&v_ref, &v))
is_double(angle_ref, angle, HKL_EPSILON, __func__);
else if (hkl_vector_is_opposite(&v, &v_ref))
is_double(angle_ref, -angle, HKL_EPSILON, __func__);
}
}
int main(void)
{
plan(375);
assignment();
cmp();
init_from_vector();
init_from_angle_and_axe();
times_quaternion();
norm2();
conjugate();
to_matrix();
to_angle_and_axe();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-t.c 0000644 0001751 0001751 00000043074 13447477011 017647 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include
#include
#include "hkl.h"
#include
#include
#define DEBUG
typedef int (* test_func) (HklEngine *engine, HklEngineList *engine_list, unsigned int n);
static int __test(unsigned int nb_iter, test_func f, int foreach_mode)
{
HklFactory **factories;
size_t i, j, n;
HklGeometry *geometry = NULL;
HklDetector *detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
HklSample *sample = newSample(cu);
HklEngineList *engines;
int res = TRUE;
const char **mode;
factories = hkl_factory_get_all(&n);
for(i=0; i geometry */
if(HKL_ENGINE_CAPABILITIES_INITIALIZABLE & hkl_engine_capabilities_get(engine))
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
res &= DIAG(hkl_engine_pseudo_axis_values_get(engine, currents, n_pseudo_axes,
HKL_UNIT_DEFAULT, NULL));
/* idem with error management */
error = NULL;
res &= DIAG(hkl_engine_pseudo_axis_values_get(engine, currents, n_pseudo_axes,
HKL_UNIT_DEFAULT, &error));
res &= DIAG(NULL == error);
for(i=0; i geometry */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, &error));
/* geometry -> pseudo */
solutions = hkl_engine_pseudo_axis_values_set(engine,
targets, n_pseudo_axes,
HKL_UNIT_DEFAULT, &error);
if(solutions) {
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, solutions){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(hkl_engine_pseudo_axis_values_get(engine, currents, n_pseudo_axes, HKL_UNIT_DEFAULT, &error));
for(j=0; j 1)
n = atoi(argv[1]);
else
n = 10;
factories();
parameters();
get();
set(n);
pseudo_axis_get();
capabilities();
initialized();
modes();
axis_names();
mode_parameters();
depends();
return 0;
}
hkl-5.0.0.2569/tests/hkl-pseudoaxis-e4cv-t.c 0000644 0001751 0001751 00000025076 13447477011 020510 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
static void getter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
/* geometry -> pseudo */
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., 0., 1.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., -90., 60.));
res &= DIAG(check_pseudoaxes_v(engine, -1., 0., 0.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 180., 60.));
res &= DIAG(check_pseudoaxes_v(engine, 0., 0., -1.));
res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 0., 135., 90.));
res &= DIAG(check_pseudoaxes_v(engine, 1., 0., -1.));
ok(res == TRUE, "getter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void degenerated(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const char **mode;
const darray_string *modes;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
modes = hkl_engine_modes_names_get(engine);
darray_foreach(mode, *modes){
static double values[] = {0, 0, 1};
HklGeometryList *geometries;
size_t n_params;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
const darray_string *parameters = hkl_engine_parameters_names_get(engine);
n_params = darray_size(*parameters);
if (n_params){
double params[n_params];
hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
params[0] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
}
/* studdy this degenerated case */
geometries = hkl_engine_pseudo_axis_values_set(engine, values, 3, HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, values, ARRAY_SIZE(values)));
}
hkl_geometry_list_free(geometries);
}
}
ok(res == TRUE, "degenerated");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void psi_getter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
double hkl[3];
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
/* the getter part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
/* 1 0 0 */
hkl[0] = 1, hkl[1] = 0, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 0.));
/* 0 1 0*/
hkl[0] = 0, hkl[1] = 1, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 90. * HKL_DEGTORAD));
/* here Q and _ref are colinear must FAIL */
hkl[0] = 0, hkl[1] = 0, hkl[2] = 1;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(!check_pseudoaxes_v(engine, 0. * HKL_DEGTORAD));
/* -1 0 0 */
hkl[0] = -1, hkl[1] = 0, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, 180. * HKL_DEGTORAD));
/* 0 -1 0 */
hkl[0] = 0, hkl[1] = -1, hkl[2] = 0;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(check_pseudoaxes_v(engine, -90. * HKL_DEGTORAD));
/* Q and _ref are colinear so must FAIL */
hkl[0] = 0, hkl[1] = 0, hkl[2] = -1;
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(!check_pseudoaxes_v(engine, 0. * HKL_DEGTORAD));
ok(res == TRUE, "psi getter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void psi_setter(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {1, 0, 0};
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double psi;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(psi=-180 * HKL_DEGTORAD;psi<180 * HKL_DEGTORAD;psi += HKL_DEGTORAD){
HklGeometryList *geometries;
geometries = hkl_engine_pseudo_axis_values_set(engine, &psi, 1,
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes_v(engine, psi));
}
hkl_geometry_list_free(geometries);
}
}
}
ok(res == TRUE, "psi setter");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void q(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
const darray_string *modes;
const char **mode;
HklGeometry *geometry;
HklDetector *detector;
HklSample *sample;
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "q", NULL);
modes = hkl_engine_modes_names_get(engine);
/* the init part */
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
darray_foreach(mode, *modes){
double q;
res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
for(q=-1.; q<1.; q += 0.1){
HklGeometryList *geometries;
geometries = hkl_engine_pseudo_axis_values_set(engine, &q, 1,
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, &q, 1));
}
hkl_geometry_list_free(geometries);
}
}
}
ok(res == TRUE, "q");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
static void hkl_psi_constant_vertical(void)
{
int res = TRUE;
HklEngineList *engines;
HklEngine *engine;
HklGeometry *geometry;
HklGeometryList *geometries;
HklDetector *detector;
HklSample *sample;
static double hkl[] = {1, 0, 1};
static double hkl2[] = {1, 1, 0};
struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
geometry = newGeometry(gconf);
engines = newEngines(gconf);
sample = newSample(cu);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
hkl_engine_list_init(engines, geometry, detector, sample);
engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
res &= DIAG(hkl_engine_current_mode_set(engine, "psi_constant", NULL));
/* the init part */
res &= DIAG(hkl_engine_parameters_values_set(engine, hkl2, ARRAY_SIZE(hkl2), HKL_UNIT_DEFAULT, NULL));
res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
geometries = hkl_engine_pseudo_axis_values_set(engine, hkl, ARRAY_SIZE(hkl),
HKL_UNIT_DEFAULT, NULL);
if(geometries){
const HklGeometryListItem *item;
HKL_GEOMETRY_LIST_FOREACH(item, geometries){
hkl_geometry_set(geometry,
hkl_geometry_list_item_geometry_get(item));
res &= DIAG(check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl)));
}
hkl_geometry_list_free(geometries);
}
ok(res == TRUE, "psi constant vertical");
hkl_engine_list_free(engines);
hkl_detector_free(detector);
hkl_sample_free(sample);
hkl_geometry_free(geometry);
}
int main(void)
{
plan(6);
getter();
degenerated();
psi_getter();
psi_setter();
q();
hkl_psi_constant_vertical();
return 0;
}
hkl-5.0.0.2569/tests/hkl-sample-t.c 0000644 0001751 0001751 00000041233 13447477011 016737 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include
#define SET(_sample, _param, _value) do{ \
HklParameter *parameter = hkl_parameter_new_copy(hkl_sample_ ## _param ## _get(_sample)); \
GError *error; \
ok(TRUE == hkl_parameter_value_set(parameter, _value, HKL_UNIT_DEFAULT, NULL), __func__); \
error = NULL; \
ok(TRUE == hkl_parameter_value_set(parameter, _value, HKL_UNIT_DEFAULT, &error), __func__); \
ok(error == NULL, __func__); \
ok(TRUE == hkl_sample_ ## _param ## _set(_sample, parameter, NULL), __func__); \
ok(TRUE == hkl_sample_ ## _param ## _set(_sample, parameter, &error), __func__); \
ok(error == NULL, __func__); \
hkl_parameter_free(parameter); \
}while(0)
#define SET_UX_UY_UZ(_sample, _ux, _uy, _uz) do{ \
SET(_sample, ux, _ux); \
SET(_sample, uy, _uy); \
SET(_sample, uz, _uz); \
}while(0)
#define CHECK(_sample, _param, _value) do{ \
is_double(_value, \
hkl_parameter_value_get(hkl_sample_## _param ## _get(sample), HKL_UNIT_DEFAULT), \
HKL_EPSILON, __func__); \
}while(0)
#define CHECK_UX_UY_UZ(_sample, _ux, _uy, _uz) do{ \
CHECK(_sample, ux, _ux); \
CHECK(_sample, uy, _uy); \
CHECK(_sample, uz, _uz); \
}while(0)
static void new(void)
{
HklSample *sample;
sample = hkl_sample_new("test");
hkl_sample_free(sample);
}
static void add_reflection(void)
{
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklSampleReflection *ref;
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
ok(hkl_sample_n_reflections_get(sample) == 0, __func__);
ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
/* we can not add two times the same reflection */
hkl_sample_add_reflection(sample, ref);
ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
}
static void get_reflection(void)
{
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklSampleReflection *ref;
HklSampleReflection *ref2;
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ref2 = hkl_sample_reflections_first_get(sample);
ok(0 == !ref, __func__);
ok(ref == ref2, __func__);
ok(NULL == hkl_sample_reflections_next_get(sample, ref2), __func__);
ref = hkl_sample_reflection_new(geometry, detector, -1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
hkl_sample_add_reflection(sample, ref);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
}
static void del_reflection(void)
{
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklSampleReflection *ref;
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
hkl_sample_del_reflection(sample, ref);
ok(hkl_sample_n_reflections_get(sample) == 0, __func__);
ok (NULL == hkl_sample_reflections_first_get(sample), __func__);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
}
static void set_ux_uy_uz(void)
{
HklSample *sample;
sample = hkl_sample_new("test");
SET_UX_UY_UZ(sample, 1 * HKL_DEGTORAD, 2 * HKL_DEGTORAD, 3 * HKL_DEGTORAD);
CHECK_UX_UY_UZ(sample, 1 * HKL_DEGTORAD, 2 * HKL_DEGTORAD, 3 * HKL_DEGTORAD);
hkl_sample_free(sample);
}
static void set_UB(void)
{
GError *error;
HklSample *sample;
const HklMatrix *_UB;
HklMatrix *UB = hkl_matrix_new_full(HKL_TAU/1.54, 0., 0.,
0., 0., HKL_TAU/1.54,
0., -HKL_TAU/1.54, 0.);
HklMatrix *U = hkl_matrix_new_full(1., 0., 0.,
0., 0., 1.,
0.,-1., 0.);
HklMatrix *UB_wrong = hkl_matrix_new_full(0., 0., 0.,
0., 0., 0.,
0., 0., 0.);
sample = hkl_sample_new("test");
/* check that reading and writing the current UB works */
_UB = hkl_sample_UB_get(sample);
ok(TRUE == hkl_sample_UB_set(sample, _UB, NULL), __func__);
error = NULL;
ok(TRUE == hkl_sample_UB_set(sample, _UB, &error), __func__);
ok(error == NULL, __func__);
CHECK_UX_UY_UZ(sample, 0., 0., 0.);
/* set a new valid UB matrix */
error = NULL;
ok(TRUE == hkl_sample_UB_set(sample, UB, NULL), __func__);
ok(TRUE == hkl_sample_UB_set(sample, UB, &error), __func__);
ok(error == NULL, __func__);
is_matrix(U, hkl_sample_U_get(sample), __func__);
CHECK_UX_UY_UZ(sample, -90. * HKL_DEGTORAD, 0., 0.);
/* set a non-valid UB matrix */
error = NULL;
ok(FALSE == hkl_sample_UB_set(sample, UB_wrong, &error), __func__);
ok(error != NULL, __func__);
g_clear_error(&error);
is_matrix(U, hkl_sample_U_get(sample), __func__);
hkl_sample_free(sample);
hkl_matrix_free(UB_wrong);
hkl_matrix_free(U);
hkl_matrix_free(UB);
}
static void compute_UB_busing_levy(void)
{
GError *error;
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklSampleReflection *r0, *r1, *r2, *r3;
HklMatrix *m_I = hkl_matrix_new_full(1,0,0,
0,1,0,
0, 0, 1);
HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
0., 0., 1.,
0.,-1., 0.);
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
/* first test */
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
r0 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
hkl_sample_add_reflection(sample, r0);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., -90., 60.), __func__);
r1 = hkl_sample_reflection_new(geometry, detector, -1, 0, 0, NULL);
hkl_sample_add_reflection(sample, r1);
ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r0, r1, NULL), __func__);
is_matrix(m_I, hkl_sample_U_get(sample), __func__);
error = NULL;
ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r0, r1, &error), __func__);
ok(error == NULL, __func__);
is_matrix(m_I, hkl_sample_U_get(sample), __func__);
CHECK_UX_UY_UZ(sample, 0., 0., 0.);
/* second test */
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
r2 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, r2);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 180., 60.), __func__);
r3 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
hkl_sample_add_reflection(sample, r3);
ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r2, r3, NULL), __func__);
is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
error = NULL;
ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r2, r3, &error), __func__);
ok(error == NULL, __func__);
is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
CHECK_UX_UY_UZ(sample, -90. * HKL_DEGTORAD, 0., 0.);
/* failling test */
ok(FALSE == hkl_sample_compute_UB_busing_levy(sample, r0, r0, NULL), __func__);
error = NULL;
ok(FALSE == hkl_sample_compute_UB_busing_levy(sample, r0, r0, &error), __func__);
ok(error != NULL, __func__);
g_clear_error(&error);
is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
hkl_matrix_free(m_ref);
hkl_matrix_free(m_I);
}
static void affine(void)
{
GError *error;
double a, b, c, alpha, beta, gamma;
const HklFactory *factory;
HklDetector *detector;
HklGeometry *geometry;
HklSample *sample;
HklLattice *lattice;
HklSampleReflection *ref;
HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
0., 1., 0.,
0., 0., 1.);
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
lattice = hkl_lattice_new(1, 5, 4,
92 * HKL_DEGTORAD,
81 * HKL_DEGTORAD,
90 * HKL_DEGTORAD,
NULL);
hkl_sample_lattice_set(sample, lattice);
hkl_lattice_free(lattice);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_sample_affine(sample, NULL), __func__);
error = NULL;
ok(TRUE == hkl_sample_affine(sample, &error), __func__);
ok(error == NULL, __func__);
hkl_lattice_get(hkl_sample_lattice_get(sample),
&a, &b, &c, &alpha, &beta, &gamma, HKL_UNIT_DEFAULT);
is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
is_double(1.54, a, HKL_EPSILON, __func__);
is_double(1.54, b, HKL_EPSILON, __func__);
is_double(1.54, c, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
CHECK_UX_UY_UZ(sample, 0., 0., 0.);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
hkl_matrix_free(m_ref);
}
static void get_reflections_xxx_angle(void)
{
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklLattice *lattice;
HklSampleReflection *r0, *r1, *r2, *r3, *r4;
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD,
NULL);
hkl_sample_lattice_set(sample, lattice);
hkl_lattice_free(lattice);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
r0 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, r0);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
r1 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
hkl_sample_add_reflection(sample, r1);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
r2 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
hkl_sample_add_reflection(sample, r2);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
r3 = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
hkl_sample_add_reflection(sample, r3);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
r4 = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
hkl_sample_add_reflection(sample, r4);
is_double(90 * HKL_DEGTORAD,
hkl_sample_get_reflection_theoretical_angle(sample, r0, r1),
HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD,
hkl_sample_get_reflection_measured_angle(sample, r0, r1),
HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD,
hkl_sample_get_reflection_theoretical_angle(sample, r1, r2),
HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD,
hkl_sample_get_reflection_measured_angle(sample, r1, r2),
HKL_EPSILON, __func__);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
}
static void reflection_set_geometry(void)
{
double a, b, c, alpha, beta, gamma;
HklDetector *detector;
const HklFactory *factory;
HklGeometry *geometry;
HklSample *sample;
HklLattice *lattice;
HklSampleReflection *ref;
HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
0., 1., 0.,
0., 0., 1.);
factory = hkl_factory_get_by_name("E4CV", NULL);
geometry = hkl_factory_create_new_geometry(factory);
detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
sample = hkl_sample_new("test");
lattice = hkl_lattice_new(1.54, 1.54, 1.54,
90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD,
NULL);
hkl_sample_lattice_set(sample, lattice);
hkl_lattice_free(lattice);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
hkl_sample_add_reflection(sample, ref);
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 46., 45., 45., 60.), __func__);
ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
hkl_sample_add_reflection(sample, ref);
/* correct the last reflection so the sample affinement must be ok. */
ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
hkl_sample_reflection_geometry_set(ref, geometry);
ok(TRUE == hkl_sample_affine(sample, NULL), __func__);
hkl_lattice_get(hkl_sample_lattice_get(sample),
&a, &b, &c, &alpha, &beta, &gamma,
HKL_UNIT_DEFAULT);
is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
is_double(1.54, a, HKL_EPSILON, __func__);
is_double(1.54, b, HKL_EPSILON, __func__);
is_double(1.54, c, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
CHECK_UX_UY_UZ(sample, 0., 0., 0.);
hkl_sample_free(sample);
hkl_detector_free(detector);
hkl_geometry_free(geometry);
hkl_matrix_free(m_ref);
}
int main(void)
{
plan(114);
new();
add_reflection();
get_reflection();
del_reflection();
set_ux_uy_uz();
set_UB();
compute_UB_busing_levy();
affine();
get_reflections_xxx_angle();
reflection_set_geometry();
return 0;
}
hkl-5.0.0.2569/tests/hkl-matrix-t.c 0000644 0001751 0001751 00000010145 13447477011 016760 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include "hkl.h"
#include
#include
#include "hkl-vector-private.h"
#include "hkl-matrix-private.h" /* we will check also the private API */
static void init(void)
{
HklMatrix m;
hkl_matrix_init(&m, 1, 1, 0, 0, 1, 0, 0, 0, 1);
is_double(1., m.data[0][0], HKL_EPSILON, __func__);
is_double(1., m.data[0][1], HKL_EPSILON, __func__);
is_double(0., m.data[0][2], HKL_EPSILON, __func__);
is_double(0., m.data[1][0], HKL_EPSILON, __func__);
is_double(1., m.data[1][1], HKL_EPSILON, __func__);
is_double(0., m.data[1][2], HKL_EPSILON, __func__);
is_double(0., m.data[2][0], HKL_EPSILON, __func__);
is_double(0., m.data[2][1], HKL_EPSILON, __func__);
is_double(1., m.data[2][2], HKL_EPSILON, __func__);
}
static void cmp(void)
{
HklMatrix m1 = {{{0.0, 1.0, 2.0},
{3.0, 4.0, 5.0},
{6.0, 7.0, 8.0}}};
HklMatrix m2 = {{{1.0, 1.0, 2.0},
{3.0, 4.0, 5.0},
{6.0, 7.0, 8.0}}};
ok(TRUE == hkl_matrix_cmp(&m1, &m1), __func__);
ok(FALSE == hkl_matrix_cmp(&m1, &m2), __func__);
}
static void dup(void)
{
HklMatrix m1 = {{{0.0, 1.0, 2.0},
{3.0, 4.0, 5.0},
{6.0, 7.0, 8.0}}};
HklMatrix *m;
m = hkl_matrix_dup(&m1);
ok(TRUE == hkl_matrix_cmp(&m1, m), __func__);
hkl_matrix_free(m);
}
static void assignement(void)
{
HklMatrix m1 = {{{0.0, 1.0, 2.0},
{3.0, 4.0, 5.0},
{6.0, 7.0, 8.0}}};
HklMatrix m;
m = m1;
ok(TRUE == hkl_matrix_cmp(&m1, &m), __func__);
}
static void init_from_euler(void)
{
HklMatrix m_ref = {{{ 1./2., -1./2., sqrt(2)/2.},
{ sqrt(2.)/4.+1./2., -sqrt(2.)/4.+1./2., -1./2.},
{-sqrt(2.)/4.+1./2., sqrt(2.)/4.+1./2., 1./2.}}};
HklMatrix m;
hkl_matrix_init_from_euler(&m, 45.*HKL_DEGTORAD, 45.*HKL_DEGTORAD, 45.*HKL_DEGTORAD);
ok(TRUE == hkl_matrix_cmp(&m_ref, &m), __func__);
}
static void init_from_two_vector(void)
{
HklVector v1 = {{0.0, 1.0, 2.0}};
HklVector v2 = {{1.0, 2.0, 3.0}};
HklMatrix m_ref = {{{0.0, 5.0 / sqrt(30.0), -1.0 / sqrt(6.0)},
{1.0 / sqrt(5.0), 2.0 / sqrt(30.0), 2.0 / sqrt(6.0)},
{2.0 / sqrt(5.0),-1.0 / sqrt(30.0), -1.0 / sqrt(6.0)}}
};
HklMatrix m;
hkl_matrix_init_from_two_vector(&m, &v1, &v2);
ok(TRUE == hkl_matrix_cmp(&m_ref, &m), __func__);
}
static void times_vector(void)
{
HklMatrix m = {{{ 1.0, 3.0,-2.0},
{10.0, 5.0, 5.0},
{-3.0, 2.0, 0.0}}
};
HklVector v = {{1, 2, 3}};
HklVector v_ref = {{1, 35, 1}};
hkl_matrix_times_vector(&m, &v);
ok(0 == hkl_vector_cmp(&v_ref, &v), __func__);
}
static void times_matrix(void)
{
HklMatrix m_ref = {{{37., 14., 13.},
{45., 65., 5.},
{17., 1., 16.}}
};
HklMatrix m = {{{ 1., 3.,-2.},
{10., 5., 5.},
{-3., 2., 0.}}
};
hkl_matrix_times_matrix(&m, &m);
ok(TRUE == hkl_matrix_cmp(&m_ref, &m), __func__);
}
static void transpose(void)
{
HklMatrix m_ref = {{{37., 14., 13.},
{45., 65., 5.},
{17., 1., 16.}}
};
HklMatrix m = {{{37., 45., 17.},
{14., 65., 1.},
{13., 5., 16.}}
};
hkl_matrix_transpose(&m);
ok(TRUE == hkl_matrix_cmp(&m_ref, &m), __func__);
}
int main(void)
{
plan(18);
init();
cmp();
dup();
assignement();
init_from_euler();
init_from_two_vector();
times_vector();
times_matrix();
transpose();
return 0;
}
hkl-5.0.0.2569/tests/Makefile.in 0000644 0001751 0001751 00000140325 13574156672 016354 0 ustar 00picca picca 0000000 0000000 # Makefile.in generated by automake 1.16.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2018 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = { \
if test -z '$(MAKELEVEL)'; then \
false; \
elif test -n '$(MAKE_HOST)'; then \
true; \
elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
true; \
else \
false; \
fi; \
}
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
@HAVE_INTROSPECTION_TRUE@am__append_1 = bindings
@HKL3D_TRUE@am__append_2 = hkl3d-test-t
@HKL3D_TRUE@am__append_3 = -I$(top_srcdir)/hkl3d \
@HKL3D_TRUE@ $(G3D_CFLAGS) \
@HKL3D_TRUE@ $(BULLET_CFLAGS)
@HKL3D_TRUE@am__append_4 = $(top_builddir)/hkl3d/libhkl3d.la \
@HKL3D_TRUE@ $(BULLET_LIBS)
check_PROGRAMS = runtests$(EXEEXT) $(am__EXEEXT_2)
subdir = tests
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/gtk-doc.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
@HKL3D_TRUE@am__EXEEXT_1 = hkl3d-test-t$(EXEEXT)
am__EXEEXT_2 = hkl-unit-t$(EXEEXT) hkl-bench-t$(EXEEXT) \
hkl-axis-t$(EXEEXT) hkl-quaternion-t$(EXEEXT) \
hkl-interval-t$(EXEEXT) hkl-sample-t$(EXEEXT) \
hkl-lattice-t$(EXEEXT) hkl-source-t$(EXEEXT) \
hkl-detector-t$(EXEEXT) hkl-matrix-t$(EXEEXT) \
hkl-vector-t$(EXEEXT) hkl-geometry-t$(EXEEXT) \
hkl-parameter-t$(EXEEXT) hkl-pseudoaxis-t$(EXEEXT) \
hkl-pseudoaxis-e4cv-t$(EXEEXT) hkl-pseudoaxis-e4ch-t$(EXEEXT) \
hkl-pseudoaxis-e6c-t$(EXEEXT) hkl-pseudoaxis-k4cv-t$(EXEEXT) \
hkl-pseudoaxis-k6c-t$(EXEEXT) \
hkl-pseudoaxis-soleil-sirius-kappa-t$(EXEEXT) \
hkl-pseudoaxis-soleil-sixs-med-t$(EXEEXT) \
hkl-pseudoaxis-zaxis-t$(EXEEXT) $(am__EXEEXT_1)
hkl_axis_t_SOURCES = hkl-axis-t.c
hkl_axis_t_OBJECTS = hkl-axis-t.$(OBJEXT)
hkl_axis_t_LDADD = $(LDADD)
am__DEPENDENCIES_1 =
@HKL3D_TRUE@am__DEPENDENCIES_2 = $(top_builddir)/hkl3d/libhkl3d.la \
@HKL3D_TRUE@ $(am__DEPENDENCIES_1)
hkl_axis_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 =
hkl_bench_t_SOURCES = hkl-bench-t.c
hkl_bench_t_OBJECTS = hkl-bench-t.$(OBJEXT)
hkl_bench_t_LDADD = $(LDADD)
hkl_bench_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_detector_t_SOURCES = hkl-detector-t.c
hkl_detector_t_OBJECTS = hkl-detector-t.$(OBJEXT)
hkl_detector_t_LDADD = $(LDADD)
hkl_detector_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_geometry_t_SOURCES = hkl-geometry-t.c
hkl_geometry_t_OBJECTS = hkl-geometry-t.$(OBJEXT)
hkl_geometry_t_LDADD = $(LDADD)
hkl_geometry_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_interval_t_SOURCES = hkl-interval-t.c
hkl_interval_t_OBJECTS = hkl-interval-t.$(OBJEXT)
hkl_interval_t_LDADD = $(LDADD)
hkl_interval_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_lattice_t_SOURCES = hkl-lattice-t.c
hkl_lattice_t_OBJECTS = hkl-lattice-t.$(OBJEXT)
hkl_lattice_t_LDADD = $(LDADD)
hkl_lattice_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_matrix_t_SOURCES = hkl-matrix-t.c
hkl_matrix_t_OBJECTS = hkl-matrix-t.$(OBJEXT)
hkl_matrix_t_LDADD = $(LDADD)
hkl_matrix_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_parameter_t_SOURCES = hkl-parameter-t.c
hkl_parameter_t_OBJECTS = hkl-parameter-t.$(OBJEXT)
hkl_parameter_t_LDADD = $(LDADD)
hkl_parameter_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_e4ch_t_SOURCES = hkl-pseudoaxis-e4ch-t.c
hkl_pseudoaxis_e4ch_t_OBJECTS = hkl-pseudoaxis-e4ch-t.$(OBJEXT)
hkl_pseudoaxis_e4ch_t_LDADD = $(LDADD)
hkl_pseudoaxis_e4ch_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_e4cv_t_SOURCES = hkl-pseudoaxis-e4cv-t.c
hkl_pseudoaxis_e4cv_t_OBJECTS = hkl-pseudoaxis-e4cv-t.$(OBJEXT)
hkl_pseudoaxis_e4cv_t_LDADD = $(LDADD)
hkl_pseudoaxis_e4cv_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_e6c_t_SOURCES = hkl-pseudoaxis-e6c-t.c
hkl_pseudoaxis_e6c_t_OBJECTS = hkl-pseudoaxis-e6c-t.$(OBJEXT)
hkl_pseudoaxis_e6c_t_LDADD = $(LDADD)
hkl_pseudoaxis_e6c_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_k4cv_t_SOURCES = hkl-pseudoaxis-k4cv-t.c
hkl_pseudoaxis_k4cv_t_OBJECTS = hkl-pseudoaxis-k4cv-t.$(OBJEXT)
hkl_pseudoaxis_k4cv_t_LDADD = $(LDADD)
hkl_pseudoaxis_k4cv_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_k6c_t_SOURCES = hkl-pseudoaxis-k6c-t.c
hkl_pseudoaxis_k6c_t_OBJECTS = hkl-pseudoaxis-k6c-t.$(OBJEXT)
hkl_pseudoaxis_k6c_t_LDADD = $(LDADD)
hkl_pseudoaxis_k6c_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_soleil_sirius_kappa_t_SOURCES = \
hkl-pseudoaxis-soleil-sirius-kappa-t.c
hkl_pseudoaxis_soleil_sirius_kappa_t_OBJECTS = \
hkl-pseudoaxis-soleil-sirius-kappa-t.$(OBJEXT)
hkl_pseudoaxis_soleil_sirius_kappa_t_LDADD = $(LDADD)
hkl_pseudoaxis_soleil_sirius_kappa_t_DEPENDENCIES = \
$(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_soleil_sixs_med_t_SOURCES = \
hkl-pseudoaxis-soleil-sixs-med-t.c
hkl_pseudoaxis_soleil_sixs_med_t_OBJECTS = \
hkl-pseudoaxis-soleil-sixs-med-t.$(OBJEXT)
hkl_pseudoaxis_soleil_sixs_med_t_LDADD = $(LDADD)
hkl_pseudoaxis_soleil_sixs_med_t_DEPENDENCIES = \
$(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_t_SOURCES = hkl-pseudoaxis-t.c
hkl_pseudoaxis_t_OBJECTS = hkl-pseudoaxis-t.$(OBJEXT)
hkl_pseudoaxis_t_LDADD = $(LDADD)
hkl_pseudoaxis_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_pseudoaxis_zaxis_t_SOURCES = hkl-pseudoaxis-zaxis-t.c
hkl_pseudoaxis_zaxis_t_OBJECTS = hkl-pseudoaxis-zaxis-t.$(OBJEXT)
hkl_pseudoaxis_zaxis_t_LDADD = $(LDADD)
hkl_pseudoaxis_zaxis_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_quaternion_t_SOURCES = hkl-quaternion-t.c
hkl_quaternion_t_OBJECTS = hkl-quaternion-t.$(OBJEXT)
hkl_quaternion_t_LDADD = $(LDADD)
hkl_quaternion_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_sample_t_SOURCES = hkl-sample-t.c
hkl_sample_t_OBJECTS = hkl-sample-t.$(OBJEXT)
hkl_sample_t_LDADD = $(LDADD)
hkl_sample_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_source_t_SOURCES = hkl-source-t.c
hkl_source_t_OBJECTS = hkl-source-t.$(OBJEXT)
hkl_source_t_LDADD = $(LDADD)
hkl_source_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_unit_t_SOURCES = hkl-unit-t.c
hkl_unit_t_OBJECTS = hkl-unit-t.$(OBJEXT)
hkl_unit_t_LDADD = $(LDADD)
hkl_unit_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl_vector_t_SOURCES = hkl-vector-t.c
hkl_vector_t_OBJECTS = hkl-vector-t.$(OBJEXT)
hkl_vector_t_LDADD = $(LDADD)
hkl_vector_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
hkl3d_test_t_SOURCES = hkl3d-test-t.c
hkl3d_test_t_OBJECTS = hkl3d-test-t.$(OBJEXT)
hkl3d_test_t_LDADD = $(LDADD)
hkl3d_test_t_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
runtests_SOURCES = runtests.c
runtests_OBJECTS = runtests.$(OBJEXT)
runtests_LDADD = $(LDADD)
runtests_DEPENDENCIES = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_2)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/config/depcomp
am__maybe_remake_depfiles = depfiles
am__depfiles_remade = ./$(DEPDIR)/dummy.Po ./$(DEPDIR)/hkl-axis-t.Po \
./$(DEPDIR)/hkl-bench-t.Po ./$(DEPDIR)/hkl-detector-t.Po \
./$(DEPDIR)/hkl-geometry-t.Po ./$(DEPDIR)/hkl-interval-t.Po \
./$(DEPDIR)/hkl-lattice-t.Po ./$(DEPDIR)/hkl-matrix-t.Po \
./$(DEPDIR)/hkl-parameter-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-e4ch-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-e4cv-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-e6c-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-k4cv-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-k6c-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-soleil-sirius-kappa-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-soleil-sixs-med-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-t.Po \
./$(DEPDIR)/hkl-pseudoaxis-zaxis-t.Po \
./$(DEPDIR)/hkl-quaternion-t.Po ./$(DEPDIR)/hkl-sample-t.Po \
./$(DEPDIR)/hkl-source-t.Po ./$(DEPDIR)/hkl-unit-t.Po \
./$(DEPDIR)/hkl-vector-t.Po ./$(DEPDIR)/hkl3d-test-t.Po \
./$(DEPDIR)/runtests.Po
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
$(AM_CFLAGS) $(CFLAGS)
AM_V_CC = $(am__v_CC_@AM_V@)
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
am__v_CC_0 = @echo " CC " $@;
am__v_CC_1 =
CCLD = $(CC)
LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
am__v_CCLD_0 = @echo " CCLD " $@;
am__v_CCLD_1 =
CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
$(AM_CXXFLAGS) $(CXXFLAGS)
AM_V_CXX = $(am__v_CXX_@AM_V@)
am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
am__v_CXX_0 = @echo " CXX " $@;
am__v_CXX_1 =
CXXLD = $(CXX)
CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
am__v_CXXLD_0 = @echo " CXXLD " $@;
am__v_CXXLD_1 =
SOURCES = hkl-axis-t.c hkl-bench-t.c hkl-detector-t.c hkl-geometry-t.c \
hkl-interval-t.c hkl-lattice-t.c hkl-matrix-t.c \
hkl-parameter-t.c hkl-pseudoaxis-e4ch-t.c \
hkl-pseudoaxis-e4cv-t.c hkl-pseudoaxis-e6c-t.c \
hkl-pseudoaxis-k4cv-t.c hkl-pseudoaxis-k6c-t.c \
hkl-pseudoaxis-soleil-sirius-kappa-t.c \
hkl-pseudoaxis-soleil-sixs-med-t.c hkl-pseudoaxis-t.c \
hkl-pseudoaxis-zaxis-t.c hkl-quaternion-t.c hkl-sample-t.c \
hkl-source-t.c hkl-unit-t.c hkl-vector-t.c \
$(nodist_EXTRA_hkl3d_test_t_SOURCES) hkl3d-test-t.c runtests.c
DIST_SOURCES = hkl-axis-t.c hkl-bench-t.c hkl-detector-t.c \
hkl-geometry-t.c hkl-interval-t.c hkl-lattice-t.c \
hkl-matrix-t.c hkl-parameter-t.c hkl-pseudoaxis-e4ch-t.c \
hkl-pseudoaxis-e4cv-t.c hkl-pseudoaxis-e6c-t.c \
hkl-pseudoaxis-k4cv-t.c hkl-pseudoaxis-k6c-t.c \
hkl-pseudoaxis-soleil-sirius-kappa-t.c \
hkl-pseudoaxis-soleil-sixs-med-t.c hkl-pseudoaxis-t.c \
hkl-pseudoaxis-zaxis-t.c hkl-quaternion-t.c hkl-sample-t.c \
hkl-source-t.c hkl-unit-t.c hkl-vector-t.c hkl3d-test-t.c \
runtests.c
RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
ctags-recursive dvi-recursive html-recursive info-recursive \
install-data-recursive install-dvi-recursive \
install-exec-recursive install-html-recursive \
install-info-recursive install-pdf-recursive \
install-ps-recursive install-recursive installcheck-recursive \
installdirs-recursive pdf-recursive ps-recursive \
tags-recursive uninstall-recursive
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
distclean-recursive maintainer-clean-recursive
am__recursive_targets = \
$(RECURSIVE_TARGETS) \
$(RECURSIVE_CLEAN_TARGETS) \
$(am__extra_recursive_targets)
AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
distdir distdir-am
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates. Input order is
# *not* preserved.
am__uniquify_input = $(AWK) '\
BEGIN { nonempty = 0; } \
{ items[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in items) print i; }; } \
'
# Make sure the list of sources is unique. This is necessary because,
# e.g., the same source file might be shared among _SOURCES variables
# for different programs/libraries.
am__define_uniq_tagged_files = \
list='$(am__tagged_files)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = tap . bindings
am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/config/depcomp
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
am__relativize = \
dir0=`pwd`; \
sed_first='s,^\([^/]*\)/.*$$,\1,'; \
sed_rest='s,^[^/]*/*,,'; \
sed_last='s,^.*/\([^/]*\)$$,\1,'; \
sed_butlast='s,/*[^/]*$$,,'; \
while test -n "$$dir1"; do \
first=`echo "$$dir1" | sed -e "$$sed_first"`; \
if test "$$first" != "."; then \
if test "$$first" = ".."; then \
dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
else \
first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
if test "$$first2" = "$$first"; then \
dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
else \
dir2="../$$dir2"; \
fi; \
dir0="$$dir0"/"$$first"; \
fi; \
fi; \
dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
done; \
reldir="$$dir2"
ACLOCAL = @ACLOCAL@
ALLOCA = @ALLOCA@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AR = @AR@
ASY = @ASY@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BULLET_CFLAGS = @BULLET_CFLAGS@
BULLET_LIBS = @BULLET_LIBS@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DLLTOOL = @DLLTOOL@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EMACS = @EMACS@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
G3D_CFLAGS = @G3D_CFLAGS@
G3D_LIBS = @G3D_LIBS@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@
GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
GLIB_LIBS = @GLIB_LIBS@
GLIB_MKENUMS = @GLIB_MKENUMS@
GLU_CFLAGS = @GLU_CFLAGS@
GLU_LIBS = @GLU_LIBS@
GNUPLOT = @GNUPLOT@
GOBJECT_CFLAGS = @GOBJECT_CFLAGS@
GOBJECT_LIBS = @GOBJECT_LIBS@
GOBJECT_QUERY = @GOBJECT_QUERY@
GREP = @GREP@
GSL_CFLAGS = @GSL_CFLAGS@
GSL_CONFIG = @GSL_CONFIG@
GSL_LIBS = @GSL_LIBS@
GTKDOC_CHECK = @GTKDOC_CHECK@
GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@
GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
GTKDOC_MKPDF = @GTKDOC_MKPDF@
GTKDOC_REBASE = @GTKDOC_REBASE@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_LIBS = @GTK_LIBS@
HDF5_CFLAGS = @HDF5_CFLAGS@
HDF5_LIBS = @HDF5_LIBS@
HTML_DIR = @HTML_DIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
INTROSPECTION_CFLAGS = @INTROSPECTION_CFLAGS@
INTROSPECTION_COMPILER = @INTROSPECTION_COMPILER@
INTROSPECTION_GENERATE = @INTROSPECTION_GENERATE@
INTROSPECTION_GIRDIR = @INTROSPECTION_GIRDIR@
INTROSPECTION_LIBS = @INTROSPECTION_LIBS@
INTROSPECTION_MAKEFILE = @INTROSPECTION_MAKEFILE@
INTROSPECTION_SCANNER = @INTROSPECTION_SCANNER@
INTROSPECTION_TYPELIBDIR = @INTROSPECTION_TYPELIBDIR@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
MAKEINFO = @MAKEINFO@
MANIFEST_TOOL = @MANIFEST_TOOL@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
VMAJ = @VMAJ@
YAML_CFLAGS = @YAML_CFLAGS@
YAML_LIBS = @YAML_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
release_info = @release_info@
runstatedir = @runstatedir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
version_info = @version_info@
SUBDIRS = tap . $(am__append_1)
all_tests = hkl-unit-t hkl-bench-t hkl-axis-t hkl-quaternion-t \
hkl-interval-t hkl-sample-t hkl-lattice-t hkl-source-t \
hkl-detector-t hkl-matrix-t hkl-vector-t hkl-geometry-t \
hkl-parameter-t hkl-pseudoaxis-t hkl-pseudoaxis-e4cv-t \
hkl-pseudoaxis-e4ch-t hkl-pseudoaxis-e6c-t \
hkl-pseudoaxis-k4cv-t hkl-pseudoaxis-k6c-t \
hkl-pseudoaxis-soleil-sirius-kappa-t \
hkl-pseudoaxis-soleil-sixs-med-t hkl-pseudoaxis-zaxis-t \
$(am__append_2)
AM_CPPFLAGS = -Wextra -D_DEFAULT_SOURCE -I$(top_srcdir) \
-I$(top_srcdir)/hkl -I$(top_srcdir)/tests $(GLIB_CFLAGS) \
$(GOBJECT_CFLAGS) $(GSL_CFLAGS) $(am__append_3)
AM_LDFLAGS = -Wl,--whole-archive,$(top_builddir)/hkl/.libs/libhkl.a,--no-whole-archive
LDADD = $(top_builddir)/hkl/libhkl.la \
$(top_builddir)/hkl/api2/libhkl2.la \
$(top_builddir)/tests/tap/libtap.a $(GLIB_LIBS) \
$(GOBJECT_LIBS) $(GSL_LIBS) $(am__append_4)
# force linkage with g++
@HKL3D_TRUE@nodist_EXTRA_hkl3d_test_t_SOURCES = dummy.cxx
all: all-recursive
.SUFFIXES:
.SUFFIXES: .c .cxx .lo .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu tests/Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
clean-checkPROGRAMS:
@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
echo " rm -f" $$list; \
rm -f $$list || exit $$?; \
test -n "$(EXEEXT)" || exit 0; \
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
hkl-axis-t$(EXEEXT): $(hkl_axis_t_OBJECTS) $(hkl_axis_t_DEPENDENCIES) $(EXTRA_hkl_axis_t_DEPENDENCIES)
@rm -f hkl-axis-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_axis_t_OBJECTS) $(hkl_axis_t_LDADD) $(LIBS)
hkl-bench-t$(EXEEXT): $(hkl_bench_t_OBJECTS) $(hkl_bench_t_DEPENDENCIES) $(EXTRA_hkl_bench_t_DEPENDENCIES)
@rm -f hkl-bench-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_bench_t_OBJECTS) $(hkl_bench_t_LDADD) $(LIBS)
hkl-detector-t$(EXEEXT): $(hkl_detector_t_OBJECTS) $(hkl_detector_t_DEPENDENCIES) $(EXTRA_hkl_detector_t_DEPENDENCIES)
@rm -f hkl-detector-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_detector_t_OBJECTS) $(hkl_detector_t_LDADD) $(LIBS)
hkl-geometry-t$(EXEEXT): $(hkl_geometry_t_OBJECTS) $(hkl_geometry_t_DEPENDENCIES) $(EXTRA_hkl_geometry_t_DEPENDENCIES)
@rm -f hkl-geometry-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_geometry_t_OBJECTS) $(hkl_geometry_t_LDADD) $(LIBS)
hkl-interval-t$(EXEEXT): $(hkl_interval_t_OBJECTS) $(hkl_interval_t_DEPENDENCIES) $(EXTRA_hkl_interval_t_DEPENDENCIES)
@rm -f hkl-interval-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_interval_t_OBJECTS) $(hkl_interval_t_LDADD) $(LIBS)
hkl-lattice-t$(EXEEXT): $(hkl_lattice_t_OBJECTS) $(hkl_lattice_t_DEPENDENCIES) $(EXTRA_hkl_lattice_t_DEPENDENCIES)
@rm -f hkl-lattice-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_lattice_t_OBJECTS) $(hkl_lattice_t_LDADD) $(LIBS)
hkl-matrix-t$(EXEEXT): $(hkl_matrix_t_OBJECTS) $(hkl_matrix_t_DEPENDENCIES) $(EXTRA_hkl_matrix_t_DEPENDENCIES)
@rm -f hkl-matrix-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_matrix_t_OBJECTS) $(hkl_matrix_t_LDADD) $(LIBS)
hkl-parameter-t$(EXEEXT): $(hkl_parameter_t_OBJECTS) $(hkl_parameter_t_DEPENDENCIES) $(EXTRA_hkl_parameter_t_DEPENDENCIES)
@rm -f hkl-parameter-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_parameter_t_OBJECTS) $(hkl_parameter_t_LDADD) $(LIBS)
hkl-pseudoaxis-e4ch-t$(EXEEXT): $(hkl_pseudoaxis_e4ch_t_OBJECTS) $(hkl_pseudoaxis_e4ch_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_e4ch_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-e4ch-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_e4ch_t_OBJECTS) $(hkl_pseudoaxis_e4ch_t_LDADD) $(LIBS)
hkl-pseudoaxis-e4cv-t$(EXEEXT): $(hkl_pseudoaxis_e4cv_t_OBJECTS) $(hkl_pseudoaxis_e4cv_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_e4cv_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-e4cv-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_e4cv_t_OBJECTS) $(hkl_pseudoaxis_e4cv_t_LDADD) $(LIBS)
hkl-pseudoaxis-e6c-t$(EXEEXT): $(hkl_pseudoaxis_e6c_t_OBJECTS) $(hkl_pseudoaxis_e6c_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_e6c_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-e6c-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_e6c_t_OBJECTS) $(hkl_pseudoaxis_e6c_t_LDADD) $(LIBS)
hkl-pseudoaxis-k4cv-t$(EXEEXT): $(hkl_pseudoaxis_k4cv_t_OBJECTS) $(hkl_pseudoaxis_k4cv_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_k4cv_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-k4cv-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_k4cv_t_OBJECTS) $(hkl_pseudoaxis_k4cv_t_LDADD) $(LIBS)
hkl-pseudoaxis-k6c-t$(EXEEXT): $(hkl_pseudoaxis_k6c_t_OBJECTS) $(hkl_pseudoaxis_k6c_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_k6c_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-k6c-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_k6c_t_OBJECTS) $(hkl_pseudoaxis_k6c_t_LDADD) $(LIBS)
hkl-pseudoaxis-soleil-sirius-kappa-t$(EXEEXT): $(hkl_pseudoaxis_soleil_sirius_kappa_t_OBJECTS) $(hkl_pseudoaxis_soleil_sirius_kappa_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_soleil_sirius_kappa_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-soleil-sirius-kappa-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_soleil_sirius_kappa_t_OBJECTS) $(hkl_pseudoaxis_soleil_sirius_kappa_t_LDADD) $(LIBS)
hkl-pseudoaxis-soleil-sixs-med-t$(EXEEXT): $(hkl_pseudoaxis_soleil_sixs_med_t_OBJECTS) $(hkl_pseudoaxis_soleil_sixs_med_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_soleil_sixs_med_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-soleil-sixs-med-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_soleil_sixs_med_t_OBJECTS) $(hkl_pseudoaxis_soleil_sixs_med_t_LDADD) $(LIBS)
hkl-pseudoaxis-t$(EXEEXT): $(hkl_pseudoaxis_t_OBJECTS) $(hkl_pseudoaxis_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_t_OBJECTS) $(hkl_pseudoaxis_t_LDADD) $(LIBS)
hkl-pseudoaxis-zaxis-t$(EXEEXT): $(hkl_pseudoaxis_zaxis_t_OBJECTS) $(hkl_pseudoaxis_zaxis_t_DEPENDENCIES) $(EXTRA_hkl_pseudoaxis_zaxis_t_DEPENDENCIES)
@rm -f hkl-pseudoaxis-zaxis-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_pseudoaxis_zaxis_t_OBJECTS) $(hkl_pseudoaxis_zaxis_t_LDADD) $(LIBS)
hkl-quaternion-t$(EXEEXT): $(hkl_quaternion_t_OBJECTS) $(hkl_quaternion_t_DEPENDENCIES) $(EXTRA_hkl_quaternion_t_DEPENDENCIES)
@rm -f hkl-quaternion-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_quaternion_t_OBJECTS) $(hkl_quaternion_t_LDADD) $(LIBS)
hkl-sample-t$(EXEEXT): $(hkl_sample_t_OBJECTS) $(hkl_sample_t_DEPENDENCIES) $(EXTRA_hkl_sample_t_DEPENDENCIES)
@rm -f hkl-sample-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_sample_t_OBJECTS) $(hkl_sample_t_LDADD) $(LIBS)
hkl-source-t$(EXEEXT): $(hkl_source_t_OBJECTS) $(hkl_source_t_DEPENDENCIES) $(EXTRA_hkl_source_t_DEPENDENCIES)
@rm -f hkl-source-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_source_t_OBJECTS) $(hkl_source_t_LDADD) $(LIBS)
hkl-unit-t$(EXEEXT): $(hkl_unit_t_OBJECTS) $(hkl_unit_t_DEPENDENCIES) $(EXTRA_hkl_unit_t_DEPENDENCIES)
@rm -f hkl-unit-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_unit_t_OBJECTS) $(hkl_unit_t_LDADD) $(LIBS)
hkl-vector-t$(EXEEXT): $(hkl_vector_t_OBJECTS) $(hkl_vector_t_DEPENDENCIES) $(EXTRA_hkl_vector_t_DEPENDENCIES)
@rm -f hkl-vector-t$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(hkl_vector_t_OBJECTS) $(hkl_vector_t_LDADD) $(LIBS)
hkl3d-test-t$(EXEEXT): $(hkl3d_test_t_OBJECTS) $(hkl3d_test_t_DEPENDENCIES) $(EXTRA_hkl3d_test_t_DEPENDENCIES)
@rm -f hkl3d-test-t$(EXEEXT)
$(AM_V_CXXLD)$(CXXLINK) $(hkl3d_test_t_OBJECTS) $(hkl3d_test_t_LDADD) $(LIBS)
runtests$(EXEEXT): $(runtests_OBJECTS) $(runtests_DEPENDENCIES) $(EXTRA_runtests_DEPENDENCIES)
@rm -f runtests$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(runtests_OBJECTS) $(runtests_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dummy.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-axis-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-bench-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-detector-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-geometry-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-interval-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-lattice-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-matrix-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-parameter-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-e4ch-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-e4cv-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-e6c-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-k4cv-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-k6c-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-soleil-sirius-kappa-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-soleil-sixs-med-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-pseudoaxis-zaxis-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-quaternion-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-sample-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-source-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-unit-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl-vector-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hkl3d-test-t.Po@am__quote@ # am--include-marker
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtests.Po@am__quote@ # am--include-marker
$(am__depfiles_remade):
@$(MKDIR_P) $(@D)
@echo '# dummy' >$@-t && $(am__mv) $@-t $@
am--depfiles: $(am__depfiles_remade)
.c.o:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
.c.obj:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
.cxx.o:
@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
.cxx.obj:
@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
.cxx.lo:
@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
# This directory's subdirectories are mostly independent; you can cd
# into them and run 'make' without going through this Makefile.
# To change the values of 'make' variables: instead of editing Makefiles,
# (1) if the variable is set in 'config.status', edit 'config.status'
# (which will cause the Makefiles to be regenerated when you run 'make');
# (2) otherwise, pass the desired values on the 'make' command line.
$(am__recursive_targets):
@fail=; \
if $(am__make_keepgoing); then \
failcom='fail=yes'; \
else \
failcom='exit 1'; \
fi; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
case "$@" in \
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
*) list='$(SUBDIRS)' ;; \
esac; \
for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
ID: $(am__tagged_files)
$(am__define_uniq_tagged_files); mkid -fID $$unique
tags: tags-recursive
TAGS: tags
tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
set x; \
here=`pwd`; \
if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
include_option=--etags-include; \
empty_fix=.; \
else \
include_option=--include; \
empty_fix=; \
fi; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test ! -f $$subdir/TAGS || \
set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
fi; \
done; \
$(am__define_uniq_tagged_files); \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: ctags-recursive
CTAGS: ctags
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
$(am__define_uniq_tagged_files); \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
cscopelist: cscopelist-recursive
cscopelist-am: $(am__tagged_files)
list='$(am__tagged_files)'; \
case "$(srcdir)" in \
[\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
*) sdir=$(subdir)/$(srcdir) ;; \
esac; \
for i in $$list; do \
if test -f "$$i"; then \
echo "$(subdir)/$$i"; \
else \
echo "$$sdir/$$i"; \
fi; \
done >> $(top_builddir)/cscope.files
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
distdir-am: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
$(am__make_dryrun) \
|| test -d "$(distdir)/$$subdir" \
|| $(MKDIR_P) "$(distdir)/$$subdir" \
|| exit 1; \
dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
$(am__relativize); \
new_distdir=$$reldir; \
dir1=$$subdir; dir2="$(top_distdir)"; \
$(am__relativize); \
new_top_distdir=$$reldir; \
echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
($(am__cd) $$subdir && \
$(MAKE) $(AM_MAKEFLAGS) \
top_distdir="$$new_top_distdir" \
distdir="$$new_distdir" \
am__remove_distdir=: \
am__skip_length_check=: \
am__skip_mode_fix=: \
distdir) \
|| exit 1; \
fi; \
done
check-am: all-am
$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
$(MAKE) $(AM_MAKEFLAGS) check-local
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-recursive
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive
clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
mostlyclean-am
distclean: distclean-recursive
-rm -f ./$(DEPDIR)/dummy.Po
-rm -f ./$(DEPDIR)/hkl-axis-t.Po
-rm -f ./$(DEPDIR)/hkl-bench-t.Po
-rm -f ./$(DEPDIR)/hkl-detector-t.Po
-rm -f ./$(DEPDIR)/hkl-geometry-t.Po
-rm -f ./$(DEPDIR)/hkl-interval-t.Po
-rm -f ./$(DEPDIR)/hkl-lattice-t.Po
-rm -f ./$(DEPDIR)/hkl-matrix-t.Po
-rm -f ./$(DEPDIR)/hkl-parameter-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e4ch-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e4cv-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e6c-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-k4cv-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-k6c-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-soleil-sirius-kappa-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-soleil-sixs-med-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-zaxis-t.Po
-rm -f ./$(DEPDIR)/hkl-quaternion-t.Po
-rm -f ./$(DEPDIR)/hkl-sample-t.Po
-rm -f ./$(DEPDIR)/hkl-source-t.Po
-rm -f ./$(DEPDIR)/hkl-unit-t.Po
-rm -f ./$(DEPDIR)/hkl-vector-t.Po
-rm -f ./$(DEPDIR)/hkl3d-test-t.Po
-rm -f ./$(DEPDIR)/runtests.Po
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-recursive
dvi-am:
html: html-recursive
html-am:
info: info-recursive
info-am:
install-data-am:
install-dvi: install-dvi-recursive
install-dvi-am:
install-exec-am:
install-html: install-html-recursive
install-html-am:
install-info: install-info-recursive
install-info-am:
install-man:
install-pdf: install-pdf-recursive
install-pdf-am:
install-ps: install-ps-recursive
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-recursive
-rm -f ./$(DEPDIR)/dummy.Po
-rm -f ./$(DEPDIR)/hkl-axis-t.Po
-rm -f ./$(DEPDIR)/hkl-bench-t.Po
-rm -f ./$(DEPDIR)/hkl-detector-t.Po
-rm -f ./$(DEPDIR)/hkl-geometry-t.Po
-rm -f ./$(DEPDIR)/hkl-interval-t.Po
-rm -f ./$(DEPDIR)/hkl-lattice-t.Po
-rm -f ./$(DEPDIR)/hkl-matrix-t.Po
-rm -f ./$(DEPDIR)/hkl-parameter-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e4ch-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e4cv-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-e6c-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-k4cv-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-k6c-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-soleil-sirius-kappa-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-soleil-sixs-med-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-t.Po
-rm -f ./$(DEPDIR)/hkl-pseudoaxis-zaxis-t.Po
-rm -f ./$(DEPDIR)/hkl-quaternion-t.Po
-rm -f ./$(DEPDIR)/hkl-sample-t.Po
-rm -f ./$(DEPDIR)/hkl-source-t.Po
-rm -f ./$(DEPDIR)/hkl-unit-t.Po
-rm -f ./$(DEPDIR)/hkl-vector-t.Po
-rm -f ./$(DEPDIR)/hkl3d-test-t.Po
-rm -f ./$(DEPDIR)/runtests.Po
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-recursive
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-recursive
pdf-am:
ps: ps-recursive
ps-am:
uninstall-am:
.MAKE: $(am__recursive_targets) check-am install-am install-strip
.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
am--depfiles check check-am check-local clean \
clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \
ctags ctags-am distclean distclean-compile distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs installdirs-am maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags tags-am uninstall uninstall-am
.PRECIOUS: Makefile
check-local: $(check_PROGRAMS)
./runtests -v -s $(abs_top_srcdir) $(all_tests)
# Support for GNU Flymake, in Emacs.
check-syntax: AM_CFLAGS += -fsyntax-only -pipe
check-syntax:
test -z "$(CHK_SOURCES)" || $(COMPILE) $(CHK_SOURCES)
.PHONY: check-syntax
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
hkl-5.0.0.2569/README 0000644 0001751 0001751 00000000737 13175414511 014011 0 ustar 00picca picca 0000000 0000000 To build you need
-PREREQUIRED
gsl >= 1.12 (lib -- required) http://www.gnu.org/software/gsl/
gtkmm >= 2.18 (gui -- optional) http://www.gtkmm.org
libg3d (gui -- optional) http://automagically.de/g3dviewer/
libyaml (gui -- optional) http://pyyaml.org/wiki/LibYAML
gtk-doc >= 1.9 (doc -- optional) http://www.gtk.org/gtk-doc/
povray (doc -- optional) http://www.povray.org/
asymptote (doc -- optional) http://asymptote.sourceforge.net/ hkl-5.0.0.2569/hkl/ 0000755 0001751 0001751 00000000000 13574157075 013714 5 ustar 00picca picca 0000000 0000000 hkl-5.0.0.2569/hkl/hkl-axis.c 0000644 0001751 0001751 00000034312 13574156433 015600 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for GSL_NAN
#include // for gsl_sf_angle_restrict_symm
#include // for gsl_isnan
#include // for M_PI, ceil, fabs, floor
#include // for FILE
#include // for NULL, free
#include "hkl-axis-private.h" // for HklAxis
#include "hkl-interval-private.h" // for HklInterval, etc
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-parameter-private.h" // for _HklParameter, etc
#include "hkl-quaternion-private.h" // for hkl_quaternion_fprintf, etc
#include "hkl-vector-private.h" // for hkl_vector_fprintf, etc
#include "hkl.h" // for HklParameter, TRUE, etc
#include "hkl/ccan/container_of/container_of.h" // for container_of
/***********/
/* HklAxis */
/***********/
static inline HklParameter *hkl_axis_copy_real(const HklParameter *base)
{
HklAxis *self = container_of(base, HklAxis, parameter);
HklAxis *dup;
dup = HKL_MALLOC(HklAxis);
*dup = *self;
return &dup->parameter;
}
static inline void hkl_axis_free_real(HklParameter *self)
{
free(container_of(self, HklAxis, parameter));
}
static inline void hkl_axis_update(HklAxis *self)
{
hkl_quaternion_init_from_angle_and_axe(&self->q,
self->parameter._value,
&self->axis_v);
}
static inline int hkl_axis_init_copy_real(HklParameter *self, const HklParameter *src,
GError **error)
{
HklAxis *axis_self = container_of(self, HklAxis, parameter);
HklAxis *axis_src = container_of(src, HklAxis, parameter);
hkl_error (error == NULL || *error == NULL);
*axis_self = *axis_src;
self->changed = TRUE;
return TRUE;
}
static inline int hkl_axis_set_value_real(HklParameter *self, double value,
HklUnitEnum unit_type, GError **error)
{
HklAxis *axis = container_of(self, HklAxis, parameter);
hkl_error (error == NULL || *error == NULL);
if(!hkl_parameter_value_set_real(self, value, unit_type, error)){
g_assert (error == NULL || *error != NULL);
return FALSE;
}
g_assert (error == NULL || *error == NULL);
hkl_axis_update(axis);
return TRUE;
}
static inline void hkl_axis_set_value_smallest_in_range_real(HklParameter *self)
{
double value, min;
value = self->_value;
min = self->range.min;
if(value < min)
hkl_axis_set_value_real(self,
value + 2*M_PI*ceil((min - value)/(2*M_PI)),
HKL_UNIT_DEFAULT,
NULL);
else
hkl_axis_set_value_real(self,
value - 2*M_PI*floor((value - min)/(2*M_PI)),
HKL_UNIT_DEFAULT,
NULL);
}
static inline void hkl_axis_randomize_real(HklParameter *self)
{
hkl_parameter_randomize_real(self);
hkl_axis_update(container_of(self, HklAxis, parameter));
}
/*
* given a current position of angle a min and max interval find the closest
* equivalent angle + n delta_angle in a given direction.
* CAUSION angle MUST be in [min, max] otherwise...
*/
static void find_angle(double current, double *angle, double *distance,
double min, double max, double delta_angle)
{
double new_angle = *angle;
double new_distance;
while(new_angle >= min && new_angle <= max) {
new_distance = fabs(new_angle - current);
if (new_distance <= *distance) {
*angle = new_angle;
*distance = new_distance;
}
new_angle += delta_angle;
}
}
static inline double hkl_axis_get_value_closest_real(const HklParameter *self,
const HklParameter *ref)
{
double angle = self->_value;
if(hkl_parameter_is_valid(self)){
if(hkl_interval_length(&self->range) >= 2*M_PI){
int k;
double current = ref->_value;
double distance = fabs(current - angle);
double delta = 2. * M_PI;
double min = self->range.min;
double max = self->range.max;
/* three cases */
if (angle > max) {
k = (int)(floor((max - angle) / delta));
angle += k * delta;
find_angle(current, &angle, &distance, min, max, -delta);
} else if (angle < min) {
k = (int) (ceil((min - angle) / delta));
angle += k * delta;
find_angle(current, &angle, &distance, min, max, delta);
} else {
find_angle(current, &angle, &distance, min, max, -delta);
find_angle(current, &angle, &distance, min, max, delta);
}
}
}else
angle = GSL_NAN;
return angle;
}
/*
* check if the angle or its equivalent is in between [min, max]
*/
static inline int hkl_axis_is_valid_real(const HklParameter *self)
{
double value = self->_value;
int res = FALSE;
HklInterval range = self->range;
if(hkl_interval_length(&range) > 2*M_PI)
res = TRUE;
else{
hkl_interval_angle_restrict_symm(&range);
value = gsl_sf_angle_restrict_symm(value);
if(range.min <= range.max){
if(range.min <= value && range.max >= value)
res = TRUE;
}else{
if(value <= range.max || value >= range.min)
res = TRUE;
}
}
return res;
}
static inline void hkl_axis_fprintf_real(FILE *f, const HklParameter *self)
{
HklAxis *axis = container_of(self, HklAxis, parameter);
hkl_parameter_fprintf_real(f, self);
hkl_vector_fprintf(f, &axis->axis_v);
hkl_quaternion_fprintf(f, &axis->q);
}
static inline const HklVector *hkl_axis_axis_v_get_real(const HklParameter *self)
{
return &container_of(self, HklAxis, parameter)->axis_v;
}
static inline const HklQuaternion *hkl_axis_quaternion_get_real(const HklParameter *self)
{
return &container_of(self, HklAxis, parameter)->q;
}
static inline int hkl_axis_transformation_cmp_real(const HklParameter *base, const HklParameter *p2)
{
const HklAxis *self = container_of(base, HklAxis, parameter);
const HklAxis *axis2 = container_of(p2, HklAxis, parameter);
return hkl_parameter_transformation_cmp_real(base, p2)
|| hkl_vector_cmp(&self->axis_v, &axis2->axis_v);
}
static inline HklVector hkl_axis_transformation_apply_real(const HklParameter *base,
const HklVector *v)
{
const HklAxis *self = container_of(base, HklAxis, parameter);
HklVector res = *v;
hkl_vector_rotated_quaternion(&res, &self->q);
return res;
}
#define HKL_PARAMETER_OPERATIONS_AXIS_DEFAULTS \
HKL_PARAMETER_OPERATIONS_DEFAULTS, \
.copy = hkl_axis_copy_real, \
.free = hkl_axis_free_real, \
.init_copy = hkl_axis_init_copy_real, \
.get_value_closest = hkl_axis_get_value_closest_real, \
.set_value = hkl_axis_set_value_real, \
.set_value_smallest_in_range = hkl_axis_set_value_smallest_in_range_real, \
.randomize = hkl_axis_randomize_real, \
.is_valid = hkl_axis_is_valid_real, \
.fprintf = hkl_axis_fprintf_real, \
.axis_v_get = hkl_axis_axis_v_get_real, \
.quaternion_get = hkl_axis_quaternion_get_real, \
.transformation_cmp = hkl_axis_transformation_cmp_real, \
.transformation_apply = hkl_axis_transformation_apply_real
static HklParameterOperations hkl_parameter_operations_axis = {
HKL_PARAMETER_OPERATIONS_AXIS_DEFAULTS,
};
HklParameter *hkl_parameter_new_rotation(const char *name, HklVector const *axis_v, const HklUnit *punit)
{
HklAxis axis0 = {
.parameter = { HKL_PARAMETER_DEFAULTS_ANGLE,
.name = name,
.punit = punit,
.ops = &hkl_parameter_operations_axis,
},
.axis_v = *axis_v,
.q = {{1., 0., 0., 0.}},
};
HklAxis *self = HKL_MALLOC(HklAxis);
*self = axis0;
return &self->parameter;
}
/*************************/
/* HklRotationWithOrigin */
/*************************/
static inline HklParameter *hkl_rotation_with_origin_copy_real(const HklParameter *base)
{
HklRotationWithOrigin *self = container_of(container_of(base, HklAxis, parameter),
HklRotationWithOrigin, axis);
HklRotationWithOrigin *dup;
dup = HKL_MALLOC(HklRotationWithOrigin);
*dup = *self;
return &dup->axis.parameter;
}
static inline void hkl_rotation_with_origin_free_real(HklParameter *base)
{
free(container_of(container_of(base, HklAxis, parameter),
HklRotationWithOrigin, axis));
}
static inline int hkl_rotation_with_origin_init_copy_real(HklParameter *base,
const HklParameter *base_src,
GError **error)
{
HklRotationWithOrigin *self = container_of(container_of(base, HklAxis, parameter),
HklRotationWithOrigin, axis);
HklRotationWithOrigin *src = container_of(container_of(base_src, HklAxis, parameter),
HklRotationWithOrigin, axis);
hkl_error (error == NULL || *error == NULL);
*self = *src;
base->changed = TRUE;
return TRUE;
}
static inline int hkl_rotation_with_origin_transformation_cmp_real(const HklParameter *base,
const HklParameter *base_p2)
{
HklRotationWithOrigin *self = container_of(container_of(base, HklAxis, parameter),
HklRotationWithOrigin, axis);
HklRotationWithOrigin *p2 = container_of(container_of(base_p2, HklAxis, parameter),
HklRotationWithOrigin, axis);
return hkl_axis_transformation_cmp_real(base, base_p2)
|| hkl_vector_cmp(&self->origin, &p2->origin);
}
static inline HklVector hkl_rotation_with_origin_transformation_apply_real(const HklParameter *base,
const HklVector *v)
{
const HklAxis *axis = container_of(base, HklAxis, parameter);
const HklRotationWithOrigin *self = container_of(axis, HklRotationWithOrigin, axis);
HklVector res = *v;
hkl_vector_minus_vector(&res, &self->origin);
hkl_vector_rotated_quaternion(&res, &axis->q);
hkl_vector_add_vector(&res, &self->origin);
return res;
}
#define HKL_PARAMETER_OPERATIONS_ROTATION_WITH_ORIGIN_DEFAULTS \
HKL_PARAMETER_OPERATIONS_AXIS_DEFAULTS, \
.copy = hkl_rotation_with_origin_copy_real, \
.free = hkl_rotation_with_origin_free_real, \
.init_copy = hkl_rotation_with_origin_init_copy_real, \
.transformation_cmp = hkl_rotation_with_origin_transformation_cmp_real, \
.transformation_apply = hkl_rotation_with_origin_transformation_apply_real
static HklParameterOperations hkl_parameter_operations_rotation_with_origin = {
HKL_PARAMETER_OPERATIONS_ROTATION_WITH_ORIGIN_DEFAULTS,
};
HklParameter *hkl_parameter_new_rotation_with_origin(const char *name,
HklVector const *axis_v,
HklVector const *origin,
const HklUnit *punit)
{
HklRotationWithOrigin rotation0 = {
.axis = {
.parameter = { HKL_PARAMETER_DEFAULTS_ANGLE,
.name = name,
.punit = punit,
.ops = &hkl_parameter_operations_rotation_with_origin,
},
.axis_v = *axis_v,
.q = {{1., 0., 0., 0.}},
},
.origin = *origin,
};
HklRotationWithOrigin *self = HKL_MALLOC(HklRotationWithOrigin);
*self = rotation0;
return &self->axis.parameter;
}
/**********************/
/* HklTranslation */
/**********************/
static inline HklParameter *hkl_translation_copy_real(const HklParameter *base)
{
HklTranslation *self = container_of(base, HklTranslation, parameter);
HklTranslation *dup;
dup = HKL_MALLOC(HklTranslation);
*dup = *self;
return &dup->parameter;
}
static inline void hkl_translation_free_real(HklParameter *base)
{
free(container_of(base, HklTranslation, parameter));
}
static inline int hkl_translation_init_copy_real(HklParameter *base,
const HklParameter *base_src,
GError **error)
{
HklTranslation *self = container_of(base, HklTranslation, parameter);
HklTranslation *src = container_of(base_src, HklTranslation, parameter);
/* need to check that parameters are compatibles */
hkl_error (error == NULL || *error == NULL);
*self = *src;
base->changed = TRUE;
return TRUE;
}
static inline void hkl_translation_fprintf_real(FILE *f, const HklParameter *base)
{
HklTranslation *self = container_of(base, HklTranslation, parameter);
hkl_parameter_fprintf_real(f, base);
hkl_vector_fprintf(f, &self->axis_v);
}
static inline const HklVector *hkl_translation_axis_v_get_real(const HklParameter *base)
{
return &container_of(base, HklTranslation, parameter)->axis_v;
}
static inline int hkl_translation_transformation_cmp_real(const HklParameter *base,
const HklParameter *p2)
{
const HklTranslation *self = container_of(base, HklTranslation, parameter);
const HklTranslation *translation2 = container_of(p2, HklTranslation, parameter);
return hkl_parameter_transformation_cmp_real(base, p2)
|| hkl_vector_cmp(&self->axis_v, &translation2->axis_v);
}
static inline HklVector hkl_translation_transformation_apply_real(const HklParameter *base,
const HklVector *v)
{
const HklTranslation *self = container_of(base, HklTranslation, parameter);
HklVector res = self->axis_v;
hkl_vector_times_double(&res, base->_value);
hkl_vector_add_vector(&res, v);
return res;
}
#define HKL_PARAMETER_OPERATIONS_TRANSLATION_DEFAULTS \
HKL_PARAMETER_OPERATIONS_DEFAULTS, \
.copy = hkl_translation_copy_real, \
.free = hkl_translation_free_real, \
.init_copy = hkl_translation_init_copy_real, \
.fprintf = hkl_translation_fprintf_real , \
.axis_v_get = hkl_translation_axis_v_get_real, \
.transformation_cmp = hkl_translation_transformation_cmp_real, \
.transformation_apply = hkl_translation_transformation_apply_real
static HklParameterOperations hkl_parameter_operations_translation =
{
HKL_PARAMETER_OPERATIONS_TRANSLATION_DEFAULTS,
};
HklParameter *hkl_parameter_new_translation(const char *name, HklVector const *axis_v, const HklUnit *punit)
{
HklTranslation translation0 = {
.parameter = { HKL_PARAMETER_DEFAULTS,
.name = name,
.unit = &hkl_unit_length_meter,
.punit = punit,
.ops = &hkl_parameter_operations_translation,
},
.axis_v = *axis_v,
};
HklTranslation *self = HKL_MALLOC(HklTranslation);
*self = translation0;
return &self->parameter;
}
hkl-5.0.0.2569/hkl/hkl-engine-e6c.c 0000644 0001751 0001751 00000027732 13447477011 016561 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for gsl_isnan
#include "hkl-factory-private.h" // for autodata_factories_, etc
#include "hkl-pseudoaxis-common-hkl-private.h" // for hkl_mode_operations, etc
#include "hkl-pseudoaxis-common-psi-private.h" // for hkl_engine_psi_new, etc
#include "hkl-pseudoaxis-common-q-private.h" // for hkl_engine_q2_new, etc
#include "hkl-pseudoaxis-common-tth-private.h" // for hkl_engine_tth2_new, etc
#include "hkl-pseudoaxis-common-readonly-private.h" // for hkl_engine_tth2_new, etc
#define MU "mu"
#define OMEGA "omega"
#define CHI "chi"
#define PHI "phi"
#define GAMMA "gamma"
#define DELTA "delta"
/***********************/
/* numerical functions */
/***********************/
static int _bissector_horizontal_func(const gsl_vector *x, void *params, gsl_vector *f)
{
const double mu = x->data[0];
const double omega = x->data[1];
const double gamma = x->data[4];
CHECK_NAN(x->data, x->size);
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
f->data[4] = gamma - 2 * fmod(mu, M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_horizontal_func = {
.function = _bissector_horizontal_func,
.size = 5,
};
static int _bissector_vertical_func(const gsl_vector *x, void *params, gsl_vector *f)
{
const double omega = x->data[0];
const double tth = x->data[3];
CHECK_NAN(x->data, x->size);
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = tth - 2 * fmod(omega,M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_vertical_func = {
.function = _bissector_vertical_func,
.size = 4,
};
/************/
/* mode hkl */
/************/
static HklMode *bissector_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, CHI, PHI, DELTA};
static const HklFunction *functions[] = {&bissector_vertical_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_omega_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {CHI, PHI, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_chi_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, PHI, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_phi_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, CHI, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_phi(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {PHI, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_omega(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_mu(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, CHI, PHI, DELTA};
static const HklFunction *functions[] = {&double_diffraction_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *bissector_horizontal(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, OMEGA, CHI, PHI, GAMMA};
static const HklFunction *functions[] = {&bissector_horizontal_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_horizontal(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, CHI, PHI, GAMMA};
static const HklFunction *functions[] = {&double_diffraction_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *psi_constant_vertical(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, CHI, PHI, DELTA};
static const HklFunction *functions[] = {&psi_constant_vertical_func};
static const HklParameter parameters[] = { PSI_CONSTANT_PARAMETERS(1, 0, 0, 0) };
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w, functions, parameters),
};
return hkl_mode_auto_new(&info,
&psi_constant_vertical_mode_operations,
TRUE);
}
static HklMode *psi_constant_horizontal(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {OMEGA, CHI, PHI, GAMMA};
static const HklFunction *functions[] = {&psi_constant_vertical_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, psi_constant_parameters),
};
return hkl_mode_auto_new(&info,
&psi_constant_vertical_mode_operations,
TRUE);
}
static HklMode *constant_mu_horizontal(void)
{
static const char* axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char* axes_w[] = {CHI, PHI, GAMMA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklEngine *hkl_engine_e6c_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = bissector_vertical();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, constant_omega_vertical());
hkl_engine_add_mode(self, constant_chi_vertical());
hkl_engine_add_mode(self, constant_phi_vertical());
hkl_engine_add_mode(self, lifting_detector_phi());
hkl_engine_add_mode(self, lifting_detector_omega());
hkl_engine_add_mode(self, lifting_detector_mu());
hkl_engine_add_mode(self, double_diffraction_vertical());
hkl_engine_add_mode(self, bissector_horizontal());
hkl_engine_add_mode(self, double_diffraction_horizontal());
hkl_engine_add_mode(self, psi_constant_vertical());
hkl_engine_add_mode(self, psi_constant_horizontal());
hkl_engine_add_mode(self, constant_mu_horizontal());
return self;
}
/************/
/* mode psi */
/************/
static HklMode* psi_vertical()
{
static const char *axes_r[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static const char *axes_w[] = {OMEGA, CHI, PHI, DELTA};
static const HklFunction *functions[] = {&psi_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, psi_parameters),
};
return hkl_mode_psi_new(&info);
}
static HklEngine *hkl_engine_e6c_psi_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_psi_new(engines);
default_mode = psi_vertical();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
return self;
}
/*****************/
/* mode readonly */
/*****************/
REGISTER_READONLY_INCIDENCE(hkl_engine_e6c_incidence_new,
P99_PROTECT({MU, OMEGA, CHI, PHI}),
surface_parameters_y);
REGISTER_READONLY_EMERGENCE(hkl_engine_e6c_emergence_new,
P99_PROTECT({MU, OMEGA, CHI, PHI, GAMMA, DELTA}),
surface_parameters_y);
/*******/
/* E6C */
/*******/
#define HKL_GEOMETRY_EULERIAN6C_DESCRIPTION \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 4 axes for the sample\n" \
"\n" \
" + **" MU "** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" OMEGA "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
" + **" CHI "** : rotating around the :math:`\\vec{x}` direction (1, 0, 0)\n" \
" + **" PHI "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
"\n" \
"+ 2 axes for the detector\n" \
"\n" \
" + **" GAMMA "** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" DELTA "** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
static const char* hkl_geometry_eulerian6C_axes[] = {MU, OMEGA, CHI, PHI, GAMMA, DELTA};
static HklGeometry *hkl_geometry_new_eulerian6C(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MU, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, OMEGA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, CHI, 1, 0, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, PHI, 0, -1, 0, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, GAMMA, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, DELTA, 0, -1, 0, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_eulerian6C(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_e6c_hkl_new(self);
hkl_engine_e6c_psi_new(self);
hkl_engine_q2_new(self);
hkl_engine_qper_qpar_new(self);
hkl_engine_tth2_new(self);
hkl_engine_e6c_incidence_new(self);
hkl_engine_e6c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(eulerian6C, "E6C", HKL_GEOMETRY_EULERIAN6C_DESCRIPTION);
hkl-5.0.0.2569/hkl/hkl-engine-e4c.c 0000644 0001751 0001751 00000024527 13447477011 016556 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for gsl_isnan
#include "hkl-factory-private.h" // for autodata_factories_, etc
#include "hkl-pseudoaxis-common-q-private.h" // for hkl_engine_q2_new, etc
#include "hkl-pseudoaxis-common-hkl-private.h" // for hkl_mode_operations, etc
#include "hkl-pseudoaxis-common-psi-private.h" // for hkl_engine_psi_new, etc
#include "hkl-pseudoaxis-common-readonly-private.h"
#define OMEGA "omega"
#define CHI "chi"
#define PHI "phi"
#define TTH "tth"
/************/
/* mode hkl */
/************/
static int _bissector_func(const gsl_vector *x, void *params, gsl_vector *f)
{
const double omega = x->data[0];
const double tth = x->data[3];
CHECK_NAN(x->data, x->size);
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = tth - 2 * fmod(omega,M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_func = {
.function = _bissector_func,
.size = 4,
};
static HklMode *bissector(void)
{
static const char* axes[] = {OMEGA, CHI, PHI, TTH};
static const HklFunction *functions[] = {&bissector_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes, axes, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklMode *constant_omega(void)
{
static const char* axes_r[] = {OMEGA, CHI, PHI, TTH};
static const char* axes_w[] = {CHI, PHI, TTH};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklMode *constant_chi(void)
{
static const char* axes_r[] = {OMEGA, CHI, PHI, TTH};
static const char* axes_w[] = {OMEGA, PHI, TTH};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklMode *constant_phi(void)
{
static const char* axes_r[] = {OMEGA, CHI, PHI, TTH};
static const char* axes_w[] = {OMEGA, CHI, TTH};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklMode *double_diffraction(void)
{
static const char* axes[] = {OMEGA, CHI, PHI, TTH};
static const HklFunction *functions[] = {&double_diffraction_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes, axes,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
static HklMode *psi_constant(void)
{
static const char* axes[] = {OMEGA, CHI, PHI, TTH};
static const HklFunction *functions[] = {&psi_constant_vertical_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes, axes,
functions, psi_constant_parameters),
};
return hkl_mode_auto_new(&info,
&psi_constant_vertical_mode_operations,
TRUE);
}
static HklEngine *hkl_engine_e4c_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = bissector();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, constant_omega());
hkl_engine_add_mode(self, constant_chi());
hkl_engine_add_mode(self, constant_phi());
hkl_engine_add_mode(self, double_diffraction());
hkl_engine_add_mode(self, psi_constant());
return self;
}
/************/
/* mode psi */
/************/
static HklMode *psi(void)
{
static const char *axes[] = {OMEGA, CHI, PHI, TTH};
static const HklFunction *functions[] = {&psi_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes, axes,
functions, psi_parameters),
};
return hkl_mode_psi_new(&info);
}
static HklEngine *hkl_engine_e4c_psi_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_psi_new(engines);
default_mode = psi();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
return self;
}
/*****************/
/* mode readonly */
/*****************/
REGISTER_READONLY_INCIDENCE(hkl_engine_e4c_incidence_new,
P99_PROTECT({OMEGA, CHI, PHI}),
surface_parameters_y);
REGISTER_READONLY_EMERGENCE(hkl_engine_e4c_emergence_new,
P99_PROTECT({OMEGA, CHI, PHI, TTH}),
surface_parameters_y);
/********/
/* E4CV */
/********/
#define HKL_GEOMETRY_EULERIAN4C_VERTICAL_DESCRIPTION \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 3 axes for the sample\n" \
"\n" \
" + **" OMEGA "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
" + **" CHI "** : rotating around the :math:`\\vec{x}` direction (1, 0, 0)\n" \
" + **" PHI "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
"\n" \
"+ 1 axis for the detector\n" \
"\n" \
" + **" TTH "** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
static const char* hkl_geometry_eulerian4C_vertical_axes[] = {OMEGA, CHI, PHI, TTH};
static HklGeometry *hkl_geometry_new_eulerian4C_vertical(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, OMEGA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, CHI, 1, 0, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, PHI, 0, -1, 0, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, TTH, 0, -1, 0, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_eulerian4C_vertical(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_e4c_hkl_new(self);
hkl_engine_e4c_psi_new(self);
hkl_engine_q_new(self);
hkl_engine_e4c_incidence_new(self);
hkl_engine_e4c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(eulerian4C_vertical, "E4CV", HKL_GEOMETRY_EULERIAN4C_VERTICAL_DESCRIPTION);
/***************/
/* SOLEIL MARS */
/***************/
#define HKL_GEOMETRY_TYPE_SOLEIL_MARS_DESCRIPTION \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 3 axes for the sample\n" \
"\n" \
" + **" OMEGA "** : rotating around the :math:`\\vec{z}` direction (0, -1, 0)\n" \
" + **" CHI "** : rotating around the :math:`\\vec{x}` direction (-1, 0, 0)\n" \
" + **" PHI "** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
"\n" \
"+ 1 axis for the detector\n" \
"\n" \
" + **" TTH "** : rotation around the :math:`\\vec{z}` direction (0, -1, 0)\n"
static const char* hkl_geometry_soleil_mars_axes[] = {OMEGA, CHI, PHI, TTH};
static HklGeometry *hkl_geometry_new_soleil_mars(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, OMEGA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, CHI, -1, 0, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, PHI, 0, 0, 1, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, TTH, 0, -1, 0, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_soleil_mars(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_e4c_hkl_new(self);
hkl_engine_e4c_psi_new(self);
hkl_engine_q_new(self);
hkl_engine_e4c_incidence_new(self);
hkl_engine_e4c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(soleil_mars, "SOLEIL MARS", HKL_GEOMETRY_TYPE_SOLEIL_MARS_DESCRIPTION);
/********/
/* E4CH */
/********/
#define HKL_GEOMETRY_TYPE_EULERIAN4C_HORIZONTAL_DESCRIPTION \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 3 axes for the sample\n" \
"\n" \
" + **" OMEGA "** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" CHI "** : rotating around the :math:`\\vec{x}` direction (1, 0, 0)\n" \
" + **" PHI "** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
"\n" \
"+ 1 axis for the detector\n" \
"\n" \
" + **" TTH "** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n"
static const char* hkl_geometry_eulerian4C_horizontal_axes[] = {OMEGA, CHI, PHI, TTH};
static HklGeometry *hkl_geometry_new_eulerian4C_horizontal(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, OMEGA, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, CHI, 1, 0, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, PHI, 0, 0, 1, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, TTH, 0, 0, 1, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_eulerian4C_horizontal(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_e4c_hkl_new(self);
hkl_engine_e4c_psi_new(self);
hkl_engine_q_new(self);
hkl_engine_e4c_incidence_new(self);
hkl_engine_e4c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(eulerian4C_horizontal, "E4CH", HKL_GEOMETRY_TYPE_EULERIAN4C_HORIZONTAL_DESCRIPTION);
hkl-5.0.0.2569/hkl/hkl-interval.c 0000644 0001751 0001751 00000024243 13447477011 016457 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#define _GNU_SOURCE
#include
#include // for floor, M_PI_2, acos, asin, etc
#include // for free, NULL
#include "hkl-interval-private.h" // for HklInterval
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl.h" // for FALSE, TRUE
/**
* hkl_interval_dup: (skip)
* @self:
*
* copy an #HklInterval
*
* Returns:
**/
HklInterval *hkl_interval_dup(const HklInterval *self)
{
if(!self)
return NULL;
HklInterval *dup = HKL_MALLOC(HklInterval);
*dup = *self;
return dup;
}
/**
* hkl_interval_free: (skip)
* @self:
*
* delete an #HklInterval
**/
void hkl_interval_free(HklInterval *self)
{
if(self)
free(self);
}
/**
* hkl_interval_cmp: (skip)
* @self:
* @interval:
*
* compare two intervals
*
* Returns:
**/
int hkl_interval_cmp(const HklInterval *self, const HklInterval *interval)
{
return (fabs(self->min - interval->min) > HKL_EPSILON)
|| (fabs(self->max - interval->max) > HKL_EPSILON);
}
/**
* hkl_interval_plus_interval: (skip)
* @self:
* @interval:
*
* add two ontervals
**/
void hkl_interval_plus_interval(HklInterval *self, const HklInterval *interval)
{
self->min += interval->min;
self->max += interval->max;
}
/**
* hkl_interval_plus_double: (skip)
* @self:
* @d:
*
* add to an interval a double
**/
void hkl_interval_plus_double(HklInterval *self, double const d)
{
self->min += d;
self->max += d;
}
/**
* hkl_interval_minus_interval: (skip)
* @self:
* @interval:
*
* substract two #HklInterval
**/
void hkl_interval_minus_interval(HklInterval *self, const HklInterval *interval)
{
self->min -= interval->max;
self->max -= interval->min;
}
/**
* hkl_interval_minus_double: (skip)
* @self:
* @d:
*
* subst a double to an #HklInterval
**/
void hkl_interval_minus_double(HklInterval *self, double const d)
{
self->min -= d;
self->max -= d;
}
/**
* hkl_interval_times_interval: (skip)
* @self:
* @interval:
*
* multiply two #HklInterval
**/
void hkl_interval_times_interval(HklInterval *self, const HklInterval *interval)
{
double min;
double max;
double m1 = self->min * interval->min;
double m2 = self->min * interval->max;
double m3 = self->max * interval->min;
double m4 = self->max * interval->max;
min = m1;
if (m2 < min)
min = m2;
if (m3 < min)
min = m3;
if (m4 < min)
min = m4;
max = m1;
if (m2 > max)
max = m2;
if (m3 > max)
max = m3;
if (m4 > max)
max = m4;
self->min = min;
self->max = max;
}
/**
* hkl_interval_times_double: (skip)
* @self:
* @d:
*
* multiply an #HklInterval by a double
**/
void hkl_interval_times_double(HklInterval *self, double const d)
{
double min;
double max;
if (d < 0) {
min = self->max * d;
max = self->min * d;
} else {
min = self->min * d;
max = self->max * d;
}
self->min = min;
self->max = max;
}
/**
* hkl_interval_divides_double: (skip)
* @self:
* @d:
*
* divide an #HklInterval by a double
**/
void hkl_interval_divides_double(HklInterval *self, double const d)
{
double min = self->min / d;
double max = self->max / d;
if (min > max){
double tmp = min;
min = max;
max = tmp;
}
self->min = min;
self->max = max;
}
/**
* hkl_interval_contain_zero: (skip)
* @self:
*
* check if an #HklInterval contain zero
*
* Returns:
**/
int hkl_interval_contain_zero(HklInterval const *self)
{
if (self->min <= 0 && self->max >= 0)
return TRUE;
else
return FALSE;
}
/**
* hkl_interval_cos: (skip)
* @self:
*
* compute the cosinus of an #HklInterval
**/
void hkl_interval_cos(HklInterval *self)
{
double min = 0;
double max = 0;
double cmin;
double cmax;
cmin = cos(self->min);
cmax = cos(self->max);
if (self->max - self->min >= 2 * M_PI) {
min = -1;
max = 1;
} else {
int quad_min;
int quad_max;
quad_min = (int)floor(self->min / M_PI_2) % 4;
if (quad_min < 0)
quad_min += 4;
quad_max = (int)floor(self->max / M_PI_2) % 4;
if (quad_max < 0)
quad_max += 4;
switch (quad_max) {
case 0:
switch (quad_min) {
case 0:
min = cmax;
max = cmin;
break;
case 1:
min = -1;
max = 1;
break;
case 2:
min = cmin;
max = 1;
break;
case 3:
if (cmin < cmax) {
min = cmin;
max = 1;
} else {
min = cmax;
max = 1;
}
break;
}
break;
case 1:
switch (quad_min) {
case 0:
min = cmax;
max = cmin;
break;
case 1:
min = -1;
max = 1;
break;
case 2:
if (cmin < cmax) {
min = cmin;
max = 1;
} else {
min = cmax;
max = 1;
}
break;
case 3:
min = cmax;
max = 1;
break;
}
break;
case 2:
switch (quad_min) {
case 0:
min = -1;
max = cmin;
break;
case 1:
if (cmin < cmax) {
min = -1;
max = cmax;
} else {
min = -1;
max = cmin;
}
break;
case 2:
if (cmin < cmax) {
min = cmin;
max = cmax;
} else {
min = -1;
max = 1;
}
break;
case 3:
min = -1;
max = 1;
break;
}
break;
case 3:
switch (quad_min) {
case 0:
if (cmin < cmax) {
min = -1;
max = cmax;
} else {
min = -1;
max = cmin;
}
break;
case 1:
min = -1;
max = cmax;
break;
case 2:
min = cmin;
max = cmax;
break;
case 3:
if (cmin < cmax) {
min = cmin;
max = cmax;
} else {
min = -1;
max = 1;
}
break;
}
break;
}
}
self->min = min;
self->max = max;
}
/**
* hkl_interval_acos: (skip)
* @self:
*
* compute the arc cosinus of an #HklInterval
**/
void hkl_interval_acos(HklInterval *self)
{
double tmp;
tmp = self->min;
self->min = acos(self->max);
self->max = acos(tmp);
}
/**
* hkl_interval_sin: (skip)
* @self:
*
* compute the sin of an #HklInterval
**/
void hkl_interval_sin(HklInterval *self)
{
double min = 0;
double max = 0;
double smin;
double smax;
smin = sin(self->min);
smax = sin(self->max);
/* if there is at least one period in b, then a = [-1, 1] */
if ( self->max - self->min >= 2 * M_PI) {
min = -1;
max = 1;
} else {
int quad_min;
int quad_max;
quad_min = (int)floor(self->min / M_PI_2) % 4;
if (quad_min < 0)
quad_min += 4;
quad_max = (int)floor(self->max / M_PI_2) % 4;
if (quad_max < 0)
quad_max += 4;
switch (quad_max) {
case 0:
switch (quad_min) {
case 0:
if (smin < smax) {
min = smin;
max = smax;
} else {
min = -1;
max = 1;
}
break;
case 3:
min = smin;
max = smax;
break;
case 1:
if (smin > smax) {
min = -1;
max = smin;
} else {
min = -1;
max = smax;
}
break;
case 2:
min = -1;
max = smax;
break;
}
break;
case 1:
switch (quad_min) {
case 0:
if (smin < smax) {
min = smin;
max = 1;
} else {
min = smax;
max = 1;
}
break;
case 1:
if (smin < smax) {
min = -1;
max = 1;
} else {
min = smax;
max = smin;
}
break;
case 2:
min = -1;
max = 1;
break;
case 3:
min = smin;
max = 1;
break;
}
break;
case 2:
switch (quad_min) {
case 0:
min = smax;
max = 1;
break;
case 1:
case 2:
if (smin < smax) {
min = -1;
max = 1;
} else {
min = smax;
max = smin;
}
break;
case 3:
if (smin < smax) {
min = smin;
max = 1;
} else {
min = smax;
max = 1;
}
break;
}
break;
case 3:
switch (quad_min) {
case 0:
min = -1;
max = 1;
break;
case 1:
min = -1;
max = smin;
break;
case 2:
if (smin < smax) {
min = -1;
max = smax;
} else {
min = -1;
max = smin;
}
break;
case 3:
if (smin < smax) {
min = smin;
max = smax;
} else {
min = -1;
max = 1;
}
break;
}
break;
}
}
self->min = min;
self->max = max;
}
/**
* hkl_interval_asin: (skip)
* @self:
*
* compute the arc sinus of an #HklInterval
**/
void hkl_interval_asin(HklInterval *self)
{
self->min = asin(self->min);
self->max = asin(self->max);
}
/**
* hkl_interval_tan: (skip)
* @self:
*
* compute the tangente of an #HklInterval
**/
void hkl_interval_tan(HklInterval *self)
{
int quadrant_down = (int)floor(self->min / M_PI_2);
int quadrant_up = (int)floor(self->max / M_PI_2);
/* if there is at least one period in b or if b contains a Pi/2 + k*Pi, */
/* then a = ]-oo, +oo[ */
if ( ((quadrant_up - quadrant_down) >= 2)
|| (!(quadrant_down % 2) && (quadrant_up % 2)) ) {
self->min = -INFINITY;
self->max = INFINITY;
} else {
self->min = tan(self->min);
self->max = tan(self->max);
}
}
/**
* hkl_interval_atan: (skip)
* @self:
*
* compute the arc tangente of an #HklInterval
**/
void hkl_interval_atan(HklInterval *self)
{
self->min = atan(self->min);
self->max = atan(self->max);
}
/**
* hkl_interval_length: (skip)
* @self:
*
* compute the length of an #HklInterval
*
* Returns:
**/
double hkl_interval_length(const HklInterval *self)
{
return self->max - self->min;
}
/**
* hkl_interval_angle_restrict_symm: (skip)
* @self:
*
* restrict an #HklInterval into -pi, pi
**/
void hkl_interval_angle_restrict_symm(HklInterval *self)
{
gsl_sf_angle_restrict_symm_e(&self->min);
gsl_sf_angle_restrict_symm_e(&self->max);
}
hkl-5.0.0.2569/hkl/hkl-pseudoaxis-common-eulerians.c 0000644 0001751 0001751 00000020025 13447477011 022264 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
* Jens Krüger
*/
#include // for gsl_sf_angle_restrict_symm
#include // for sin, asin, M_PI_2, tan, etc
#include // for free
#include // for uint
#include "hkl-geometry-private.h"
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-parameter-private.h" // for _HklParameter, etc
#include "hkl-pseudoaxis-common-eulerians-private.h"
#include "hkl-pseudoaxis-private.h" // for _HklPseudoAxis, etc
#include "hkl.h" // for HklParameter, HklPseudoAxis, etc
#include "hkl/ccan/array_size/array_size.h" // for ARRAY_SIZE
#include "hkl/ccan/container_of/container_of.h" // for container_of
#include "hkl/ccan/darray/darray.h" // for darray_item
typedef struct _HklModeEulerians HklModeEulerians;
typedef struct _HklEngineEulerians HklEngineEulerians;
struct _HklModeEulerians
{
HklMode parent;
HklParameter *solutions;
};
struct _HklEngineEulerians
{
HklEngine engine;
HklParameter *omega;
HklParameter *chi;
HklParameter *phi;
};
#define HKL_MODE_EULERIANS_ERROR hkl_mode_eulerians_error_quark ()
static GQuark hkl_mode_eulerians_error_quark (void)
{
return g_quark_from_static_string ("hkl-mode-eulerians-error-quark");
}
typedef enum {
HKL_MODE_EULERIANS_ERROR_SET, /* can not set the engine */
} HklModeEuleriansError;
static int kappa_to_eulerian(const double angles[],
double *omega, double *chi, double *phi,
double alpha, int solution)
{
const double komega = angles[0];
const double kappa = gsl_sf_angle_restrict_symm(angles[1]);
const double kphi = angles[2];
const double p = atan(tan(kappa/2.) * cos(alpha));
if (solution){
*omega = komega + p - M_PI_2;
*chi = 2 * asin(sin(kappa/2.) * sin(alpha));
*phi = kphi + p + M_PI_2;
}else{
*omega = komega + p + M_PI_2;
*chi = -2 * asin(sin(kappa/2.) * sin(alpha));
*phi = kphi + p - M_PI_2;
}
return TRUE;
}
static int eulerian_to_kappa(const double omega, const double chi, const double phi,
double angles[],
double alpha, double solution)
{
int status = TRUE;
double *komega = &angles[0];
double *kappa = &angles[1];
double *kphi = &angles[2];
if (fabs(chi) <= alpha * 2){
const double p = asin(tan(chi/2.)/tan(alpha));
if (solution){
*komega = omega - p + M_PI_2;
*kappa = 2 * asin(sin(chi/2.)/sin(alpha));
*kphi = phi - p - M_PI_2;
}else{
*komega = omega + p - M_PI_2;
*kappa = -2 * asin(sin(chi/2.)/sin(alpha));
*kphi = phi + p + M_PI_2;
}
}else
status = FALSE;
return status;
}
void kappa_2_kappap(double komega, double kappa, double kphi, double alpha,
double *komegap, double *kappap, double *kphip)
{
double p = atan(tan(kappa/2.) * cos(alpha));
double omega = komega + p - M_PI_2;
double phi = kphi + p + M_PI_2;
*komegap = gsl_sf_angle_restrict_symm(2*omega - komega);
*kappap = -kappa;
*kphip = gsl_sf_angle_restrict_symm(2*phi - kphi);
}
/***********/
/* HklMode */
/***********/
static int hkl_mode_get_eulerians_real(HklMode *base,
HklEngine *engine,
HklGeometry *geometry,
HklDetector *detector,
HklSample *sample,
GError **error)
{
HklModeEulerians *self = container_of(base, HklModeEulerians, parent);
HklEngineEulerians *eulerians = container_of(engine, HklEngineEulerians, engine);;
const double angles[] = {
hkl_parameter_value_get(
hkl_geometry_get_axis_by_name(geometry, "komega"),
HKL_UNIT_DEFAULT),
hkl_parameter_value_get(
hkl_geometry_get_axis_by_name(geometry, "kappa"),
HKL_UNIT_DEFAULT),
hkl_parameter_value_get(
hkl_geometry_get_axis_by_name(geometry, "kphi"),
HKL_UNIT_DEFAULT),
};
hkl_geometry_update(geometry);
kappa_to_eulerian(angles,
&eulerians->omega->_value,
&eulerians->chi->_value,
&eulerians->phi->_value,
50 * HKL_DEGTORAD, self->solutions->_value);
return TRUE;
}
static int hkl_mode_set_eulerians_real(HklMode *base,
HklEngine *engine,
HklGeometry *geometry,
HklDetector *detector,
HklSample *sample,
GError **error)
{
HklModeEulerians *self = container_of(base, HklModeEulerians, parent);
HklEngineEulerians *eulerians = container_of(engine, HklEngineEulerians, engine);;
double angles[3];
if(!eulerian_to_kappa(eulerians->omega->_value,
eulerians->chi->_value,
eulerians->phi->_value,
angles, 50 * HKL_DEGTORAD,
self->solutions->_value)){
g_set_error(error,
HKL_MODE_EULERIANS_ERROR,
HKL_MODE_EULERIANS_ERROR_SET,
"unreachable solution : 0° < chi < 50°");
return FALSE;
}else
hkl_engine_add_geometry(engine, angles);
return TRUE;
}
static HklMode *mode_eulerians()
{
static const char *axes[] = {"komega", "kappa", "kphi"};
static const HklParameter parameters[] = {
{ HKL_PARAMETER_DEFAULTS,.name = "solutions", ._value = 1,
.description = "(0/1) to select the first or second solution",
.range = { .max = 1 },
},
};
static const HklModeInfo info = {
HKL_MODE_INFO_WITH_PARAMS("eulerians", axes, axes, parameters),
};
static const HklModeOperations operations = {
HKL_MODE_OPERATIONS_DEFAULTS,
.get = hkl_mode_get_eulerians_real,
.set = hkl_mode_set_eulerians_real,
};
HklModeEulerians *self = HKL_MALLOC(HklModeEulerians);
/* the base constructor; */
hkl_mode_init(&self->parent,
&info,
&operations, TRUE);
self->solutions = register_mode_parameter(&self->parent, 0);
return &self->parent;
};
/*************/
/* HklEngine */
/*************/
static void hkl_engine_eulerians_free_real(HklEngine *base)
{
HklEngineEulerians *self;
self = container_of(base, HklEngineEulerians, engine);
hkl_engine_release(&self->engine);
free(self);
}
HklEngine *hkl_engine_eulerians_new(HklEngineList *engines)
{
HklEngineEulerians *self;
HklMode *mode;
static const HklParameter omega = {
HKL_PARAMETER_DEFAULTS_ANGLE, .name = "omega",
.description = "omega equivalent for a four circle eulerian geometry",
};
static const HklParameter chi = {
HKL_PARAMETER_DEFAULTS_ANGLE, .name = "chi",
.description = "chi equivalent for a four circle eulerian geometry",
};
static const HklParameter phi = {
HKL_PARAMETER_DEFAULTS_ANGLE, .name = "phi",
.description = "phi equivalent for a four circle eulerian geometry",
};
static const HklParameter *pseudo_axes[] = {&omega, &chi, &phi};
static HklEngineInfo info = {
HKL_ENGINE_INFO("eulerians",
pseudo_axes,
HKL_ENGINE_DEPENDENCIES_AXES),
};
static HklEngineOperations operations = {
HKL_ENGINE_OPERATIONS_DEFAULTS,
.free=hkl_engine_eulerians_free_real,
};
self = HKL_MALLOC(HklEngineEulerians);
hkl_engine_init(&self->engine, &info, &operations, engines);
/* add the pseudo axes with the new API */
self->omega = register_pseudo_axis(&self->engine, engines, &omega);
self->chi = register_pseudo_axis(&self->engine, engines, &chi);
self->phi = register_pseudo_axis(&self->engine, engines, &phi);
/* eulerians [default] */
mode = mode_eulerians();
hkl_engine_add_mode(&self->engine, mode);
hkl_engine_mode_set(&self->engine, mode);
return &self->engine;
}
hkl-5.0.0.2569/hkl/hkl-pseudoaxis-auto-private.h 0000644 0001751 0001751 00000012442 13447477011 021440 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#ifndef __HKL_PSEUDOAXIS_AUTO_H__
#define __HKL_PSEUDOAXIS_AUTO_H__
#include // for gsl_vector
#include // for NULL
#include // for uint
#include "hkl-detector-private.h" // for hkl_detector_new_copy
#include "hkl-geometry-private.h" // for hkl_geometry_new_copy
#include "hkl-macros-private.h" // for hkl_assert, etc
#include "hkl-pseudoaxis-private.h" // for HklModeOperations, etc
#include "hkl.h" // for HklMode, hkl_detector_free, etc
#include "hkl/ccan/container_of/container_of.h" // for container_of
#include "hkl/ccan/array_size/array_size.h" // ARRAY_SIZE
G_BEGIN_DECLS
typedef struct _HklFunction HklFunction;
typedef struct _HklModeAutoInfo HklModeAutoInfo;
typedef struct _HklModeAutoWithInit HklModeAutoWithInit;
/***************/
/* HklModeAuto */
/***************/
struct _HklFunction
{
const uint size;
int (* function) (const gsl_vector *x, void *params, gsl_vector *f);
};
typedef darray(const HklFunction*) darray_function;
struct _HklModeAutoInfo {
const HklModeInfo info;
darray_function functions;
};
#define HKL_MODE_OPERATIONS_AUTO_DEFAULTS \
HKL_MODE_OPERATIONS_DEFAULTS, \
.set = hkl_mode_auto_set_real
#define CHECK_NAN(x, len) do{ \
for(uint i=0; igeometry)
hkl_geometry_free(self->geometry);
if(self->detector)
hkl_detector_free(self->detector);
if(self->sample)
hkl_sample_free(self->sample);
hkl_mode_free_real(mode);
}
static NEEDED int hkl_mode_auto_with_init_initialized_set_real(HklMode *mode,
HklEngine *engine,
HklGeometry *geometry,
HklDetector *detector,
HklSample *sample,
int initialized,
GError **error)
{
HklModeAutoWithInit *self = container_of(mode, HklModeAutoWithInit, mode);
hkl_error(error == NULL || *error == NULL);
if(initialized){
if(geometry){
if(self->geometry)
hkl_geometry_free(self->geometry);
self->geometry = hkl_geometry_new_copy(geometry);
}
if(detector){
if(self->detector)
hkl_detector_free(self->detector);
self->detector = hkl_detector_new_copy(detector);
}
if(sample){
if(self->sample)
hkl_sample_free(self->sample);
self->sample = hkl_sample_new_copy(sample);
}
}
mode->initialized = initialized;
return TRUE;
}
extern HklMode *hkl_mode_auto_with_init_new(const HklModeAutoInfo *info,
const HklModeOperations *ops,
int initialized);
G_END_DECLS
#endif /* __HKL_PSEUDOAXIS_AUTO_H__ */
hkl-5.0.0.2569/hkl/hkl-vector.c 0000644 0001751 0001751 00000037436 13447477011 016145 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for fabs, acos, cos, sin, sqrt, etc
#include // for fprintf, FILE
#include // for rand, RAND_MAX, free
#include // for memcpy
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-matrix-private.h" // for _HklMatrix
#include "hkl-quaternion-private.h" // for _HklQuaternion
#include "hkl-vector-private.h" // for HklVector, HklQuaternion
#include "hkl.h" // for HklMatrix, HKL_EPSILON, etc
/**
* hkl_vector_dup: (skip)
* @self: the HklVector to copy
*
* Copy an HklVector
*
* Returns: A copy of self which need to be free using hkl_vector_free
**/
HklVector* hkl_vector_dup (const HklVector* self) {
HklVector* dup;
dup = HKL_MALLOC(HklVector);
memcpy(dup, self, sizeof (HklVector));
return dup;
}
/**
* hkl_vector_free: (skip)
* @self:
*
* delete an HklVector struct
**/
void hkl_vector_free (HklVector* self) {
free(self);
}
/**
* hkl_vector_init:
* @self: the #HklVector to initialize.
* @x: the first coordinate value
* @y: the second coordinate value
* @z: the third coordinate value
*
* initialize an #HklVector
**/
void hkl_vector_init(HklVector *self, double x, double y, double z)
{
self->data[0] = x;
self->data[1] = y;
self->data[2] = z;
}
/**
* hkl_vector_fprintf: (skip)
* @file: the stream to print into
* @self: the #HklVector to print.
*
* print an #HklVector into a stream
**/
void hkl_vector_fprintf(FILE *file, const HklVector *self)
{
fprintf(file, "|%f, %f, %f|", self->data[0], self->data[1], self->data[2]);
}
/**
* hkl_vector_cmp: (skip)
* @self: the first vector
* @vector: th vector to compare with
*
* compare two #HklVector. this comparison use HKL_EPSILON
* to do the comparison.
*
* Returns: FALSE if both are equals, TRUE otherwise.
**/
int hkl_vector_cmp(const HklVector *self, const HklVector *vector)
{
unsigned int i;
for (i=0; i<3; i++)
if ( fabs(self->data[i] - vector->data[i]) > HKL_EPSILON )
return TRUE;
return FALSE;
}
/**
* hkl_vector_is_opposite: (skip)
* @self:
* @vector:
*
* Check if two vectors are oposite.
*
* Returns: TRUE is vector are oposite vectors.
**/
int hkl_vector_is_opposite(const HklVector *self, const HklVector *vector)
{
unsigned int i;
for (i=0; i<3; i++)
if ( fabs(self->data[i] + vector->data[i]) > HKL_EPSILON )
return FALSE;
return TRUE;
}
/**
* hkl_vector_add_vector: (skip)
* @self: the modified #HklVector
* @vector: the #hklvector to add
*
* add an #HklVector to another one.
**/
void hkl_vector_add_vector(HklVector *self, const HklVector *vector)
{
unsigned int i;
for (i=0;i<3;i++)
self->data[i] += vector->data[i];
}
/**
* hkl_vector_minus_vector: (skip)
* @self: the modified #HklVector
* @vector: the #hklvector to substract
*
* substract an #HklVector to another one.
**/
void hkl_vector_minus_vector(HklVector *self, const HklVector *vector)
{
unsigned int i;
for (i=0;i<3;i++)
self->data[i] -= vector->data[i];
}
/**
* hkl_vector_div_double: (skip)
* @self: the #HklVector to divide.
* @d: constant use to divide the #HklVector
*
* divide an #HklVector by constant.
**/
void hkl_vector_div_double(HklVector *self, const double d)
{
unsigned int i;
for (i=0;i<3;i++)
self->data[i] /= d;
}
/**
* hkl_vector_times_double: (skip)
* @self: the #HklVector to modify
* @d: the multiply factor
*
* multiply an #HklVector by a constant value.
**/
void hkl_vector_times_double(HklVector *self, const double d)
{
unsigned int i;
for (i=0;i<3;i++)
self->data[i] *= d;
}
/**
* hkl_vector_times_vector: (skip)
* @self: the #HklVector to modify
* @vector: the #HklVector use to modify the first one
*
* multiply an #HklVector by another one. This method multiply
* coordinate by coordinate.
**/
void hkl_vector_times_vector(HklVector *self, const HklVector *vector)
{
unsigned int i;
for (i=0;i<3;i++)
self->data[i] *= vector->data[i];
}
/**
* hkl_vector_times_matrix: (skip)
* @self: the #HklVector to multiply
* @m: the #HklMatrix use to multiply the #HklVector
*
* multiply an #HklVector by an #HklMatrix.
* compute v'= M . v
**/
void hkl_vector_times_matrix(HklVector *self, const HklMatrix *m)
{
HklVector tmp;
tmp = *self;
self->data[0] = tmp.data[0] *m->data[0][0] + tmp.data[1] *m->data[1][0] + tmp.data[2] *m->data[2][0];
self->data[1] = tmp.data[0] *m->data[0][1] + tmp.data[1] *m->data[1][1] + tmp.data[2] *m->data[2][1];
self->data[2] = tmp.data[0] *m->data[0][2] + tmp.data[1] *m->data[1][2] + tmp.data[2] *m->data[2][2];
}
/**
* hkl_vector_sum: (skip)
* @self: the #HklVector to sum.
*
* compute the #HklVector sum of all its elements.
*
* Returns: the sum of all elements.
**/
double hkl_vector_sum(const HklVector *self)
{
return self->data[0] + self->data[1] + self->data[2];
}
/**
* hkl_vector_scalar_product: (skip)
* @self: the first #HklVector
* @vector: the second #HklVector
*
* compute the scalar product of two #HklVector
*
* Returns: the scalar product.
**/
double hkl_vector_scalar_product(const HklVector *self, const HklVector *vector)
{
unsigned int i;
double scalar = 0;
for (i=0;i<3;i++)
scalar += self->data[i] *vector->data[i];
return scalar;
}
/**
* hkl_vector_vectorial_product: (skip)
* @self: the first #HklVector (modify)
* @vector: the second #HklVector
*
* compute the vectorial product of two vectors
**/
void hkl_vector_vectorial_product(HklVector *self, const HklVector *vector)
{
HklVector tmp;
tmp = *self;
self->data[0] = tmp.data[1] * vector->data[2] - tmp.data[2] * vector->data[1];
self->data[1] = tmp.data[2] * vector->data[0] - tmp.data[0] * vector->data[2];
self->data[2] = tmp.data[0] * vector->data[1] - tmp.data[1] * vector->data[0];
}
/**
* hkl_vector_angle: (skip)
* @self: the fist #HklVector
* @vector: the second #HklVector
*
* compute the angles beetween two #HklVector
*
* Returns: the return value is in beetween [0, pi]
**/
double hkl_vector_angle(const HklVector *self, const HklVector *vector)
{
double angle;
double cos_angle;
double norm;
double norm_self;
double norm_vector;
norm_self = hkl_vector_norm2(self);
norm_vector = hkl_vector_norm2(vector);
if (norm_self < HKL_EPSILON || norm_vector < HKL_EPSILON)
return 0.0;
norm = norm_self * norm_vector;
cos_angle = hkl_vector_scalar_product(self, vector) / norm;
/* problem with round */
if (cos_angle >= 1 )
angle = 0;
else
if (cos_angle <= -1 )
angle = M_PI;
else
angle = acos(cos_angle);
return angle;
}
/**
* hkl_vector_oriented_angle: (skip)
* @self: the first #HklVector
* @vector: the second #HklVector
* @ref: the reference #HklVector
*
* compute the angles beetween two #HklVector and use
* a reference #HklVector to orientate the space. That's
* way the return value can be in beetween [-pi, pi].
* the (self, vector, ref) is a right oriented base.
*
* Returns: the angles [-pi, pi]
**/
double hkl_vector_oriented_angle(const HklVector *self,
const HklVector *vector,
const HklVector *ref)
{
double angle;
HklVector tmp;
HklVector ref_u;
angle = hkl_vector_angle(self, vector);
tmp = *self;
hkl_vector_vectorial_product(&tmp, vector);
hkl_vector_normalize(&tmp);
ref_u = *ref;
hkl_vector_normalize(&ref_u);
if (hkl_vector_is_opposite(&tmp, &ref_u))
angle = -angle;
return angle;
}
/**
* hkl_vector_oriented_angle_points: (skip)
* @self: the first point
* @p2: the second point
* @p3: the third point
* @ref: the reference #HklVector
*
* compute the angles beetween three points (p1, p2, p3) and use
* a reference #HklVector to orientate the space. That's
* way the return value can be in beetween [-pi, pi].
* the (self, vector, ref) is a right oriented base.
*
* Returns: the angles [-pi, pi]
**/
double hkl_vector_oriented_angle_points(const HklVector *self,
const HklVector *p2,
const HklVector *p3,
const HklVector *ref)
{
HklVector v1;
HklVector v2;
v1 = *self;
v2 = *p3;
hkl_vector_minus_vector(&v1, p2);
hkl_vector_minus_vector(&v2, p2);
return hkl_vector_oriented_angle(&v1, &v2, ref);
}
/**
* hkl_vector_normalize: (skip)
* @self: the #HklVector to normalize
*
* normalize a hkl_vector
*
* Returns: TRUE if the #HklVector can be normalized, FALSE otherwise
**/
int hkl_vector_normalize(HklVector *self)
{
double norm = hkl_vector_norm2(self);
if ( norm <= HKL_EPSILON )
return FALSE;
hkl_vector_div_double(self, norm);
return TRUE;
}
/**
* hkl_vector_is_colinear: (skip)
* @self: the first #HklVector
* @vector: the second #HklVector
*
* check if two #HklVector are colinears
*
* Returns: TRUE if both are colinear.
**/
int hkl_vector_is_colinear(const HklVector *self, const HklVector *vector)
{
int is_colinear = 0;
HklVector tmp = *self;
hkl_vector_vectorial_product(&tmp, vector);
if (hkl_vector_norm2(&tmp) < HKL_EPSILON)
is_colinear = 1;
return is_colinear;
}
/**
* hkl_vector_randomize: (skip)
* @self: the #HklVector to randomize
*
* initialize a vector with random values.
* coordinates range [-1, 1]
*/
void hkl_vector_randomize(HklVector *self)
{
self->data[0] = -1 + 2 *rand()/(RAND_MAX+1.0);
self->data[1] = -1 + 2 *rand()/(RAND_MAX+1.0);
self->data[2] = -1 + 2 *rand()/(RAND_MAX+1.0);
}
/**
* hkl_vector_randomize_vector: (skip)
* @self: the #HklVector to randomize
* @vector: the #HklVector result to avoid
*
* randomize an #HklVector an be sure that it is not equal
* to the #HklVector vector.
**/
void hkl_vector_randomize_vector(HklVector *self, const HklVector *vector)
{
do
hkl_vector_randomize(self);
while (!hkl_vector_cmp(self, vector));
}
/**
* hkl_vector_randomize_vector_vector: (skip)
* @self: the #HklVector to randomize
* @vector1: the first #HklVector solution to avoid
* @vector2: the second #HklVector solution to avoid
*
* randomize an #HklVector an be sure that it is not equal
* to the #HklVector vector1 and vector2.
*
**/
void hkl_vector_randomize_vector_vector(HklVector *self,
const HklVector *vector1,
const HklVector *vector2)
{
do
hkl_vector_randomize(self);
while (!hkl_vector_cmp(self, vector1) || !hkl_vector_cmp(self, vector2));
}
/**
* hkl_vector_rotated_around_vector: (skip)
* @self: the #HklVector to rotate
* @axe: the axe of rotation
* @angle: the angle of the rotation
*
* rotate a vector around another one with a given angle.
**/
void hkl_vector_rotated_around_vector(HklVector *self,
const HklVector *axe, double angle)
{
double c = cos(angle);
double s = sin(angle);
HklVector axe_n;
HklVector tmp;
axe_n = *axe;
hkl_vector_normalize(&axe_n);
tmp = *self;
self->data[0] = (c + (1 - c) * axe_n.data[0] * axe_n.data[0]) * tmp.data[0];
self->data[0] += ((1 - c) * axe_n.data[0] * axe_n.data[1] - axe_n.data[2] * s) * tmp.data[1];
self->data[0] += ((1 - c) * axe_n.data[0] * axe_n.data[2] + axe_n.data[1] * s) * tmp.data[2];
self->data[1] = ((1 - c) * axe_n.data[0] * axe_n.data[1] + axe_n.data[2] * s) * tmp.data[0];
self->data[1] += (c + (1 - c) * axe_n.data[1] * axe_n.data[1]) * tmp.data[1];
self->data[1] += ((1 - c) * axe_n.data[1] * axe_n.data[2] - axe_n.data[0] * s) * tmp.data[2];
self->data[2] = ((1 - c) * axe_n.data[0] * axe_n.data[2] - axe_n.data[1] * s) * tmp.data[0];
self->data[2] += ((1 - c) * axe_n.data[1] * axe_n.data[2] + axe_n.data[0] * s) * tmp.data[1];
self->data[2] += (c + (1 - c) * axe_n.data[2] * axe_n.data[2]) * tmp.data[2];
}
/**
* hkl_vector_norm2: (skip)
* @self: the #hklvector use to compute the norm2
*
* compute the norm2 of an #HklVector
*
* Returns: the sqrt(|v|)
**/
double hkl_vector_norm2(const HklVector *self)
{
return sqrt(self->data[0] * self->data[0]
+ self->data[1] * self->data[1]
+ self->data[2] * self->data[2]);
}
/**
* hkl_vector_rotated_quaternion: (skip)
* @self: the #HklVector to rotate
* @qr: the #HklQuaternion use to rotate the vector
*
* rotate an #HklVector using an #HklQuaternion.
**/
void hkl_vector_rotated_quaternion(HklVector *self, const HklQuaternion *qr)
{
double v1 = self->data[0];
double v2 = self->data[1];
double v3 = self->data[2];
double a = qr->data[0];
double b = qr->data[1];
double c = qr->data[2];
double d = qr->data[3];
double t2 = a*b;
double t3 = a*c;
double t4 = a*d;
double t5 = -b*b;
double t6 = b*c;
double t7 = b*d;
double t8 = -c*c;
double t9 = c*d;
double t10 = -d*d;
self->data[0] = 2*( (t8 + t10)*v1 + (t6 - t4)*v2 + (t3 + t7)*v3 ) + v1;
self->data[1] = 2*( (t4 + t6)*v1 + (t5 + t10)*v2 + (t9 - t2)*v3 ) + v2;
self->data[2] = 2*( (t7 - t3)*v1 + (t2 + t9)*v2 + (t5 + t8)*v3 ) + v3;
}
/**
* hkl_vector_rotated_around_line: (skip)
* @self: the point to rotate around a line
* @angle: the angle of the rotation
* @c1: the fist point of the line
* @c2: the second point of the line
*
* This method rotate a point around a line defined by two points
* of a certain amount of angle. The rotation is right handed.
* this mean that c2 - c1 gives the direction of the rotation.
**/
void hkl_vector_rotated_around_line(HklVector *self, double angle,
const HklVector *c1, const HklVector *c2)
{
HklVector axis;
if (!self || !c1 || !c2 || fabs(angle) < HKL_EPSILON)
return;
axis = *c2;
hkl_vector_minus_vector(&axis, c1);
/* the c2 - c1 vector must be non null */
hkl_vector_minus_vector(self, c1);
hkl_vector_rotated_around_vector(self, &axis, angle);
hkl_vector_add_vector(self, c1);
}
/**
* hkl_vector_is_null: (skip)
* @self: the #hklvector to check
*
* check if all the coordinates of an #HklVector are null.
*
* Returns: HKl_TRUE if all |elements| are below HKL_EPSILON, HKl_FALSE otherwise
*
* Todo: test
*/
int hkl_vector_is_null(const HklVector *self)
{
unsigned int i;
for (i=0; i<3; i++)
if ( fabs(self->data[i]) > HKL_EPSILON )
return FALSE;
return TRUE;
}
/**
* hkl_vector_project_on_plan: (skip)
* @self: the vector to project
* @normal: the normal of the plane.
*
* project an #HklVector on a plan of normal which contain
* the origin [0, 0, 0]
*
**/
void hkl_vector_project_on_plan(HklVector *self,
const HklVector *normal)
{
HklVector tmp;
if(!self || !normal)
return;
tmp = *normal;
hkl_vector_normalize(&tmp);
hkl_vector_times_double(&tmp, hkl_vector_scalar_product(self, &tmp));
hkl_vector_minus_vector(self, &tmp);
}
/**
* hkl_vector_project_on_plan_with_point: (skip)
* @self: the vector to project (modify)
* @normal: the normal of the plane.
* @point: a point of the plan.
*
* project an #HklVector on a plan of normal #normal which contain #point.
**/
void hkl_vector_project_on_plan_with_point(HklVector *self,
const HklVector *normal,
const HklVector *point)
{
HklVector tmp;
double d1, d2;
if(!self || !normal || !point)
return;
tmp = *normal;
hkl_vector_normalize(&tmp);
d1 = hkl_vector_scalar_product(self, &tmp);
d2 = hkl_vector_scalar_product(point, &tmp);
hkl_vector_times_double(&tmp, d1 - d2);
hkl_vector_minus_vector(self, &tmp);
}
hkl-5.0.0.2569/hkl/hkl-macros.c 0000644 0001751 0001751 00000003022 13447477011 016107 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for backtrace, etc
#include "hkl-macros-private.h"
#ifndef _MSC_VER
void hkl_printbt(void)
{
void *array[20];
int size;
char **strings;
int i;
size = backtrace(array, 20);
strings = backtrace_symbols(array, size);
printf("Got a backtrace:\n");
for(i=0; i.
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
* Copyright (C) 2017 DESY
*
* Authors: Picca Frédéric-Emmanuel
* Teresa Núñez
*/
#include "hkl.h"
#include // for gsl_isnan
#include "hkl-axis-private.h"
#include "hkl-factory-private.h" // for autodata_factories_, etc
#include "hkl-matrix-private.h"
#include "hkl-pseudoaxis-common-hkl-private.h" // for hkl_mode_operations, etc
#include "hkl-pseudoaxis-common-psi-private.h" // for hkl_engine_psi_new, etc
#include "hkl-pseudoaxis-common-q-private.h" // for hkl_engine_q2_new, etc
#include "hkl-pseudoaxis-common-tth-private.h" // for hkl_engine_tth2_new, etc
#include "hkl-pseudoaxis-common-readonly-private.h"
#include "hkl-sample-private.h"
/***********************
Description
There are 5 real motors:
mchi (monochromator rotation) -> rotation y axis +1
sphi (sample rotation) -> rotation z axis +1
dtth (detector table rotation) -> rotation z axis -1
dh (detector height) -> translation z axis +1
drot (detector rotation) -> rotation x axis +1
There are 4 pseudo motors related to them:
alpha (incident angle - kin with xy plane)
beta (outgoing angle - kout with xy plane)
sth (angle between the kin projection and the vector defined via sphi)
stth (angle between kin and kout projections in the xy plane)
sth and stth has to be independently as pseudomotors.
For a given energy, E, one can compute mchi, sphi, dtth, dh and drot
from alpha, beta, th and tth and viceversa. The solutions are not
unique, for fixing them one has to set:
FRED: reading this and looking at the schema, it seems that you need a
pseudo motor engine with the four pseudo motors. something which takes
alpha, beta, sth and stth in order to compute the 5 real motors
positions. So maybe the right things to do is to create a pm with all
the pseudo motors and not only stth and sth.
Teresa: I agree. The users told me only about stth and sth, as the manual
also says, but it is better to have the four ones.
Maybe the right things to do is to create for now, only pseudo motors
with the read part. So once we have this setup it will be easier for
us to understand what is going on.
- Detector rotation tracking -> the detector table rotation, dtth,
follows the monochromator rotation, mchi, so that the position of
stth stays constant. For stth = 0 the detector is in diffraction
plane.
- mchi rotation direction -> if set to '+' the mchi angle goes from 0
to pi, set to '-' it goes from 0 to -pi.
- allow rotation sample -> if 'yes' the sample will be rotated with
the monochromator, so that sth will stay constant. If 'no' the
sample will not be rotated.
The following geometry constants have to be set:
- distance sample center to detector = 500
- distance first crystal (mono1) to sample center = 650
- distance first crystal (mono1) to second one (mono2) = 25
- first crystal diffraction parameter
- second crystal diffraction parameter
lambda = hc_over_e/Energy
bragg1 = g_tau1 * lambda * 1/(4*pi)
bragg2 = g_tau2 * lambda * 1/(4*pi)
where
the crystals used are Si111 and Si220.
g_tau1 = 2*PI/d111
g_tau2 = 2*PI/d220
where d111 and d220 are the lattice plane distances (in Amstrong) of the
crystals.
d111 = 3.136 A
d220 = 1.920 A
FRED: Do you want to set these parameters in the code or do you want
to add these parameters to the geometry dynamiquely ? So the user can
change this during the experimenta ? I would prefer a static
declaration for now in the code.
For a alpha, beta, th and tth set there are different possibilities of
choosing the position of the real motors for getting a given
h,k,l. Four possible geometry modes have to be implemented, each mode
gives an unique solution for the real computers computed from the
angles. These modes are:
- mode 0 -> K axis from reciprocal space parallel to incident beam.
- mode 1 -> alpha = beta
- mode 2 -> th = tth/2
- mode 3 -> K axis from reciprocal space parallel to outgoing beam.
There are some corrections (motor movements) that have to be done if
the energy is changed, in order to correct the shifts in the position
of the beam on the sample.
*******************/
/**************/
/* Axes names */
/**************/
#define SPHI "sphi"
#define DTTH "dtth"
#define DH "dh"
#define DROT "drot"
#define MCHI "mchi"
#define D_SD 0.5 /* meter */
#define D_Si111 3.136 /* Si111 of mono1 Angstöm */
#define D_Si220 1.920 /* Si220 ok mono2 Angstöm */
#define PETRA3_P08_LISA_SOURCE_HOLDER_IDX 0
#define PETRA3_P08_LISA_SAMPLE_HOLDER_IDX 1
#define PETRA3_P08_LISA_DETECTOR_HOLDER_IDX 2
#define HKL_GEOMETRY_PETRA3_P08_LISA_DESCRIPTION \
"+ xrays source fix along the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 1 axes for the monochromator\n" \
"\n" \
" + **" MCHI "** : rotation around the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"\n" \
"+ 1 axis for the sample\n" \
"\n" \
" + **" SPHI "** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
"\n" \
"+ 2 axes for the detector\n" \
"\n" \
" + **" DTTH "** : rotation around the :math:`-\\vec{z}` direction (0, 0, -1)\n" \
" + **" DH "** : translation along the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" DROT "** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
static double _alpha_max(double wavelength, double d1, double d2)
{
double theta1 = asin(wavelength / (2 * d1));
double theta2 = asin(wavelength / (2 * d2));
return 2 * (theta2 - theta1);
}
static int hkl_mode_hkl_petra3_p08_lisa_get_real(HklMode *self,
HklEngine *engine,
HklGeometry *geometry,
HklDetector *detector,
HklSample *sample,
GError **error)
{
HklHolder *holder;
HklMatrix RUB;
HklVector hkl;
HklVector ki;
HklVector Q;
HklEngineHkl *engine_hkl = container_of(engine, HklEngineHkl, engine);
/* update the geometry internals */
hkl_geometry_update(geometry);
/* R * UB */
/* for the lisa geometry the holder 1 is the sample holder. */
holder = hkl_geometry_sample_holder_get(geometry, sample);
hkl_quaternion_to_matrix(&holder->q, &RUB);
hkl_matrix_times_matrix(&RUB, &sample->UB);
/* kf - ki = Q */
ki = hkl_geometry_ki_get(geometry);
Q = hkl_geometry_kf_get(geometry, detector);
hkl_vector_minus_vector(&Q, &ki);
/* compute hkl */
hkl_matrix_solve(&RUB, &hkl, &Q);
engine_hkl->h->_value = hkl.data[0];
engine_hkl->k->_value = hkl.data[1];
engine_hkl->l->_value = hkl.data[2];
return TRUE;
}
int hkl_mode_hkl_petra3_p08_lisa_set_real(HklMode *self,
HklEngine *engine,
HklGeometry *geometry,
HklDetector *detector,
HklSample *sample,
GError **error)
{
/* FRED: to implement */
/* int last_axis; */
/* hkl_error (error == NULL || *error == NULL); */
/* /\* check the input parameters *\/ */
/* if(!hkl_is_reachable(engine, geometry->source.wave_length, */
/* error)){ */
/* hkl_assert(error == NULL || *error != NULL); */
/* return FALSE; */
/* } */
/* hkl_assert(error == NULL || *error == NULL); */
/* /\* compute the mode *\/ */
/* if(!hkl_mode_auto_set_real(self, engine, */
/* geometry, detector, sample, */
/* error)){ */
/* hkl_assert(error == NULL || *error != NULL); */
/* //fprintf(stdout, "message :%s\n", (*error)->message); */
/* return FALSE; */
/* } */
/* hkl_assert(error == NULL || *error == NULL); */
/* /\* check that the mode allow to move a sample axis *\/ */
/* /\* FIXME for now the sample holder is the first one *\/ */
/* last_axis = get_last_axis_idx(geometry, 0, &self->info->axes_w); */
/* if(last_axis >= 0){ */
/* uint i; */
/* const HklGeometryListItem *item; */
/* uint len = engine->engines->geometries->n_items; */
/* /\* For each solution already found we will generate another one *\/ */
/* /\* using the Ewalds construction by rotating Q around the last sample *\/ */
/* /\* axis of the mode until it intersect again the Ewald sphere. *\/ */
/* /\* FIXME do not work if ki is colinear with the axis. *\/ */
/* /\* for this we needs : *\/ */
/* /\* - the coordinates of the end of the Q vector (q) *\/ */
/* /\* - the last sample axis orientation of the mode (axis_v) *\/ */
/* /\* - the coordinates of the center of the ewalds sphere (c) *\/ */
/* /\* - the coordinates of the center of rotation of the sample (o = 0, 0, 0) *\/ */
/* /\* then we can : *\/ */
/* /\* - project the origin in plane of normal axis_v containing q (o') *\/ */
/* /\* - project the center of the ewalds sphere into the same plan (c') *\/ */
/* /\* - rotate q around this (o', c') line of 180° to find the (q2) solution *\/ */
/* /\* - compute the (kf2) corresponding to this q2 solution *\/ */
/* /\* at the end we just need to solve numerically the position of the detector *\/ */
/* /\* we will add solution to the geometries so save its length before *\/ */
/* for(i=0, item=list_top(&engine->engines->geometries->items, HklGeometryListItem, list); */
/* iengines->geometries->items, item, list)){ */
/* int j; */
/* HklVector ki; */
/* HklVector kf2; */
/* HklVector q; */
/* HklVector axis_v; */
/* HklQuaternion qr; */
/* HklAxis *axis; */
/* HklVector cp = {{0}}; */
/* HklVector op = {{0}}; */
/* double angle; */
/* HklGeometry *geom; */
/* geom = hkl_geometry_new_copy(item->geometry); */
/* /\* get the Q vector kf - ki *\/ */
/* hkl_detector_compute_kf(detector, geom, &q); */
/* hkl_source_compute_ki(&geom->source, &ki); */
/* hkl_vector_minus_vector(&q, &ki); */
/* /\* compute the current orientation of the last axis *\/ */
/* axis = container_of(darray_item(geom->axes, */
/* darray_item(geom->holders, 0)->config->idx[last_axis]), */
/* HklAxis, parameter); */
/* axis_v = axis->axis_v; */
/* hkl_quaternion_init(&qr, 1, 0, 0, 0); */
/* for(j=0; jaxes, */
/* darray_item(geom->holders, 0)->config->idx[j]), */
/* HklAxis, parameter)->q); */
/* hkl_vector_rotated_quaternion(&axis_v, &qr); */
/* /\* - project the center of the ewalds sphere into the same plan (c') *\/ */
/* hkl_vector_minus_vector(&cp, &ki); */
/* hkl_vector_project_on_plan_with_point(&cp, &axis_v, &q); */
/* hkl_vector_project_on_plan_with_point(&op, &axis_v, &q); */
/* /\* - rotate q around this (o', c') line of 180° to find the (q2) solution *\/ */
/* kf2 = q; */
/* hkl_vector_rotated_around_line(&kf2, M_PI, &cp, &op); */
/* angle = hkl_vector_oriented_angle_points(&q, &op, &kf2, &axis_v); */
/* /\* TODO parameter list for geometry *\/ */
/* if(!hkl_parameter_value_set(&axis->parameter, */
/* hkl_parameter_value_get(&axis->parameter, HKL_UNIT_DEFAULT) + angle, */
/* HKL_UNIT_DEFAULT, error)) */
/* return FALSE; */
/* hkl_geometry_update(geom); */
/* #ifdef DEBUG */
/* fprintf(stdout, "\n- try to add a solution by rotating Q <%f, %f, %f> around the \"%s\" axis <%f, %f, %f> of %f radian", */
/* q.data[0], q.data[1], q.data[2], */
/* ((HklParameter *)axis)->name, */
/* axis_v.data[0], axis_v.data[1], axis_v.data[2], */
/* angle); */
/* fprintf(stdout, "\n op: <%f, %f, %f>", op.data[0], op.data[1], op.data[2]); */
/* fprintf(stdout, "\n q2: <%f, %f, %f>", kf2.data[0], kf2.data[1], kf2.data[2]); */
/* #endif */
/* hkl_vector_add_vector(&kf2, &ki); */
/* /\* at the end we just need to solve numerically the position of the detector *\/ */
/* if(fit_detector_position(self, geom, detector, &kf2)) */
/* hkl_geometry_list_add(engine->engines->geometries, */
/* geom); */
/* hkl_geometry_free(geom); */
/* } */
/* } */
return TRUE;
}
#define HKL_MODE_HKL_PETRA3_P08_LISA_OPERATIONS_DEFAULTS \
HKL_MODE_OPERATIONS_AUTO_DEFAULTS, \
.get = hkl_mode_hkl_petra3_p08_lisa_get_real, \
.set = hkl_mode_hkl_petra3_p08_lisa_set_real
static const HklModeOperations hkl_mode_hkl_petra3_p08_lisa_operations = {
HKL_MODE_HKL_PETRA3_P08_LISA_OPERATIONS_DEFAULTS,
};
static const char* hkl_geometry_petra3_p08_lisa_axes[] = {MCHI, SPHI, DTTH, DH, DROT};
static HklHolder *hkl_geometry_petra3_p08_lisa_sample_holder_get_real(const HklGeometry *geometry,
const HklSample *sample)
{
return darray_item(geometry->holders, PETRA3_P08_LISA_SAMPLE_HOLDER_IDX);
}
static HklHolder *hkl_geometry_petra3_p08_lisa_detector_holder_get_real(const HklGeometry *geometry,
const HklDetector *detector)
{
return darray_item(geometry->holders, PETRA3_P08_LISA_DETECTOR_HOLDER_IDX);
}
static HklVector hkl_geometry_petra3_p08_lisa_ki_get_real(const HklGeometry *geometry)
{
double alpha_max = _alpha_max(geometry->source.wave_length, D_Si111, D_Si220);
HklHolder *holder;
HklVector ki = {{cos(alpha_max), 0, -sin(alpha_max)}};
holder = darray_item(geometry->holders, PETRA3_P08_LISA_SOURCE_HOLDER_IDX);
ki = hkl_holder_transformation_apply(holder, &ki);
hkl_vector_times_double(&ki, HKL_TAU / geometry->source.wave_length);
return ki;
}
static HklVector hkl_geometry_petra3_p08_lisa_kf_get_real(const HklGeometry *geometry,
const HklDetector *detector)
{
HklHolder *holder;
HklVector kf = {{D_SD, 0, 0}};
holder = hkl_geometry_detector_holder_get(geometry, detector);
kf = hkl_holder_transformation_apply(holder, &kf);
hkl_vector_normalize(&kf);
hkl_vector_times_double(&kf, HKL_TAU / geometry->source.wave_length);
return kf;
}
#define HKL_GEOMETRY_PETRA3_P08_LISA_OPERATIONS_DEFAULTS \
HKL_GEOMETRY_OPERATIONS_DEFAULTS, \
.sample_holder_get = hkl_geometry_petra3_p08_lisa_sample_holder_get_real, \
.detector_holder_get = hkl_geometry_petra3_p08_lisa_detector_holder_get_real, \
.ki_get = hkl_geometry_petra3_p08_lisa_ki_get_real, \
.kf_get = hkl_geometry_petra3_p08_lisa_kf_get_real
static HklGeometry *hkl_geometry_new_petra3_p08_lisa(const HklFactory *factory)
{
static HklGeometryOperations ops = {HKL_GEOMETRY_PETRA3_P08_LISA_OPERATIONS_DEFAULTS};
HklGeometry *self = hkl_geometry_new(factory, &ops);
HklHolder *h;
/* source */
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MCHI, 1, 0, 0, &hkl_unit_angle_deg);
/* sample */
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, SPHI, 0, 0, 1, &hkl_unit_angle_deg);
/* detector */
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, DTTH, 0, 0, -1, &hkl_unit_angle_deg);
hkl_holder_add_translation(h, DH, 0, 0, 1, &hkl_unit_length_mm);
hkl_holder_add_rotation_with_origin(h, DROT, 0, -1, 0, D_SD, 0, 0, &hkl_unit_angle_deg);
return self;
}
/*********/
/* Modes */
/********/
/* hkl modes */
static HklMode *k_parallel_incident(void)
{
/* TODO: check if the axes are correct, add the functions and implement them */
static const char* axes_r[] = {MCHI, SPHI, DTTH, DROT};
static const char* axes_w[] = {MCHI, SPHI, DTTH, DROT};
static const HklFunction *functions[] = {};
/* here just the description of the mode: name, axes_r, axes_w, functions */
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
/* instantiate a new mode */
return hkl_mode_auto_new(&info,
&hkl_mode_hkl_petra3_p08_lisa_operations,
TRUE);
}
static HklMode *alpha_eq_beta(void)
{
/* TODO: check if the axes are correct, add the functions and implement them */
static const char* axes_r[] = {MCHI, SPHI, DTTH, DROT};
static const char* axes_w[] = {MCHI, SPHI, DTTH, DROT};
static const HklFunction *functions[] = {};
/* here just the description of the mode: name, axes_r, axes_w, functions */
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
/* instantiate a new mode */
return hkl_mode_auto_new(&info,
&hkl_mode_hkl_petra3_p08_lisa_operations,
TRUE);
}
static HklMode *th_eq_tth2(void)
{
/* TODO: check if the axes are correct, add the functions and implement them */
static const char* axes_r[] = {MCHI, SPHI, DTTH, DROT};
static const char* axes_w[] = {MCHI, SPHI, DTTH, DROT};
static const HklFunction *functions[] = {};
/* here just the description of the mode: name, axes_r, axes_w, functions */
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
/* instantiate a new mode */
return hkl_mode_auto_new(&info,
&hkl_mode_hkl_petra3_p08_lisa_operations,
TRUE);
}
static HklMode *k_parallel_outgoing(void)
{
/* TODO: check if the axes are correct, add the functions and implement them */
static const char* axes_r[] = {MCHI, SPHI, DTTH, DROT};
static const char* axes_w[] = {MCHI, SPHI, DTTH, DROT};
static const HklFunction *functions[] = {};
/* here just the description of the mode: name, axes_r, axes_w, functions */
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
/* instantiate a new mode */
return hkl_mode_auto_new(&info,
&hkl_mode_hkl_petra3_p08_lisa_operations,
TRUE);
}
/* lisapm modes */
static const HklParameter mode_lisa_pm_parameters[] = {
{
HKL_PARAMETER_DEFAULTS, .name = "det_rot_tracking", ._value = 0,
.description = "if 1, the detector table will be rotated with the monochromator, so that stth stays constant",
.range = { .min=0, .max=1 },
},
{
HKL_PARAMETER_DEFAULTS, .name = "mchi_rot_dir", ._value = 1,
.description = "if 1 mchi angle goes from 0 to pi, if -1 from 0 to -pi",
.range = { .min=-1, .max=1 },
},
{
HKL_PARAMETER_DEFAULTS, .name = "sample_rot", ._value = 0,
.description = "if 1, the sample will be rotated with the monochromator, so that sth stays constant.",
.range = { .min=0, .max=1 },
},
};
static int _mode_lisa_pm_m_to_pm_func(const gsl_vector *x, void *params, gsl_vector *f)
{
/* TODO: implement it */
return GSL_SUCCESS;
}
static const HklFunction mode_lisa_pm_m_to_pm_func = {
.function = _mode_lisa_pm_m_to_pm_func,
.size = 3,
};
static int _mode_lisa_pm_pm_to_m_func(const gsl_vector *x, void *params, gsl_vector *f)
{
/* TODO: implement it */
return GSL_SUCCESS;
}
static const HklFunction mode_lisa_pm_pm_to_m_func = {
.function = _mode_lisa_pm_pm_to_m_func,
.size = 3,
};
static HklMode *mode_lisa_pm(void)
{
static const char* axes_r[] = {MCHI, SPHI, DTTH}; /* QUESTION: these are the two motors I need for computing sth and stth positions, is this right ??? */
static const char* axes_w[] = {MCHI, SPHI, DTTH}; /* QUESTION: these are the motors I move if I write to the pseudomotor sth or stth, is this right ??? */
/* here a list of functions use to solve the mode */ /* QUESTION: which functions should be here ???, I need one for computing motor positions from pseudomotor and one for computing pseudonmotor from motor positions. Why in the other diffractometers there is only one function here ??? */
/* FRED this are not the functions in order to do get and set but only to do the set. the get/set is done in the hkl_mode_operations. */
static const HklFunction *functions[] = {&mode_lisa_pm_m_to_pm_func, &mode_lisa_pm_pm_to_m_func};
/* here just the description of the mode: name, axes_r, axes_w, functions */
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w, functions, mode_lisa_pm_parameters),
};
/* instantiate a new mode */
return hkl_mode_auto_new(&info,
&hkl_mode_operations, /* FRED these operation must be specifique to the pseudo motors look at the read_only emergence pseudo in hkl-pseudoaxis-common-readonly code. */
TRUE);
}
/******************/
/* LisaPM Engine */
/*****************/
struct _HklEngineLisaPM
{
HklEngine engine;
HklParameter *sth;
HklParameter *stth;
};
typedef struct _HklEngineLisaPM HklEngineLisaPM;
static void hkl_engine_lisapm_free_real(HklEngine *base)
{
HklEngineLisaPM *self = container_of(base, HklEngineLisaPM, engine);
hkl_engine_release(&self->engine);
free(self);
}
HklEngine *hkl_engine_lisa_pm_new(HklEngineList *engines)
{
HklEngineLisaPM *self;
static const HklParameter sth = {
HKL_PARAMETER_DEFAULTS_ANGLE, .name="sth",
.description = "angle of the projection of $\\vec{ki}$ in the $xy$ and the sample table rotation",
};
static const HklParameter stth = {
HKL_PARAMETER_DEFAULTS_ANGLE, .name="stth",
.description = "angle of the projection of $\\vec{ki}$ in the $xy$ and the detector arm",
};
static const HklParameter *pseudo_axes[] = {&sth, &stth};
static const HklEngineInfo info = {
HKL_ENGINE_INFO("LisaPM",
pseudo_axes,
HKL_ENGINE_DEPENDENCIES_AXES),
};
static const HklEngineOperations operations = {
HKL_ENGINE_OPERATIONS_DEFAULTS,
.free=hkl_engine_lisapm_free_real,
};
self = HKL_MALLOC(HklEngineLisaPM);
hkl_engine_init(&self->engine, &info, &operations, engines);
self->sth = register_pseudo_axis(&self->engine, engines, &sth);
self->stth = register_pseudo_axis(&self->engine, engines, &stth);
return &self->engine;
}
/***********/
/* Engines */
/***********/
static HklEngine *hkl_engine_petra3_p08_lisa_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = k_parallel_incident();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, alpha_eq_beta());
hkl_engine_add_mode(self, th_eq_tth2());
hkl_engine_add_mode(self, k_parallel_outgoing());
return self;
}
static HklEngine *hkl_engine_petra3_p08_lisa_pm_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_lisa_pm_new(engines);
default_mode = mode_lisa_pm();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
return self;
}
/***************/
/* Engine list */
/***************/
static HklEngineList *hkl_engine_list_new_petra3_p08_lisa(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_petra3_p08_lisa_hkl_new(self);
/* hkl_engine_petra3_p08_lisa_pm_new(self); */
return self;
}
/* Register the diffractometer into the factory */
/* REGISTER_DIFFRACTOMETER(petra3_p08_lisa, "PETRA3 P08 LISA", HKL_GEOMETRY_PETRA3_P08_LISA_DESCRIPTION); */
hkl-5.0.0.2569/hkl/hkl-engine-zaxis.c 0000644 0001751 0001751 00000012105 13447477011 017226 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for gsl_isnan
#include "hkl-factory-private.h" // for autodata_factories_, etc
#include "hkl-pseudoaxis-common-hkl-private.h" // for RUBh_minus_Q, etc
#include "hkl-pseudoaxis-common-q-private.h" // for hkl_engine_q2_new, etc
#include "hkl-pseudoaxis-common-tth-private.h" // for hkl_engine_tth2_new, etc
#include "hkl-pseudoaxis-common-readonly-private.h" // for hkl_engine_tth2_new, etc
#define MU "mu"
#define OMEGA "omega"
#define DELTA "delta"
#define GAMMA "gamma"
/* #define DEBUG */
static HklMode* _zaxis()
{
static const char *axes_r[] = {MU, OMEGA, DELTA, GAMMA};
static const char *axes_w[] = {OMEGA, DELTA, GAMMA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("zaxis", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
/* reflectivity */
static int _reflectivity_func(const gsl_vector *x, void *params, gsl_vector *f)
{
const double mu = x->data[0];
const double gamma = x->data[3];
CHECK_NAN(x->data, x->size);
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = mu - gamma;
return GSL_SUCCESS;
}
static const HklFunction reflectivity_func = {
.function = _reflectivity_func,
.size = 4,
};
static HklMode* reflectivity()
{
static const char* axes[] = {MU, OMEGA, DELTA, GAMMA};
static const HklFunction *functions[] = {&reflectivity_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes, axes, functions),
};
return hkl_mode_auto_new(&info,
&hkl_full_mode_operations,
TRUE);
}
/**********************/
/* pseudo axis engine */
/**********************/
static HklEngine *hkl_engine_zaxis_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = _zaxis();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, reflectivity());
return self;
}
/*****************/
/* mode readonly */
/*****************/
REGISTER_READONLY_INCIDENCE(hkl_engine_zaxis_incidence_new,
P99_PROTECT({MU, OMEGA}),
surface_parameters_y);
REGISTER_READONLY_EMERGENCE(hkl_engine_zaxis_emergence_new,
P99_PROTECT({MU, OMEGA, DELTA, GAMMA}),
surface_parameters_y);
/*********/
/* ZAXIS */
/*********/
#define HKL_GEOMETRY_TYPE_ZAXIS_DESCRIPTION \
"For this geometry the **mu** axis is common to the sample and the detector.\n" \
"\n" \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 2 axes for the sample\n" \
"\n" \
" + **" MU "** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" OMEGA "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
"\n" \
"+ 3 axis for the detector\n" \
"\n" \
" + **" MU "** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **" DELTA "** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
" + **" GAMMA "** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n"
static const char* hkl_geometry_zaxis_axes[] = {MU, OMEGA, DELTA, GAMMA};
static HklGeometry *hkl_geometry_new_zaxis(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MU, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, OMEGA, 0, -1, 0, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MU, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, DELTA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, GAMMA, 0, 0, 1, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_zaxis(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
hkl_engine_zaxis_hkl_new(self);
hkl_engine_q2_new(self);
hkl_engine_qper_qpar_new(self);
hkl_engine_tth2_new(self);
hkl_engine_zaxis_incidence_new(self);
hkl_engine_zaxis_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(zaxis, "ZAXIS", HKL_GEOMETRY_TYPE_ZAXIS_DESCRIPTION);
hkl-5.0.0.2569/hkl/hkl-unit.c 0000644 0001751 0001751 00000004745 13447477011 015617 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for GSL_NAN
#include // for gsl_isnan
#include // for free, NULL
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-unit-private.h" // for HklUnit, etc
#include "hkl.h" // for FALSE, HKL_DEGTORAD, etc
/**
* hkl_unit_dup: (skip)
* @self:
*
* copy an #Hklunit
*
* Returns: the copied #HklUnit (memory must be release with
* hkl_unit_free)
**/
HklUnit* hkl_unit_dup(const HklUnit *self)
{
if (!self)
return NULL;
HklUnit *dup = HKL_MALLOC(HklUnit);
*dup = *self;
return dup;
}
/**
* hkl_unit_free: (skip)
* @self:
*
* release the memory of an #HklUnit
**/
void hkl_unit_free(HklUnit *self)
{
if (self)
free(self);
}
/**
* hkl_unit_compatible: (skip)
* @self: the first @HklUnit
* @unit: the second @HklUnit to check
*
* check if two units are compatible.
*
* Returns: TRUE or FALSE
**/
int hkl_unit_compatible(const HklUnit *unit1, const HklUnit *unit2)
{
int res = FALSE;
if (unit1 == NULL) {
if (unit2 == NULL) {
res = TRUE;
}else{
res = FALSE;
}
}else{
if (unit2 == NULL){
res = FALSE;
}else{
res = ( (unit1->dimension.l == unit2->dimension.l)
&& (unit1->dimension.m == unit2->dimension.m)
&& (unit1->dimension.t == unit2->dimension.t)
&& (unit1->dimension.i == unit2->dimension.i)
&& (unit1->dimension.th == unit2->dimension.th)
&& (unit1->dimension.n == unit2->dimension.n)
&& (unit1->dimension.j == unit2->dimension.j));
}
}
return res;
}
hkl-5.0.0.2569/hkl/hkl-engine-k6c.c 0000644 0001751 0001751 00000077147 13447477011 016574 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for gsl_isnan
#include "hkl-factory-private.h" // for autodata_factories_, etc
#include "hkl-pseudoaxis-common-eulerians-private.h"
#include "hkl-pseudoaxis-common-hkl-private.h" // for RUBh_minus_Q, etc
#include "hkl-pseudoaxis-common-psi-private.h" // for hkl_engine_psi_new, etc
#include "hkl-pseudoaxis-common-q-private.h" // for hkl_engine_q2_new, etc
#include "hkl-pseudoaxis-common-readonly-private.h"
#include "hkl-pseudoaxis-common-tth-private.h" // for hkl_engine_tth2_new, etc
#define MU "mu"
#define KOMEGA "komega"
#define KAPPA "kappa"
#define KPHI "kphi"
#define GAMMA "gamma"
#define DELTA "delta"
static void hkl_geometry_list_multiply_k6c_real(HklGeometryList *self,
HklGeometryListItem *item)
{
HklGeometry *geometry;
HklGeometry *copy;
double komega, komegap;
double kappa, kappap;
double kphi, kphip;
geometry = item->geometry;
komega = hkl_parameter_value_get(darray_item(geometry->axes, 1), HKL_UNIT_DEFAULT);
kappa = hkl_parameter_value_get(darray_item(geometry->axes, 2), HKL_UNIT_DEFAULT);
kphi = hkl_parameter_value_get(darray_item(geometry->axes, 3), HKL_UNIT_DEFAULT);
kappa_2_kappap(komega, kappa, kphi, 50 * HKL_DEGTORAD, &komegap, &kappap, &kphip);
copy = hkl_geometry_new_copy(geometry);
/* TODO parameter list for the geometry */
hkl_parameter_value_set(darray_item(copy->axes, 1), komegap, HKL_UNIT_DEFAULT, NULL);
hkl_parameter_value_set(darray_item(copy->axes, 2), kappap, HKL_UNIT_DEFAULT, NULL);
hkl_parameter_value_set(darray_item(copy->axes, 3), kphip, HKL_UNIT_DEFAULT, NULL);
hkl_geometry_update(copy);
hkl_geometry_list_add(self, copy);
hkl_geometry_free(copy);
}
/***********************/
/* numerical functions */
/***********************/
static int _bissector_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
{
const double mu = x->data[0];
const double komega = x->data[1];
const double kappa = x->data[2];
const double gamma = x->data[4];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
f->data[4] = fmod(gamma - 2 * fmod(mu, M_PI), 2*M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_h_f1 = {
.function = _bissector_h_f1,
.size = 5,
};
static int _bissector_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
{
const double mu = x->data[0];
const double komega = x->data[1];
const double kappa = x->data[2];
const double gamma = x->data[4];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
f->data[4] = fmod(gamma - 2 * fmod(mu, M_PI), 2*M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_h_f2 = {
.function = _bissector_h_f2,
.size = 5,
};
static int _constant_kphi_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[1];
const double kappa = x->data[2];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
return GSL_SUCCESS;
}
static const HklFunction constant_kphi_h_f1 = {
.function = _constant_kphi_h_f1,
.size = 4,
};
static int _constant_kphi_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[1];
const double kappa = x->data[2];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
return GSL_SUCCESS;
}
static const HklFunction constant_kphi_h_f2 = {
.function = _constant_kphi_h_f2,
.size = 4,
};
static int _constant_phi_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[1];
const double kappa = x->data[2];
const double kphi = x->data[3];
double omega, phi, p;
CHECK_NAN(x->data, x->size);
p = atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD));
omega = komega + p - M_PI_2;
phi = kphi + p + M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
f->data[4] = phi;
return GSL_SUCCESS;
}
static const HklFunction constant_phi_h_f1 = {
.function = _constant_phi_h_f1,
.size = 5,
};
static int _constant_phi_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[1];
const double kappa = x->data[2];
const double kphi = x->data[3];
double omega, phi, p;
CHECK_NAN(x->data, x->size);
p = atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD));
omega = komega + p + M_PI_2;
phi = kphi + p - M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(omega, M_PI);
f->data[4] = phi;
return GSL_SUCCESS;
}
static const HklFunction constant_phi_h_f2 = {
.function = _constant_phi_h_f2,
.size = 5,
};
static int _bissector_v(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[0];
const double kappa = x->data[1];
const double delta = x->data[3];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = fmod(delta - 2 * fmod(omega, M_PI), 2*M_PI);
return GSL_SUCCESS;
}
static const HklFunction bissector_v = {
.function = _bissector_v,
.size = 4,
};
static int _constant_omega_v(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[0];
const double kappa = x->data[1];
double omega;
HklEngine *engine = params;
double omega0 = darray_item(engine->mode->parameters, 0)->_value;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = omega0 - omega;
return GSL_SUCCESS;
}
static const HklFunction constant_omega_v = {
.function = _constant_omega_v,
.size = 4,
};
static int _constant_chi_v(const gsl_vector *x, void *params, gsl_vector *f)
{
const double kappa = x->data[1];
double chi;
HklEngine *engine = params;
double chi0 = darray_item(engine->mode->parameters, 0)->_value;
CHECK_NAN(x->data, x->size);
chi = 2 * asin(sin(kappa/2.) * sin(50 * HKL_DEGTORAD));
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = chi0 - chi;
return GSL_SUCCESS;
}
static const HklFunction constant_chi_v = {
.function = _constant_chi_v,
.size = 4,
};
static int _constant_phi_v(const gsl_vector *x, void *params, gsl_vector *f)
{
const double kappa = x->data[1];
const double kphi = x->data[2];
double phi;
HklEngine *engine = params;
double phi0 = darray_item(engine->mode->parameters, 0)->_value;
CHECK_NAN(x->data, x->size);
phi = kphi + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
RUBh_minus_Q(x->data, params, f->data);
f->data[3] = phi0 - phi;
return GSL_SUCCESS;
}
static const HklFunction constant_phi_v = {
.function = _constant_phi_v,
.size = 4,
};
static int _double_diffraction_h(const gsl_vector *x, void *params, gsl_vector *f)
{
const double komega = x->data[1];
const double kappa = x->data[2];
double omega;
CHECK_NAN(x->data, x->size);
omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
_double_diffraction(x->data, params, f->data);
f->data[4] = fmod(omega, M_PI);
return GSL_SUCCESS;
}
static const HklFunction double_diffraction_h = {
.function = _double_diffraction_h,
.size = 5,
};
static int _constant_incidence_func(const gsl_vector *x, void *params, gsl_vector *f)
{
static const HklVector Y = {
.data = {0, 1, 0},
};
double incidence;
double azimuth;
HklEngine *engine = params;
HklModeAutoWithInit *mode = container_of(engine->mode, HklModeAutoWithInit, mode);
HklVector n;
double incidence0;
double azimuth0;
HklVector ki;
CHECK_NAN(x->data, x->size);
RUBh_minus_Q(x->data, params, f->data);
/* get the mode parameters */
n.data[0] = darray_item(engine->mode->parameters, 0)->_value;
n.data[1] = darray_item(engine->mode->parameters, 1)->_value;
n.data[2] = darray_item(engine->mode->parameters, 2)->_value;
incidence0 = darray_item(engine->mode->parameters, 3)->_value;
azimuth0 = darray_item(engine->mode->parameters, 4)->_value;
/* compute the two angles */
/* first check that the mode was already initialized if not
* the surface is oriented along the nx, ny, nz axis for all
* diffractometer angles equal to zero */
if(mode->geometry){
HklQuaternion q0 = hkl_geometry_sample_holder_get(mode->geometry, mode->sample)->q;
hkl_quaternion_conjugate(&q0);
hkl_vector_rotated_quaternion(&n, &q0);
}
hkl_vector_rotated_quaternion(&n, &hkl_geometry_sample_holder_get(engine->geometry,
mode->sample)->q);
ki = hkl_geometry_ki_get(engine->geometry);
incidence = _incidence(&n, &ki);
hkl_vector_project_on_plan(&n, &ki);
azimuth = hkl_vector_angle(&n, &Y);
f->data[3] = incidence0 - incidence;
f->data[4] = azimuth0 - azimuth;
return GSL_SUCCESS;
}
static const HklFunction constant_incidence_func = {
.function = _constant_incidence_func,
.size = 5,
};
/*******/
/* K6C */
/*******/
/************/
/* hkl mode */
/************/
static HklMode *bissector_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&bissector_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_omega_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&constant_omega_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, constant_omega_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_chi_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&constant_chi_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, constant_chi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_phi_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&constant_phi_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, constant_phi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_kphi(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KPHI, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_komega(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_mu(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, GAMMA, DELTA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&double_diffraction_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *bissector_horizontal(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&bissector_h_f1, &bissector_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_phi_horizontal(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&constant_phi_h_f1, &constant_phi_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, constant_phi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_kphi_horizontal(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, GAMMA};
static const HklFunction *functions[] = {&constant_kphi_h_f1, &constant_kphi_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_horizontal(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&double_diffraction_h};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *psi_constant_vertical(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&psi_constant_vertical_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, psi_constant_parameters),
};
return hkl_mode_auto_new(&info,
&psi_constant_vertical_mode_operations,
TRUE);
}
static HklMode *constant_incidence(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const HklFunction *functions[] = {&constant_incidence_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, constant_incidence_parameters),
};
return hkl_mode_auto_with_init_new(&info,
&constant_incidence_mode_operations,
TRUE);
}
static HklEngine *hkl_engine_k6c_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = bissector_vertical();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, constant_omega_vertical());
hkl_engine_add_mode(self, constant_chi_vertical());
hkl_engine_add_mode(self, constant_phi_vertical());
hkl_engine_add_mode(self, lifting_detector_kphi());
hkl_engine_add_mode(self, lifting_detector_komega());
hkl_engine_add_mode(self, lifting_detector_mu());
hkl_engine_add_mode(self, double_diffraction_vertical());
hkl_engine_add_mode(self, bissector_horizontal());
hkl_engine_add_mode(self, constant_phi_horizontal());
hkl_engine_add_mode(self, constant_kphi_horizontal());
hkl_engine_add_mode(self, double_diffraction_horizontal());
hkl_engine_add_mode(self, psi_constant_vertical());
hkl_engine_add_mode(self, constant_incidence());
return self;
}
/************/
/* psi mode */
/************/
static HklMode *psi_vertical(void)
{
static const char *axes_r[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static const char *axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&psi_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, psi_parameters),
};
return hkl_mode_psi_new(&info);
}
static HklEngine *hkl_engine_k6c_psi_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_psi_new(engines);
default_mode = psi_vertical();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
return self;
}
/*****************/
/* mode readonly */
/*****************/
REGISTER_READONLY_INCIDENCE(hkl_engine_k6c_incidence_new,
P99_PROTECT({MU, KOMEGA, KAPPA, KPHI}),
surface_parameters_y);
REGISTER_READONLY_EMERGENCE(hkl_engine_k6c_emergence_new,
P99_PROTECT({MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA}),
surface_parameters_y);
#define HKL_GEOMETRY_KAPPA6C_DESCRIPTION \
"For this geometry there is a special parameters called :math:`\\alpha` which is the\n" \
"angle between the kappa rotation axis and the :math:`\\vec{y}` direction.\n" \
"\n" \
"+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 4 axes for the sample\n" \
"\n" \
" + **mu** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **komega** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
" + **kappa** : rotating around the :math:`\\vec{x}` direction (0, :math:`-\\cos\\alpha`, :math:`-\\sin\\alpha`)\n" \
" + **kphi** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
"\n" \
"+ 2 axes for the detector\n" \
"\n" \
" + **gamma** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
" + **delta** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
static const char* hkl_geometry_kappa6C_axes[] = {MU, KOMEGA, KAPPA, KPHI, GAMMA, DELTA};
static HklGeometry *hkl_geometry_new_kappa6C(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
double alpha = 50 * HKL_DEGTORAD;
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MU, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KOMEGA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KAPPA, 0, -cos(alpha), -sin(alpha), &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KPHI, 0, -1, 0, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, GAMMA, 0, 0, 1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, DELTA, 0, -1, 0, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_kappa6C(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
self->geometries->multiply = hkl_geometry_list_multiply_k6c_real;
hkl_engine_k6c_hkl_new(self);
hkl_engine_eulerians_new(self);
hkl_engine_k6c_psi_new(self);
hkl_engine_q2_new(self);
hkl_engine_qper_qpar_new(self);
hkl_engine_k6c_incidence_new(self);
hkl_engine_tth2_new(self);
hkl_engine_k6c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(kappa6C, "K6C", HKL_GEOMETRY_KAPPA6C_DESCRIPTION);
/***********************/
/* SOLEIL sirius kappa */
/***********************/
/* hkl mode */
static HklMode *bissector_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&bissector_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("bissector_vertical", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_omega_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&constant_omega_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_omega_vertical", axes_r, axes_w,
functions, constant_omega_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_chi_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&constant_chi_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_chi_vertical", axes_r, axes_w,
functions, constant_chi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_phi_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&constant_phi_v};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_phi_vertical", axes_r, axes_w,
functions, constant_phi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_kphi_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KPHI, DELTA, GAMMA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("lifting_detector_kphi", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_komega_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, DELTA, GAMMA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("lifting_detector_komega", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *lifting_detector_mu_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {MU, DELTA, GAMMA};
static const HklFunction *functions[] = {&RUBh_minus_Q_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("lifting_detector_mu", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&double_diffraction_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("double_diffraction_vertical", axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *bissector_horizontal_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&bissector_h_f1, &bissector_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("bissector_horizontal", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_phi_horizontal_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&constant_phi_h_f1, &constant_phi_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_phi_horizontal", axes_r, axes_w,
functions, constant_phi_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *constant_kphi_horizontal_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, DELTA};
static const HklFunction *functions[] = {&constant_kphi_h_f1, &constant_kphi_h_f2};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO("constant_kphi_horizontal", axes_r, axes_w, functions),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *double_diffraction_horizontal_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {MU, KOMEGA, KAPPA, KPHI, DELTA};
static const HklFunction *functions[] = {&double_diffraction_h};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("double_diffraction_horizontal", axes_r, axes_w,
functions, double_diffraction_parameters),
};
return hkl_mode_auto_new(&info,
&hkl_mode_operations,
TRUE);
}
static HklMode *psi_constant_vertical_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&psi_constant_vertical_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("psi_constant_vertical", axes_r, axes_w,
functions, psi_constant_parameters),
};
return hkl_mode_auto_new(&info,
&psi_constant_vertical_mode_operations,
TRUE);
}
static HklMode *constant_incidence_soleil_sirius_kappa(void)
{
static const char* axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char* axes_w[] = {KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const HklFunction *functions[] = {&constant_incidence_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_incidence", axes_r, axes_w,
functions, constant_incidence_parameters),
};
return hkl_mode_auto_with_init_new(&info,
&constant_incidence_mode_operations,
TRUE);
}
static HklEngine *hkl_engine_soleil_sirius_kappa_hkl_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_hkl_new(engines);
default_mode = bissector_vertical_soleil_sirius_kappa();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
hkl_engine_add_mode(self, constant_omega_vertical_soleil_sirius_kappa());
hkl_engine_add_mode(self, constant_chi_vertical_soleil_sirius_kappa());
hkl_engine_add_mode(self, constant_phi_vertical_soleil_sirius_kappa());
hkl_engine_add_mode(self, lifting_detector_kphi_soleil_sirius_kappa());
hkl_engine_add_mode(self, lifting_detector_komega_soleil_sirius_kappa());
hkl_engine_add_mode(self, lifting_detector_mu_soleil_sirius_kappa());
hkl_engine_add_mode(self, double_diffraction_vertical_soleil_sirius_kappa());
hkl_engine_add_mode(self, bissector_horizontal_soleil_sirius_kappa());
hkl_engine_add_mode(self, constant_phi_horizontal_soleil_sirius_kappa());
hkl_engine_add_mode(self, constant_kphi_horizontal_soleil_sirius_kappa());
hkl_engine_add_mode(self, double_diffraction_horizontal_soleil_sirius_kappa());
hkl_engine_add_mode(self, psi_constant_vertical_soleil_sirius_kappa());
hkl_engine_add_mode(self, constant_incidence_soleil_sirius_kappa());
return self;
}
/* psi mode */
static HklMode *psi_vertical_soleil_sirius_kappa()
{
static const char *axes_r[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static const char *axes_w[] = {KOMEGA, KAPPA, KPHI, GAMMA};
static const HklFunction *functions[] = {&psi_func};
static const HklModeAutoInfo info = {
HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
functions, psi_parameters),
};
return hkl_mode_psi_new(&info);
}
static HklEngine *hkl_engine_soleil_sirius_kappa_psi_new(HklEngineList *engines)
{
HklEngine *self;
HklMode *default_mode;
self = hkl_engine_psi_new(engines);
default_mode = psi_vertical_soleil_sirius_kappa();
hkl_engine_add_mode(self, default_mode);
hkl_engine_mode_set(self, default_mode);
return self;
}
/* SOLEIL SIRIUS KAPPA */
#define HKL_GEOMETRY_TYPE_SOLEIL_SIRIUS_KAPPA_DESCRIPTION \
"+ xrays source fix along the :math:`\\vec{x}` direction (1, 0, 0)\n" \
"+ 4 axes for the sample\n" \
"\n" \
" + **" MU "** : rotating around the :math:`-\\vec{z}` direction (0, 0, -1)\n" \
" + **" KOMEGA "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
" + **" KAPPA "** : rotating around the :math:`\\vec{x}` direction (0, :math:`-\\cos\\alpha`, :math:`-\\sin\\alpha`)\n" \
" + **" KPHI "** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
"\n" \
"+ 2 axes for the detector\n" \
"\n" \
" + **" DELTA "** : rotation around the :math:`-\\vec{z}` direction (0, 0, -1)\n" \
" + **" GAMMA "** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
static const char* hkl_geometry_soleil_sirius_kappa_axes[] = {MU, KOMEGA, KAPPA, KPHI, DELTA, GAMMA};
static HklGeometry *hkl_geometry_new_soleil_sirius_kappa(const HklFactory *factory)
{
HklGeometry *self = hkl_geometry_new(factory, &hkl_geometry_operations_defaults);
double alpha = 50 * HKL_DEGTORAD;
HklHolder *h;
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, MU, 0, 0, -1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KOMEGA, 0, -1, 0, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KAPPA, 0, -cos(alpha), -sin(alpha), &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, KPHI, 0, -1, 0, &hkl_unit_angle_deg);
h = hkl_geometry_add_holder(self);
hkl_holder_add_rotation(h, DELTA, 0, 0, -1, &hkl_unit_angle_deg);
hkl_holder_add_rotation(h, GAMMA, 0, -1, 0, &hkl_unit_angle_deg);
return self;
}
static HklEngineList *hkl_engine_list_new_soleil_sirius_kappa(const HklFactory *factory)
{
HklEngineList *self = hkl_engine_list_new();
self->geometries->multiply = hkl_geometry_list_multiply_k6c_real;
hkl_engine_soleil_sirius_kappa_hkl_new(self);
hkl_engine_eulerians_new(self);
hkl_engine_soleil_sirius_kappa_psi_new(self);
hkl_engine_q2_new(self);
hkl_engine_qper_qpar_new(self);
hkl_engine_tth2_new(self);
hkl_engine_k6c_incidence_new(self);
hkl_engine_k6c_emergence_new(self);
return self;
}
REGISTER_DIFFRACTOMETER(soleil_sirius_kappa, "SOLEIL SIRIUS KAPPA", HKL_GEOMETRY_TYPE_SOLEIL_SIRIUS_KAPPA_DESCRIPTION);
hkl-5.0.0.2569/hkl/hkl-type-builtins.h 0000644 0001751 0001751 00000002316 13574156744 017455 0 ustar 00picca picca 0000000 0000000
/* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */
#ifndef __HKL_TYPE_BUILTINS_H__
#define __HKL_TYPE_BUILTINS_H__
#include // for G_BEGIN_DECLS, G_END_DECLS, etc
#include // GType
#include "hkl.h" // for HKLAPI
G_BEGIN_DECLS
/* enumerations from "../hkl.h" */
HKLAPI GType hkl_unit_enum_get_type (void) G_GNUC_CONST;
#define HKL_TYPE_UNIT_ENUM (hkl_unit_enum_get_type ())
HKLAPI GType hkl_detector_type_get_type (void) G_GNUC_CONST;
#define HKL_TYPE_DETECTOR_TYPE (hkl_detector_type_get_type ())
HKLAPI GType hkl_engine_capabilities_get_type (void) G_GNUC_CONST;
#define HKL_TYPE_ENGINE_CAPABILITIES (hkl_engine_capabilities_get_type ())
HKLAPI GType hkl_engine_axis_names_get_get_type (void) G_GNUC_CONST;
#define HKL_TYPE_ENGINE_AXIS_NAMES_GET (hkl_engine_axis_names_get_get_type ())
HKLAPI GType hkl_engine_dependencies_get_type (void) G_GNUC_CONST;
#define HKL_TYPE_ENGINE_DEPENDENCIES (hkl_engine_dependencies_get_type ())
G_END_DECLS
#endif /* __HKL_TYPE_BUILTINS_H__ */
/* Generated data ends here */
hkl-5.0.0.2569/hkl/hkl-matrix.c 0000644 0001751 0001751 00000026465 13447477011 016147 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for cos, fabs, atan2, sin, asin
#include // for fprintf, FILE
#include // for free
#include // for memcpy
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-matrix-private.h" // for _HklMatrix
#include "hkl-vector-private.h" // for HklVector, etc
#include "hkl.h" // for HklMatrix, HKL_EPSILON, etc
/**
* hkl_matrix_new: (skip)
*
* Returns: a new uninitialized HklMatrix
*/
HklMatrix *hkl_matrix_new()
{
return HKL_MALLOC(HklMatrix);
}
/**
* hkl_matrix_new_full: (skip)
* @m11: the matrix 11 value
* @m12: the matrix 12 value
* @m13: the matrix 13 value
* @m21: the matrix 21 value
* @m22: the matrix 22 value
* @m23: the matrix 23 value
* @m31: the matrix 31 value
* @m32: the matrix 32 value
* @m33: the matrix 33 value
*
* @todo test
* Returns: a new HklMAtrix
**/
HklMatrix *hkl_matrix_new_full(double m11, double m12, double m13,
double m21, double m22, double m23,
double m31, double m32, double m33)
{
HklMatrix *self = hkl_matrix_new();
hkl_matrix_init(self,
m11, m12, m13,
m21, m22, m23,
m31, m32, m33);
return self;
}
/**
* hkl_matrix_new_euler:
* @euler_x: the eulerian value along X
* @euler_y: the eulerian value along Y
* @euler_z: the eulerian value along Z
*
* Returns: Create a rotation #HklMatrix from three eulerians angles.
**/
HklMatrix *hkl_matrix_new_euler(double euler_x, double euler_y, double euler_z)
{
HklMatrix *self = hkl_matrix_new();
hkl_matrix_init_from_euler(self, euler_x, euler_y, euler_z);
return self;
}
/**
* hkl_matrix_dup: (skip)
* @self:
*
*
*
* Returns:
**/
HklMatrix *hkl_matrix_dup(const HklMatrix* self)
{
HklMatrix *dup;
dup = HKL_MALLOC(HklMatrix);
memcpy(dup, self, sizeof(*self));
return dup;
}
/**
* hkl_matrix_free: (skip)
* @self:
*
*
**/
void hkl_matrix_free(HklMatrix *self)
{
free(self);
}
/**
* hkl_matrix_init:
* @self: the #HklMatrix to initialize
* @m11: the matrix 11 value
* @m12: the matrix 12 value
* @m13: the matrix 13 value
* @m21: the matrix 21 value
* @m22: the matrix 22 value
* @m23: the matrix 23 value
* @m31: the matrix 31 value
* @m32: the matrix 32 value
* @m33: the matrix 33 value
*
*
**/
void hkl_matrix_init(HklMatrix *self,
double m11, double m12, double m13,
double m21, double m22, double m23,
double m31, double m32, double m33)
{
double (*M)[3] = self->data;
M[0][0] = m11, M[0][1] = m12, M[0][2] = m13;
M[1][0] = m21, M[1][1] = m22, M[1][2] = m23;
M[2][0] = m31, M[2][1] = m32, M[2][2] = m33;
}
/**
* hkl_matrix_matrix_set: (skip)
* @self: the this ptr
* @m: the matrix to set
*
* @todo test
**/
void hkl_matrix_matrix_set(HklMatrix *self, const HklMatrix *m)
{
if (self == m)
return;
memcpy(self->data, m->data, sizeof(double) * 9);
}
/**
* hkl_matrix_get:
* @self: the this ptr
* @i: the i coordinate
* @j: the j coordinate
*
* @todo test
* Return value: the Mij value
**/
double hkl_matrix_get(const HklMatrix *self, unsigned int i, unsigned int j)
{
return self->data[i][j];
}
/**
* hkl_matrix_fprintf:
* @file: the FILE stream
* @self: the #HklMatrix to print into the file stream
*
* printf an #HklMatrix into a FILE stream.
**/
void hkl_matrix_fprintf(FILE *file, const HklMatrix *self)
{
double const (*M)[3] = self->data;
fprintf(file, "|%f, %f, %f|\n", M[0][0], M[0][1], M[0][2]);
fprintf(file, "|%f, %f, %f|\n", M[1][0], M[1][1], M[1][2]);
fprintf(file, "|%f, %f, %f|\n", M[2][0], M[2][1], M[2][2]);
}
/**
* hkl_matrix_init_from_two_vector:
* @self: The #HklMatrix to initialize
* @v1: the first #HklVector
* @v2: the second #HklVector
*
* Create an #HklMatrix which represent a direct oriented base of the space
* the first row correspond to the |v1|, the second row |v2| and the last one
* is |v1 ^ v2|
**/
void hkl_matrix_init_from_two_vector(HklMatrix *self,
const HklVector *v1, const HklVector *v2)
{
HklVector x, y, z;
double (*M)[3] = self->data;
x = *v1;
hkl_vector_normalize(&x);
z = *v1;
hkl_vector_vectorial_product(&z, v2);
hkl_vector_normalize(&z);
y = z;
hkl_vector_vectorial_product(&y, &x);
M[0][0] = x.data[0], M[0][1] = y.data[0], M[0][2] = z.data[0];
M[1][0] = x.data[1], M[1][1] = y.data[1], M[1][2] = z.data[1];
M[2][0] = x.data[2], M[2][1] = y.data[2], M[2][2] = z.data[2];
}
/**
* hkl_matrix_init_from_euler:
* @self: the #HklMatrix to initialize
* @euler_x: the eulerian value along X
* @euler_y: the eulerian value along Y
* @euler_z: the eulerian value along Z
*
* Create a rotation #HklMatrix from three eulerians angles.
**/
void hkl_matrix_init_from_euler(HklMatrix *self,
double euler_x, double euler_y, double euler_z)
{
double (*M)[3] = self->data;
double A = cos(euler_x);
double B = sin(euler_x);
double C = cos(euler_y);
double D = sin(euler_y);
double E = cos(euler_z);
double F = sin(euler_z);
double AD = A *D;
double BD = B *D;
M[0][0] = C*E;
M[0][1] =-C*F;
M[0][2] = D;
M[1][0] = BD *E + A *F;
M[1][1] =-BD *F + A *E;
M[1][2] =-B *C;
M[2][0] =-AD *E + B *F;
M[2][1] = AD *F + B *E;
M[2][2] = A *C;
}
/**
* hkl_matrix_to_euler:
* @self: the rotation #HklMatrix use to compute the eulerians angles
* @euler_x: the eulerian value along X
* @euler_y: the eulerian value along Y
* @euler_z: the eulerian value along Z
*
* compute the three eulerians values for a given rotation #HklMatrix
**/
void hkl_matrix_to_euler(const HklMatrix *self,
double *euler_x, double *euler_y, double *euler_z)
{
double tx, ty;
double C;
double const (*M)[3] = self->data;
*euler_y = asin( self->data[0][2] ); /*Calculate Y-axis angle */
C = cos( *euler_y );
if (fabs(C) > HKL_EPSILON) {
/*Gimball lock? */
tx = M[2][2] / C; /*No, so get X-axis angle */
ty = -M[1][2] / C;
*euler_x = atan2( ty, tx );
tx = M[0][0] / C; /*Get Z-axis angle */
ty = -M[0][1] / C;
*euler_z = atan2( ty, tx );
} else {
/*Gimball lock has occurred */
*euler_x = 0.; /*Set X-axis angle to zero */
tx = M[1][1]; /*And calculate Z-axis angle */
ty = M[1][0];
*euler_z = atan2( ty, tx );
}
}
/**
* hkl_matrix_cmp:
* @self: the first #HklMatrix
* @m: the #HklMatrix to compare with
*
* compare two #HklMatrix.
*
* Returns: return TRUE if | self - m | > HKL_EPSILON
**/
int hkl_matrix_cmp(const HklMatrix *self, const HklMatrix *m)
{
unsigned int i;
unsigned int j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
if( fabs(self->data[i][j] - m->data[i][j]) > HKL_EPSILON )
return FALSE;
return TRUE;
}
/**
* hkl_matrix_times_matrix:
* @self: the #HklMatrix to modify
* @m: the #HklMatrix to multiply by
*
* compute the matrix multiplication self = self * m
**/
void hkl_matrix_times_matrix(HklMatrix *self, const HklMatrix *m)
{
HklMatrix const tmp = *self;
double (*M)[3] = self->data;
double const (*Tmp)[3] = tmp.data;
double const (*M1)[3];
if (self == m)
M1 = tmp.data;
else
M1 = m->data;
M[0][0] = Tmp[0][0]*M1[0][0] + Tmp[0][1]*M1[1][0] + Tmp[0][2]*M1[2][0];
M[0][1] = Tmp[0][0]*M1[0][1] + Tmp[0][1]*M1[1][1] + Tmp[0][2]*M1[2][1];
M[0][2] = Tmp[0][0]*M1[0][2] + Tmp[0][1]*M1[1][2] + Tmp[0][2]*M1[2][2];
M[1][0] = Tmp[1][0]*M1[0][0] + Tmp[1][1]*M1[1][0] + Tmp[1][2]*M1[2][0];
M[1][1] = Tmp[1][0]*M1[0][1] + Tmp[1][1]*M1[1][1] + Tmp[1][2]*M1[2][1];
M[1][2] = Tmp[1][0]*M1[0][2] + Tmp[1][1]*M1[1][2] + Tmp[1][2]*M1[2][2];
M[2][0] = Tmp[2][0]*M1[0][0] + Tmp[2][1]*M1[1][0] + Tmp[2][2]*M1[2][0];
M[2][1] = Tmp[2][0]*M1[0][1] + Tmp[2][1]*M1[1][1] + Tmp[2][2]*M1[2][1];
M[2][2] = Tmp[2][0]*M1[0][2] + Tmp[2][1]*M1[1][2] + Tmp[2][2]*M1[2][2];
}
/**
* hkl_matrix_times_vector:
* @self: the #HklMatrix use to multiply the #HklVector
* @v: the #HklVector multiply by the #HklMatrix
*
* multiply an #HklVector by an #HklMatrix
**/
void hkl_matrix_times_vector(const HklMatrix *self, HklVector *v)
{
HklVector tmp;
double *Tmp;
double *V = v->data;
double const (*M)[3] = self->data;
tmp = *v;
Tmp = tmp.data;
V[0] = Tmp[0]*M[0][0] + Tmp[1]*M[0][1] + Tmp[2]*M[0][2];
V[1] = Tmp[0]*M[1][0] + Tmp[1]*M[1][1] + Tmp[2]*M[1][2];
V[2] = Tmp[0]*M[2][0] + Tmp[1]*M[2][1] + Tmp[2]*M[2][2];
}
/**
* hkl_matrix_transpose:
* @self: the #HklMatrix to transpose
*
* transpose an #HklMatrix
**/
void hkl_matrix_transpose(HklMatrix *self)
{
#define SWAP(a, b) {double tmp=a; a=b; b=tmp;}
SWAP(self->data[1][0], self->data[0][1]);
SWAP(self->data[2][0], self->data[0][2]);
SWAP(self->data[2][1], self->data[1][2]);
}
/**
* hkl_matrix_det:
* @self: the #HklMatrix use to compute the determinant
*
* compute the determinant of an #HklMatrix
*
* Returns: the determinant of the self #HklMatrix
* Todo: test
**/
double hkl_matrix_det(const HklMatrix *self)
{
double det;
double const (*M)[3] = self->data;
det = M[0][0] * (M[1][1] * M[2][2] - M[2][1] * M[1][2]);
det += -M[0][1] * (M[1][0] * M[2][2] - M[2][0] * M[1][2]);
det += M[0][2] * (M[1][0] * M[2][1] - M[2][0] * M[1][1]);
return det;
}
/**
* hkl_matrix_solve:
* @self: The #HklMatrix of the system
* @x: the #HklVector to compute.
* @b: the #hklVector of the system to solve.
*
* solve the system self . X = b
*
* Returns: -1 if the système has no solution, 0 otherwise.
* Todo: test
**/
int hkl_matrix_solve(const HklMatrix *self, HklVector *x, const HklVector *b)
{
double det;
double const (*M)[3] = self->data;
double *X = x->data;
double const *B = b->data;
det = hkl_matrix_det(self);
if (fabs(det) < HKL_EPSILON)
return -1;
else {
X[0] = B[0] * (M[1][1]*M[2][2] - M[1][2]*M[2][1]);
X[0] += -B[1] * (M[0][1]*M[2][2] - M[0][2]*M[2][1]);
X[0] += B[2] * (M[0][1]*M[1][2] - M[0][2]*M[1][1]);
X[1] = -B[0] * (M[1][0]*M[2][2] - M[1][2]*M[2][0]);
X[1] += B[1] * (M[0][0]*M[2][2] - M[0][2]*M[2][0]);
X[1] += -B[2] * (M[0][0]*M[1][2] - M[0][2]*M[1][0]);
X[2] = B[0] * (M[1][0]*M[2][1] - M[1][1]*M[2][0]);
X[2] += -B[1] * (M[0][0]*M[2][1] - M[0][1]*M[2][0]);
X[2] += B[2] * (M[0][0]*M[1][1] - M[0][1]*M[1][0]);
hkl_vector_div_double(x, det);
}
return 0;
}
/**
* hkl_matrix_is_null:
* @self: the #HklMatrix to test
*
* is all #hklMatrix elementes bellow #HKL_EPSILON
*
* Returns: TRUE if the self #HklMatrix is null
* Todo: test
**/
int hkl_matrix_is_null(const HklMatrix *self)
{
unsigned int i;
unsigned int j;
for (i=0;i<3;i++)
for (j=0;j<3;j++)
if ( fabs(self->data[i][j]) > HKL_EPSILON )
return FALSE;
return TRUE;
}
hkl-5.0.0.2569/hkl/hkl-parameter-private.h 0000644 0001751 0001751 00000021106 13464522142 020256 0 ustar 00picca picca 0000000 0000000
/* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#ifndef __HKL_PARAMETER_PRIVATE_H__
#define __HKL_PARAMETER_PRIVATE_H__
#include // for M_PI
#include // for FILE, fprintf, NULL
#include // for free, rand, RAND_MAX
#include "ccan/compiler/compiler.h"
#include "hkl-interval-private.h" // for HklInterval
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-unit-private.h" // for HklUnit, hkl_unit_factor
#include "hkl.h" // for HklParameter, TRUE, etc
G_BEGIN_DECLS
typedef struct _HklParameterOperations HklParameterOperations;
struct _HklParameter {
const char *name;
const char *description;
HklInterval range;
double _value;
const HklUnit *unit;
const HklUnit *punit;
int fit;
int changed;
const HklParameterOperations *ops;
};
#define HKL_PARAMETER_DEFAULTS .name="dummy", .description="no description", .range={.min=-DBL_MAX, .max=DBL_MAX}, ._value=0, .unit=NULL, .punit=NULL, .fit=TRUE, .changed=TRUE, .ops = &hkl_parameter_operations_defaults
#define HKL_PARAMETER_DEFAULTS_ANGLE HKL_PARAMETER_DEFAULTS, .range={.min=-M_PI, .max=M_PI}, .unit = &hkl_unit_angle_rad, .punit = &hkl_unit_angle_deg
#define HKL_PARAMETER_ERROR hkl_parameter_error_quark ()
static inline GQuark hkl_parameter_error_quark (void)
{
return g_quark_from_static_string ("hkl-parameter-error-quark");
}
typedef enum {
HKL_PARAMETER_ERROR_MIN_MAX_SET, /* can not set the min max */
HKL_PARAMETER_ERROR_VALUE_SET, /* can not set the value */
} HklParameterError;
/****************/
/* HklParameter */
/****************/
struct _HklParameterOperations {
HklParameter * (*copy)(const HklParameter *self);
void (*free)(HklParameter *self);
int (*init_copy)(HklParameter *self, const HklParameter *src,
GError **error);
double (*get_value_closest)(const HklParameter *self,
const HklParameter *other);
int (*set_value)(HklParameter *self, double value,
HklUnitEnum unit_type, GError **error);
void (*set_value_smallest_in_range)(HklParameter *self);
void (*randomize)(HklParameter *self);
int (*is_valid)(const HklParameter *self);
int (*is_valid_range)(const HklParameter *self);
void (*fprintf)(FILE *f, const HklParameter *self);
const HklVector * (*axis_v_get)(const HklParameter *self);
const HklQuaternion * (*quaternion_get)(const HklParameter *self);
int (*transformation_cmp)(const HklParameter *self, const HklParameter *p2);
HklVector (*transformation_apply)(const HklParameter *self, const HklVector *v);
};
#define HKL_PARAMETER_OPERATIONS_DEFAULTS \
.copy = hkl_parameter_copy_real, \
.free = hkl_parameter_free_real, \
.init_copy = hkl_parameter_init_copy_real, \
.get_value_closest = hkl_parameter_value_get_closest_real, \
.set_value = hkl_parameter_value_set_real, \
.set_value_smallest_in_range = hkl_parameter_value_set_smallest_in_range_real, \
.randomize = hkl_parameter_randomize_real, \
.is_valid = hkl_parameter_is_valid_real, \
.is_valid_range = hkl_parameter_is_valid_real, \
.fprintf = hkl_parameter_fprintf_real, \
.axis_v_get = hkl_parameter_axis_v_get_real, \
.quaternion_get = hkl_parameter_quaternion_get_real, \
.transformation_cmp = hkl_parameter_transformation_cmp_real, \
.transformation_apply = hkl_parameter_transformation_apply_real
static inline HklParameter *hkl_parameter_copy_real(const HklParameter *self)
{
HklParameter *dup = HKL_MALLOC(HklParameter);
*dup = *self;
return dup;
}
static inline void hkl_parameter_free_real(HklParameter *self)
{
free(self);
}
static inline int hkl_parameter_init_copy_real(HklParameter *self, const HklParameter *src,
GError **error)
{
hkl_error (error == NULL || *error == NULL);
hkl_error (self->name == src->name || strcmp(self->name, src->name) == 0);
*self = *src;
self->changed = TRUE;
return TRUE;
}
static inline double hkl_parameter_value_get_closest_real(const HklParameter *self,
UNUSED const HklParameter *ref)
{
return self->_value;
}
static inline int hkl_parameter_value_set_real(HklParameter *self, double value,
HklUnitEnum unit_type, GError **error)
{
hkl_error (error == NULL || *error == NULL);
if (!isfinite(value)){
g_set_error(error,
HKL_PARAMETER_ERROR,
HKL_PARAMETER_ERROR_VALUE_SET,
"It is forbiden to set the (%s) parameter value with the non-finite %f value\n",
self->name, value);
return FALSE;
}
switch (unit_type) {
case HKL_UNIT_DEFAULT:
self->_value = value;
break;
case HKL_UNIT_USER:
self->_value = value / hkl_unit_factor(self->unit, self->punit);
break;
}
self->changed = TRUE;
return TRUE;
}
static inline void hkl_parameter_value_set_smallest_in_range_real(UNUSED HklParameter *self)
{
/* DOES NOTHING for a standard parameter */
}
static inline void hkl_parameter_randomize_real(HklParameter *self)
{
if (self->fit) {
double alea = (double)rand() / (RAND_MAX + 1.);
self->_value = self->range.min
+ (self->range.max - self->range.min) * alea;
self->changed = TRUE;
}
}
static inline int hkl_parameter_is_valid_real(const HklParameter *self)
{
if(self->_value < (self->range.min - HKL_EPSILON)
|| self->_value > (self->range.max + HKL_EPSILON))
return FALSE;
else
return TRUE;
}
static inline void hkl_parameter_fprintf_real(FILE *f, const HklParameter *self)
{
double factor = hkl_unit_factor(self->unit, self->punit);
if (self->punit)
fprintf(f, "\"%s\" : %.7f %s [%.7f : %.7f] (%d)",
self->name,
self->_value * factor,
self->punit->repr,
self->range.min * factor,
self->range.max * factor,
self->fit);
else
fprintf(f, "\"%s\" : %.7f [%.7f : %.7f] (%d)",
self->name,
self->_value * factor,
self->range.min * factor,
self->range.max * factor,
self->fit);
}
static inline const HklVector *hkl_parameter_axis_v_get_real(UNUSED const HklParameter *self)
{
return NULL;
}
static inline const HklQuaternion *hkl_parameter_quaternion_get_real(UNUSED const HklParameter *self)
{
return NULL;
}
static inline int hkl_parameter_transformation_cmp_real(const HklParameter *self, const HklParameter *p2)
{
return self->ops != p2->ops;
}
static inline HklVector hkl_parameter_transformation_apply_real(UNUSED const HklParameter *self,
const HklVector *v)
{
return *v;
}
static NEEDED HklParameterOperations hkl_parameter_operations_defaults = {
HKL_PARAMETER_OPERATIONS_DEFAULTS,
};
extern HklParameter *hkl_parameter_new(const char *name, const char *description,
double min, double value, double max,
int fit, int changed,
const HklUnit *unit,
const HklUnit *punit);
extern int hkl_parameter_init_copy(HklParameter *self, const HklParameter *src,
GError **error);
extern double hkl_parameter_value_get_closest(const HklParameter *self,
const HklParameter *ref);
extern void hkl_parameter_value_set_smallest_in_range(HklParameter *self);
extern int hkl_parameter_is_valid(const HklParameter *self);
extern int hkl_parameter_is_valid_range(const HklParameter *self);
extern void hkl_parameter_fprintf(FILE *f, const HklParameter *self);
extern int hkl_parameter_transformation_cmp(const HklParameter *self,
const HklParameter *p2);
extern HklVector hkl_parameter_transformation_apply(const HklParameter *self,
const HklVector *v);
/********************/
/* HklParameterList */
/********************/
typedef darray(HklParameter *) darray_parameter;
typedef darray(const HklParameter) darray_const_parameter;
G_END_DECLS
#endif /* __HKL_PARAMETER_PRIVATE_H__ */
hkl-5.0.0.2569/hkl/hkl-axis-private.h 0000644 0001751 0001751 00000004163 13447477011 017253 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#ifndef __HKL_AXIS_PRIVATE_H__
#define __HKL_AXIS_PRIVATE_H__
#include "hkl-parameter-private.h" // for _HklParameter
#include "hkl-quaternion-private.h" // for _HklQuaternion
#include "hkl-vector-private.h" // for HklVector, HklQuaternion
#include "hkl.h" // for HklParameter, etc
G_BEGIN_DECLS
typedef struct _HklAxis HklAxis;
typedef struct _HklRotationWithOrigin HklRotationWithOrigin;
typedef struct _HklTranslation HklTranslation;
struct _HklAxis {
HklParameter parameter;
HklVector axis_v;
HklQuaternion q; /* internal */
};
struct _HklRotationWithOrigin {
HklAxis axis;
HklVector origin;
};
struct _HklTranslation {
HklParameter parameter;
HklVector axis_v;
};
extern HklParameter *hkl_parameter_new_rotation(const char* name,
HklVector const *axis_v,
const HklUnit *punit);
extern HklParameter *hkl_parameter_new_rotation_with_origin(const char* name,
const HklVector *axis_v,
const HklVector *origin,
const HklUnit *punit);
extern HklParameter *hkl_parameter_new_translation(const char *name,
const HklVector *axis_v,
const HklUnit *punit);
G_END_DECLS
#endif /* __HKL_AXIS_PRIVATE_H__ */
hkl-5.0.0.2569/hkl/hkl-geometry.c 0000644 0001751 0001751 00000076471 13447477011 016500 0 ustar 00picca picca 0000000 0000000 /* This file is part of the hkl library.
*
* The hkl library 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.
*
* The hkl library 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 the hkl library. If not, see .
*
* Copyright (C) 2003-2019 Synchrotron SOLEIL
* L'Orme des Merisiers Saint-Aubin
* BP 48 91192 GIF-sur-YVETTE CEDEX
*
* Authors: Picca Frédéric-Emmanuel
*/
#include // for alloca
#include // for gsl_sf_angle_restrict_symm
#include // for gsl_isnan
#include // for fabs, M_PI
#include // for va_arg, va_end, va_list, etc
#include // for size_t
#include // for fprintf, FILE, stderr
#include // for free, exit, realloc
#include // for NULL, strcmp, memcpy
#include // for uint
#include "hkl-factory-private.h"
#include "hkl-axis-private.h" // for HklAxis, etc
#include "hkl-detector-private.h"
#include "hkl-geometry-private.h" // for _HklGeometry, etc
#include "hkl-interval-private.h" // for HklInterval
#include "hkl-macros-private.h" // for HKL_MALLOC
#include "hkl-parameter-private.h" // for _HklParameter, etc
#include "hkl-quaternion-private.h" // for _HklQuaternion, etc
#include "hkl-source-private.h" // for HklSource, hkl_source_init
#include "hkl-unit-private.h" // for HklUnit, hkl_unit_factor
#include "hkl-vector-private.h" // for HklVector, HklQuaternion, etc
#include "hkl.h" // for HklGeometry, etc
#include "hkl/ccan/container_of/container_of.h" // for container_of
#include "hkl/ccan/darray/darray.h" // for darray_foreach, darray_item, etc
/*
* Try to add a axis to the axes list,
* if a identical axis is present in the list return it
* else create a new on and add it to the list.
* die if try to add an axis with the same name but a different axis_v
*/
static size_t hkl_geometry_add_axis(HklGeometry *self, const HklParameter *axis)
{
uint i = 0;
HklParameter **parameter;
/* check if an axis with the same name is on the axis list */
darray_foreach(parameter, self->axes){
if(!strcmp((*parameter)->name, axis->name)){
if (hkl_parameter_transformation_cmp(*parameter, axis)){
fprintf(stderr,
"can not add two axis with the same name \"%s\" but not compatible transformation",
axis->name);
hkl_parameter_fprintf(stderr, *parameter);
hkl_parameter_fprintf(stderr, axis);
exit(128);
}else{
return i;
}
}
++i;
}
/* no so create and add it to the list */
darray_append(self->axes, hkl_parameter_new_copy(axis));
return darray_size(self->axes) - 1;
}
/*******************/
/* HklHolderConfig */
/*******************/
static struct HklHolderConfig *hkl_holder_config_new(void)
{
struct HklHolderConfig *self;
self = HKL_MALLOC(struct HklHolderConfig);
self->gc = 1;
self->idx = NULL;
self->len = 0;
return self;
}
static struct HklHolderConfig *hkl_holder_config_ref(struct HklHolderConfig *self)
{
if(!self)
return NULL;
self->gc++;
return self;
}
static void hkl_holder_config_unref(struct HklHolderConfig *self)
{
if(!self)
return;
if(--self->gc)
return;
free(self->idx);
free(self);
}
/*************/
/* HklHolder */
/*************/
static HklHolder *hkl_holder_new(HklGeometry *geometry)
{
static HklQuaternion q0 = {{1, 0, 0, 0}};
HklHolder *self = HKL_MALLOC(HklHolder);
self->config = hkl_holder_config_new();
self->geometry = geometry;
self->q = q0;
return self;
}
static HklHolder *hkl_holder_new_copy(HklHolder *src, HklGeometry *geometry)
{
HklHolder *self = HKL_MALLOC(HklHolder);
self->config = hkl_holder_config_ref(src->config);
self->geometry = geometry;
self->q = src->q;
return self;
}
static void hkl_holder_free(HklHolder *self)
{
hkl_holder_config_unref(self->config);
free(self);
}
static void hkl_holder_update(HklHolder *self)
{
static HklQuaternion q0 = {{1, 0, 0, 0}};
size_t i;
self->q = q0;
/*
* The initial meaning of hkl_holder_update was to compute the
* global rotation of the holder. The first holder contained
* only centered rotations. Now that we have added also
* translation, we stop this computation at the first non
* rotation axis
*
* The right think to do should be to add an
* HklVector hkl_holder_apply_transformation(const Hklholder, const HklVector *vector)
* for every kind of transformation (translation, rotation, etc...)
*/
for(i=0; iconfig->len; ++i){
const HklParameter *p;
const HklQuaternion *q;
p = darray_item(self->geometry->axes, self->config->idx[i]);
q = hkl_parameter_quaternion_get(p);
if(NULL == q)
break;
else
hkl_quaternion_times_quaternion(&self->q, q);
}
}
static HklParameter * hkl_holder_add_axis_if_not_present(const HklHolder *self, int idx)
{
size_t i;
HklParameter *res = NULL;
/* check if the axis was already in the geometry */
for(i=0; iconfig->len; i++)
if (idx == self->config->idx[i])
return NULL;
res = darray_item(self->geometry->axes, idx);
self->config->idx = realloc(self->config->idx, sizeof(*self->config->idx) * (self->config->len + 1));
self->config->idx[self->config->len++] = idx;
return res;
}
HklParameter *hkl_holder_add_rotation(HklHolder *self,
const char *name,
double x, double y, double z,
const HklUnit *punit)
{
HklVector axis_v = {{x, y, z}};
HklParameter *axis = hkl_parameter_new_rotation(name, &axis_v, punit);
int idx = hkl_geometry_add_axis(self->geometry, axis);
hkl_parameter_free(axis);
return hkl_holder_add_axis_if_not_present(self, idx);
}
HklParameter *hkl_holder_add_rotation_with_origin(HklHolder *self,
const char *name,
double x, double y, double z,
double ox, double oy, double oz,
const HklUnit *punit)
{
HklVector axis_v = {{x, y, z}};
HklVector origin = {{ox, oy, oz}};
HklParameter *axis = hkl_parameter_new_rotation_with_origin(name, &axis_v, &origin, punit);
int idx = hkl_geometry_add_axis(self->geometry, axis);
hkl_parameter_free(axis);
return hkl_holder_add_axis_if_not_present(self, idx);
}
HklParameter *hkl_holder_add_translation(HklHolder *self,
const char *name,
double x, double y, double z,
const HklUnit *punit)
{
HklVector axis_v = {{x, y, z}};
HklParameter *axis = hkl_parameter_new_translation(name, &axis_v, punit);
int idx = hkl_geometry_add_axis(self->geometry, axis);
hkl_parameter_free(axis);
return hkl_holder_add_axis_if_not_present(self, idx);
}
HklVector hkl_holder_transformation_apply(const HklHolder *self,
const HklVector *v)
{
size_t i;
HklVector res = *v;
/* for each axis from the end apply the transformation to the vector */
for(i=0;iconfig->len;i++){
HklParameter *p = darray_item(self->geometry->axes,
self->config->idx[self->config->len - 1 - i]);
res = hkl_parameter_transformation_apply(p, &res);
}
return res;
}
/***************/
/* HklGeometry */
/***************/
const HklGeometryOperations hkl_geometry_operations_defaults = { HKL_GEOMETRY_OPERATIONS_DEFAULTS };
/**
* hkl_geometry_new: (skip)
*
* constructor
*
* Returns:
**/
HklGeometry *hkl_geometry_new(const HklFactory *factory,
const HklGeometryOperations *ops)
{
HklGeometry *g = NULL;
g = HKL_MALLOC(HklGeometry);
g->ops = ops;
g->factory = factory;
hkl_source_init(&g->source, 1.54, 1, 0, 0);
darray_init(g->axes);
darray_init(g->holders);
return g;
}
/**
* hkl_geometry_new_copy: (skip)
* @self:
*
* copy constructor
*
* Returns:
**/
HklGeometry *hkl_geometry_new_copy(const HklGeometry *src)
{
HklGeometry *self = NULL;
HklParameter **axis;
HklHolder **holder;
self = HKL_MALLOC(HklGeometry);
*self = *src;
/* copy the axes */
darray_init(self->axes);
darray_foreach(axis, src->axes){
darray_append(self->axes, hkl_parameter_new_copy(*axis));
}
/* copy the holders */
darray_init(self->holders);
darray_foreach(holder, src->holders){
darray_append(self->holders,
hkl_holder_new_copy(*holder, self));
}
return self;
}
/**
* hkl_geometry_free: (skip)
* @self:
*
* destructor
**/
void hkl_geometry_free(HklGeometry *self)
{
HklParameter **axis;
HklHolder **holder;
darray_foreach(axis, self->axes){
hkl_parameter_free(*axis);
}
darray_free(self->axes);
darray_foreach(holder, self->holders){
hkl_holder_free(*holder);
}
darray_free(self->holders);
free(self);
}
/**
* hkl_geometry_set: (skip)
* @self: the this ptr
* @src: the other #HklGeometry to set from
*
* Set an #HklGeometry from another one.
*
* Returns: TRUE on success, FALSE if an error occurred
**/
int hkl_geometry_set(HklGeometry *self, const HklGeometry *src)
{
size_t i;
hkl_error(self->factory == src->factory);
hkl_error(self->ops == src->ops);
self->source = src->source;
/* copy the axes configuration and mark it as dirty */
for(i=0; iaxes); ++i)
hkl_parameter_init_copy(darray_item(self->axes, i),
darray_item(src->axes, i), NULL);
for(i=0; iholders); ++i)
darray_item(self->holders, i)->q = darray_item(src->holders, i)->q;
return TRUE;
}
/**
* hkl_geometry_axis_names_get:
* @self: the this ptr
*
* get all the axes of the given #HklGeometry
*
* Returns: (type gpointer): array of the axes names.
**/
const darray_string *hkl_geometry_axis_names_get(const HklGeometry *self)
{
return &self->factory->axes;
}
/**
* hkl_geometry_axis_get:
* @self: the this ptr
* @name: the name of the axis your are requesting
* @error: return location for a GError, or NULL
*
* Return value: (allow-none): the parameter corresponding to the axis name.
**/
const HklParameter *hkl_geometry_axis_get(const HklGeometry *self,
const char *name,
GError **error)
{
HklParameter **axis;
hkl_error (error == NULL || *error == NULL);
darray_foreach(axis, self->axes){
if (!strcmp((*axis)->name, name))
return *axis;
}
g_set_error(error,
HKL_GEOMETRY_ERROR,
HKL_GEOMETRY_ERROR_AXIS_GET,
"this geometry does not contain this axis \"%s\"",
name);
return NULL;
}
/**
* hkl_geometry_axis_set:
* @self: the this ptr
* @name: the name of the axis to set
* @axis: The #HklParameter to set
* @error: return location for a GError, or NULL
*
* Returns: TRUE on success, FALSE if an error occurred
**/
int hkl_geometry_axis_set(HklGeometry *self, const char *name,
const HklParameter *axis,
GError **error)
{
HklParameter **_axis;
hkl_error (error == NULL || *error == NULL);
if(name != axis->name && strcmp(name, axis->name)){
g_set_error(error,
HKL_GEOMETRY_ERROR,
HKL_GEOMETRY_ERROR_AXIS_SET,
"The axis to set \"%s\" is different from the parameter name \"%s\"\n",
name, axis->name);
return FALSE;
}
darray_foreach(_axis, self->axes){
if (*_axis == axis)
break;
if (!strcmp(axis->name, (*_axis)->name)){
hkl_parameter_init_copy(*_axis, axis, NULL);
break;
}
}
hkl_geometry_update(self);
return TRUE;
}
/**
* hkl_geometry_wavelength_get:
* @self: the this ptr
* @unit_type: the unit type (default or user) of the returned value
*
* Get the wavelength of the HklGeometry
*
* Returns: the wavelength
**/
double hkl_geometry_wavelength_get(const HklGeometry *self,
HklUnitEnum unit_type)
{
/* for now there is no unit convertion but the unit_type is
* there */
return self->source.wave_length;
}
/**
* hkl_geometry_wavelength_set:
* @self:
* @wavelength:
* @unit_type: the unit type (default or user) of the returned value
* @error: return location for a GError, or NULL
*
* Set the wavelength of the geometry
*
* Returns: TRUE on success, FALSE if an error occurred
**/
int hkl_geometry_wavelength_set(HklGeometry *self, double wavelength,
HklUnitEnum unit_type, GError **error)
{
hkl_error (error == NULL || *error == NULL);
/* for now there is no unit convertion but the unit_type is
* there */
self->source.wave_length = wavelength;
return TRUE;
}
/**
* hkl_geometry_init_geometry: (skip)
* @self: the this ptr
* @src: the #HklGeometry to set from
*
* initilize an HklGeometry
*
* Returns: TRUE on success, FALSE if an error occurred
**/
int hkl_geometry_init_geometry(HklGeometry *self, const HklGeometry *src)
{
return hkl_geometry_set(self, src);
}
/**
* hkl_geometry_add_holder: (skip)
* @self:
*
* add an Holder to the #HklGeometry
*
* Returns:
**/
HklHolder *hkl_geometry_add_holder(HklGeometry *self)
{
HklHolder *holder = hkl_holder_new(self);
darray_append(self->holders, holder);
return holder;
}
/**
* hkl_geometry_update: (skip)
* @self:
*
* update the geometry internal once an Axis values changed
**/
void hkl_geometry_update(HklGeometry *self)
{
HklParameter **axis;
int ko = 0;
darray_foreach(axis, self->axes){
if ((*axis)->changed) {
ko = 1;
break;
}
}
if (ko) {
HklHolder **holder;
darray_foreach(holder, self->holders){
hkl_holder_update(*holder);
}
darray_foreach(axis, self->axes){
(*axis)->changed = FALSE;
}
}
}
const char *hkl_geometry_name_get(const HklGeometry *self)
{
return hkl_factory_name_get(self->factory);
}
/**
* hkl_geometry_get_axis_idx_by_name: (skip)
* @self:
* @name:
*
* get the index of the axes named @name in the geometry
*
* Returns: -1 if the axis was not found
**/
int hkl_geometry_get_axis_idx_by_name(const HklGeometry *self, const char *name)
{
uint i = 0;
HklParameter **axis;
if (!self || !name)
return -1;
darray_foreach(axis, self->axes){
if (!strcmp((*axis)->name, name))
return i;
++i;
}
return -1;
}
/**
* hkl_geometry_get_axis_by_name:
* @self:
* @name:
*
* get an #HklAxis using its name
*
* Returns: (transfer none):
**/
HklParameter *hkl_geometry_get_axis_by_name(HklGeometry *self, const char *name)
{
HklParameter **axis;
darray_foreach(axis, self->axes){
if (!strcmp((*axis)->name, name))
return (*axis);
}
return NULL;
}
/**
* hkl_geometry_axis_values_get:
* @self: the this ptr
* @values: (array length=n_values): the values to get
* @n_values: the size of the values array.
* @unit_type: the unit type (default or user) of the returned value
*
* fill the values array with the #HklGeometry axes.
**/
void hkl_geometry_axis_values_get(const HklGeometry *self,
double values[], size_t n_values,
HklUnitEnum unit_type)
{
size_t i = 0;
HklParameter **axis;
g_return_if_fail (n_values == darray_size(self->axes));
darray_foreach(axis, self->axes){
values[i++] = hkl_parameter_value_get(*axis, unit_type);
}
}
/**
* hkl_geometry_axis_values_set:
* @self: the this ptr
* @values: (array length=n_values): the values to set.
* @n_values: the length of the values array.
* @unit_type: the unit type (default or user) of the returned value
* @error: return location for a GError, or NULL
*
* Set the #HklGeometry axes values
*
* Returns: TRUE on success, FALSE if an error occurred
**/
int hkl_geometry_axis_values_set(HklGeometry *self,
double values[], size_t n_values,
HklUnitEnum unit_type,
GError **error)
{
uint i = 0;
HklParameter **axis;
hkl_error (error == NULL || *error == NULL);
g_assert(n_values == darray_size(self->axes));
darray_foreach(axis, self->axes){
if(!hkl_parameter_value_set(*axis, values[i++], unit_type, error)){
g_assert (error == NULL || *error != NULL);
return FALSE;
}
}
g_assert (error == NULL || *error == NULL);
hkl_geometry_update(self);
return TRUE;
}
/**
* hkl_geometry_randomize: (skip)
* @self:
*
* randomize the #HklGeometry
**/
void hkl_geometry_randomize(HklGeometry *self)
{
HklParameter **axis;
darray_foreach(axis, self->axes){
hkl_parameter_randomize(*axis);
}
hkl_geometry_update(self);
}
/**
* hkl_geometry_set_values_v: (skip)
* @self:
* @unit_type: the unit type (default or user) of the returned value
* @error:
* "...:
*
* set the axes values
*
* Returns:
**/
int hkl_geometry_set_values_v(HklGeometry *self, HklUnitEnum unit_type, GError **error, ...)
{
va_list ap;
HklParameter **axis;
hkl_error (error == NULL || *error == NULL);
va_start(ap, error);
darray_foreach(axis, self->axes){
if(!hkl_parameter_value_set(*axis,
va_arg(ap, double),
unit_type, error)){
g_assert (error == NULL || *error != NULL);
va_end(ap);
hkl_geometry_update(self);
return FALSE;
}
}
g_assert (error == NULL || *error == NULL);
va_end(ap);
hkl_geometry_update(self);
return TRUE;
}
/**
* hkl_geometry_distance:
* @self: the this ptr
* @ref: the #HklGeometry to compare with
*
* compute the distance between two #HklGeometries
*
* Returns: the distance between the two geometries
**/
double hkl_geometry_distance(const HklGeometry *self,
const HklGeometry *ref)
{
size_t i;
double value1, value2;
double distance = 0.;
if (!self || !ref)
return 0.;
for(i=0; iaxes); ++i){
value1 = darray_item(self->axes, i)->_value;
value2 = darray_item(ref->axes, i)->_value;
distance += fabs(value2 - value1);
}
return distance;
}
/**
* hkl_geometry_distance_orthodromic: (skip)
* @self: the this ptr
* @ref: the reference #HklGeometry to compare with.
*
* Returns: the orthodromique distance
**/
double hkl_geometry_distance_orthodromic(const HklGeometry *self,
const HklGeometry *ref)
{
size_t i;
double value1, value2;
double distance = 0.;
if (!self || !ref)
return 0.;
for(i=0; i