tests/hkl-geometry-t.c

   1 /* This file is part of the hkl library.
   2  *
   3  * The hkl library is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * The hkl library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright (C) 2003-2016 Synchrotron SOLEIL
  17  *                         L'Orme des Merisiers Saint-Aubin
  18  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  19  *
  20  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  21  */
  22 #include "hkl.h"
  23 #include <tap/basic.h>
  24 #include <tap/float.h>
  25 #include <tap/hkl-tap.h>
  26
  27 /* BEWARE THESE TESTS ARE DEALING WITH HKL INTERNALS WHICH EXPOSE A
  28  * NON PUBLIC API WHICH ALLOW TO SHOOT YOURSELF IN YOUR FOOT */
  29
  30 #include "hkl/ccan/container_of/container_of.h"
  31 #include "hkl-axis-private.h" /* temporary */
  32 #include "hkl-geometry-private.h"
  33
  34 static void add_holder(void)
  35 {
  36         HklGeometry *g = NULL;
  37         HklHolder *holder = NULL;
  38
  39         g = hkl_geometry_new(NULL);
  40         is_int(0, darray_size(g->holders), __func__);
  41
  42         holder = hkl_geometry_add_holder(g);
  43         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
  44         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
  45         is_int(1, darray_size(g->holders), __func__);
  46
  47         holder = hkl_geometry_add_holder(g);
  48         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
  49         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
  50         is_int(2, darray_size(g->holders), __func__);
  51
  52         ok(holder == darray_item(g->holders, 1), __func__);
  53
  54         hkl_geometry_free(g);
  55 }
  56
  57 static void get_axis(void)
  58 {
  59         int res = TRUE;
  60         HklGeometry *g = NULL;
  61         HklHolder *holder = NULL;
  62         const HklParameter *axis0;
  63         GError *error;
  64
  65         g = hkl_geometry_new(NULL);
  66
  67         holder = hkl_geometry_add_holder(g);
  68         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
  69         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
  70
  71         holder = hkl_geometry_add_holder(g);
  72         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
  73         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
  74
  75         /* check the private API */
  76         res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "A"));
  77         res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "B"));
  78         res &= DIAG(0 == !hkl_geometry_get_axis_by_name(g, "C"));
  79         res &= DIAG(1 == !hkl_geometry_get_axis_by_name(g, "D"));
  80
  81         /* check the public API */
  82         /* get */
  83         res &= DIAG(NULL != hkl_geometry_axis_get(g, "A", NULL));
  84         res &= DIAG(NULL == hkl_geometry_axis_get(g, "D", NULL));
  85         error = NULL;
  86         res &= DIAG(NULL != hkl_geometry_axis_get(g, "A", &error));
  87         res &= DIAG(error == NULL);
  88         res &= DIAG(NULL == hkl_geometry_axis_get(g, "D", &error));
  89         res &= DIAG(error != NULL);
  90         g_clear_error(&error);
  91
  92         /* set */
  93         axis0 = hkl_geometry_axis_get(g, "A", NULL);
  94         res &= DIAG(TRUE == hkl_geometry_axis_set(g, "A", axis0, NULL));
  95         res &= DIAG(FALSE == hkl_geometry_axis_set(g, "B", axis0, NULL));
  96
  97         error = NULL;
  98         res &= DIAG(hkl_geometry_axis_set(g, "A", axis0, &error));
  99         res &= DIAG(error == NULL);
 100
 101         res &= DIAG(FALSE == hkl_geometry_axis_set(g, "B", axis0, &error));
 102         res &= DIAG(error != NULL);
 103
 104         ok(res, __func__);
 105
 106         g_clear_error(&error);
 107
 108         hkl_geometry_free(g);
 109 }
 110
 111 static void update(void)
 112 {
 113         int res = TRUE;
 114         HklGeometry *g = NULL;
 115         HklHolder *holder = NULL;
 116         HklAxis *axis1;
 117
 118         g = hkl_geometry_new(NULL);
 119
 120         holder = hkl_geometry_add_holder(g);
 121         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 122         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 123
 124         holder = hkl_geometry_add_holder(g);
 125         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 126         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 127
 128         axis1 = container_of(hkl_geometry_get_axis_by_name(g, "B"), HklAxis, parameter);
 129         res &= DIAG(hkl_parameter_value_set(&axis1->parameter, M_PI_2, HKL_UNIT_DEFAULT, NULL));
 130         /* now axis1 is dirty */
 131         ok(TRUE == axis1->parameter.changed, __func__);
 132
 133         hkl_geometry_update(g);
 134         holder = darray_item(g->holders, 0);
 135         is_double(1./sqrt(2), holder->q.data[0], HKL_EPSILON, __func__);
 136         is_double(1./sqrt(2), holder->q.data[1], HKL_EPSILON, __func__);
 137         is_double(.0, holder->q.data[2], HKL_EPSILON, __func__);
 138         is_double(.0, holder->q.data[3], HKL_EPSILON, __func__);
 139         /* now axis1 is clean */
 140         res &= DIAG(FALSE == axis1->parameter.changed);
 141
 142         ok(res, __func__);
 143
 144         hkl_geometry_free(g);
 145 }
 146
 147 static void set(void)
 148 {
 149         HklGeometry *g;
 150         HklGeometry *g1;
 151         HklGeometry *g2;
 152         HklHolder *holder;
 153         HklFactory *fake_factory;
 154
 155         g = hkl_geometry_new(NULL);
 156         holder = hkl_geometry_add_holder(g);
 157         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 158         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 159         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 160
 161         g1 = hkl_geometry_new_copy(g);
 162
 163         /* it is required to use a fake factory, with the public API
 164          * geometry contain always a real factory */
 165         fake_factory = (HklFactory *)0x1;
 166         g2 = hkl_geometry_new(fake_factory);
 167         holder = hkl_geometry_add_holder(g);
 168         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 169         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 170
 171         ok(hkl_geometry_set(g, g1), __func__);
 172
 173         hkl_geometry_free(g2);
 174         hkl_geometry_free(g1);
 175         hkl_geometry_free(g);
 176 }
 177
 178 static void axis_values_get_set(void)
 179 {
 180         unsigned int i;
 181         HklGeometry *g;
 182         HklHolder *holder;
 183         static double set_1[] = {1, 1, 1};
 184         static double set_10[] = {10, 10, 10};
 185         double values[3];
 186         GError *error;
 187
 188         g = hkl_geometry_new(NULL);
 189         holder = hkl_geometry_add_holder(g);
 190         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 191         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 192         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 193
 194         /* check set DEFAULT unit */
 195         error = NULL;
 196         ok(TRUE == hkl_geometry_axis_values_set(g, set_1, ARRAY_SIZE(set_1), HKL_UNIT_DEFAULT, NULL), __func__);
 197         ok(TRUE == hkl_geometry_axis_values_set(g, set_1, ARRAY_SIZE(set_1), HKL_UNIT_DEFAULT, &error), __func__);
 198         ok(error == NULL, __func__);
 199         for(i=0; i<ARRAY_SIZE(set_1); ++i)
 200                 is_double(set_1[i], hkl_parameter_value_get(darray_item(g->axes, i), HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
 201
 202         /* check get DEFAULT unit */
 203         hkl_geometry_axis_values_get(g, values, 3, HKL_UNIT_DEFAULT);
 204         for(i=0; i<ARRAY_SIZE(set_1); ++i)
 205                 is_double(set_1[i], values[i], HKL_EPSILON, __func__);
 206
 207         /* check set USER unit */
 208         ok(TRUE == hkl_geometry_axis_values_set(g, set_10, ARRAY_SIZE(set_10), HKL_UNIT_USER, NULL), __func__);
 209         ok(TRUE == hkl_geometry_axis_values_set(g, set_10, ARRAY_SIZE(set_10), HKL_UNIT_USER, &error), __func__);
 210         ok(error == NULL, __func__);
 211         for(i=0; i<ARRAY_SIZE(set_10); ++i)
 212                 is_double(set_10[i] * HKL_DEGTORAD, hkl_parameter_value_get(darray_item(g->axes, i), HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
 213
 214         /* check get USER unit */
 215         hkl_geometry_axis_values_get(g, values, 3, HKL_UNIT_USER);
 216         for(i=0; i<ARRAY_SIZE(set_10); ++i)
 217                 is_double(set_10[i], values[i], HKL_EPSILON, __func__);
 218
 219         hkl_geometry_free(g);
 220 }
 221
 222 static void distance(void)
 223 {
 224         int res = TRUE;
 225         HklGeometry *g1 = NULL;
 226         HklGeometry *g2 = NULL;
 227         HklHolder *holder = NULL;
 228
 229         g1 = hkl_geometry_new(NULL);
 230         holder = hkl_geometry_add_holder(g1);
 231         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 232         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 233         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 234
 235         g2 = hkl_geometry_new_copy(g1);
 236
 237         res &= DIAG(hkl_geometry_set_values_v(g1, HKL_UNIT_DEFAULT, NULL, 0., 0., 0.));
 238         res &= DIAG(hkl_geometry_set_values_v(g2, HKL_UNIT_DEFAULT, NULL, 1., 1., 1.));
 239         is_double(3., hkl_geometry_distance(g1, g2), HKL_EPSILON, __func__);
 240
 241         ok(res, __func__);
 242
 243         hkl_geometry_free(g1);
 244         hkl_geometry_free(g2);
 245 }
 246
 247 static void is_valid(void)
 248 {
 249         int res = TRUE;
 250         HklGeometry *geom = NULL;
 251         HklHolder *holder = NULL;
 252
 253         geom = hkl_geometry_new(NULL);
 254         holder = hkl_geometry_add_holder(geom);
 255         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 256         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 257         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 258
 259         res &= DIAG(hkl_geometry_set_values_v(geom, HKL_UNIT_DEFAULT, NULL, 0., 0., 0.));
 260         res &= DIAG(TRUE == hkl_geometry_is_valid(geom));
 261
 262         res &= DIAG(hkl_geometry_set_values_v(geom, HKL_UNIT_DEFAULT, NULL, -181. * HKL_DEGTORAD, 0., 0.));
 263         res &= DIAG(TRUE == hkl_geometry_is_valid(geom));
 264
 265         res &= DIAG(hkl_parameter_min_max_set(darray_item(geom->axes, 0),
 266                                               -100 * HKL_DEGTORAD, 100 * HKL_DEGTORAD,
 267                                               HKL_UNIT_DEFAULT, NULL));
 268         res &= DIAG(FALSE == hkl_geometry_is_valid(geom));
 269
 270         ok(res, __func__);
 271
 272         hkl_geometry_free(geom);
 273 }
 274
 275 static void wavelength(void)
 276 {
 277         HklGeometry *geom = NULL;
 278         GError *error;
 279
 280         geom = hkl_geometry_new(NULL);
 281
 282         is_double(1.54, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
 283
 284         ok(TRUE == hkl_geometry_wavelength_set(geom, 2, HKL_UNIT_DEFAULT, NULL), __func__);
 285         is_double(2, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
 286
 287         error = NULL;
 288         ok(TRUE == hkl_geometry_wavelength_set(geom, 2, HKL_UNIT_DEFAULT, &error), __func__);
 289         ok(error == NULL, __func__);
 290         is_double(2, hkl_geometry_wavelength_get(geom, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
 291
 292         hkl_geometry_free(geom);
 293 }
 294
 295 static void list(void)
 296 {
 297         int i = 0;
 298         int res = TRUE;
 299         HklGeometry *g;
 300         HklGeometryList *list;
 301         const HklGeometryListItem *item;
 302         HklHolder *holder;
 303         static double values[] = {0. * HKL_DEGTORAD, 10 * HKL_DEGTORAD, 30 * HKL_DEGTORAD};
 304
 305         g = hkl_geometry_new(NULL);
 306         holder = hkl_geometry_add_holder(g);
 307         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 308         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 309         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 310
 311         list = hkl_geometry_list_new();
 312
 313         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL, values[0], 0., 0.));
 314         hkl_geometry_list_add(list, g);
 315         is_int(1, hkl_geometry_list_n_items_get(list), __func__);
 316
 317         /* can not add two times the same geometry */
 318         hkl_geometry_list_add(list, g);
 319         is_int(1, hkl_geometry_list_n_items_get(list), __func__);
 320
 321         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL, values[2], 0., 0.));
 322         hkl_geometry_list_add(list, g);
 323         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL, values[1], 0., 0.));
 324         hkl_geometry_list_add(list, g);
 325         is_int(3, hkl_geometry_list_n_items_get(list), __func__);
 326
 327         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL, values[0], 0., 0.));
 328         hkl_geometry_list_sort(list, g);
 329
 330         HKL_GEOMETRY_LIST_FOREACH(item, list){
 331                 is_double(values[i++],
 332                           hkl_parameter_value_get(darray_item(item->geometry->axes, 0), HKL_UNIT_DEFAULT),
 333                           HKL_EPSILON, __func__);
 334         }
 335
 336         ok(res, __func__);
 337
 338         hkl_geometry_free(g);
 339         hkl_geometry_list_free(list);
 340 }
 341
 342 static void  list_multiply_from_range(void)
 343 {
 344         int res = TRUE;
 345         HklGeometry *g;
 346         HklGeometryList *list;
 347         HklHolder *holder;
 348         HklParameter *axisA, *axisB, *axisC;
 349
 350         g = hkl_geometry_new(NULL);
 351         holder = hkl_geometry_add_holder(g);
 352         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 353         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 354         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 355
 356         axisA = hkl_geometry_get_axis_by_name(g, "A");
 357         axisB = hkl_geometry_get_axis_by_name(g, "B");
 358         axisC = hkl_geometry_get_axis_by_name(g, "C");
 359
 360         res &= DIAG(hkl_parameter_min_max_set(axisA, -190, 190, HKL_UNIT_USER, NULL));
 361         res &= DIAG(hkl_parameter_min_max_set(axisB, -190, 190, HKL_UNIT_USER, NULL));
 362         res &= DIAG(hkl_parameter_min_max_set(axisC, -190, 190, HKL_UNIT_USER, NULL));
 363
 364         list = hkl_geometry_list_new();
 365
 366         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
 367                                               185. * HKL_DEGTORAD, -185. * HKL_DEGTORAD, 190. * HKL_DEGTORAD));
 368         hkl_geometry_list_add(list, g);
 369
 370         hkl_geometry_list_multiply_from_range(list);
 371
 372         ok(res, __func__);
 373
 374         hkl_geometry_free(g);
 375         hkl_geometry_list_free(list);
 376 }
 377
 378 static void  list_remove_invalid(void)
 379 {
 380         int res = TRUE;
 381         HklGeometry *g;
 382         HklGeometryList *list;
 383         HklHolder *holder;
 384         HklParameter *axisA, *axisB, *axisC;
 385
 386         g = hkl_geometry_new(NULL);
 387         holder = hkl_geometry_add_holder(g);
 388         hkl_holder_add_rotation_axis(holder, "A", 1., 0., 0.);
 389         hkl_holder_add_rotation_axis(holder, "B", 1., 0., 0.);
 390         hkl_holder_add_rotation_axis(holder, "C", 1., 0., 0.);
 391
 392         axisA = hkl_geometry_get_axis_by_name(g, "A");
 393         axisB = hkl_geometry_get_axis_by_name(g, "B");
 394         axisC = hkl_geometry_get_axis_by_name(g, "C");
 395
 396         res &= DIAG(hkl_parameter_min_max_set(axisA, -100, 180., HKL_UNIT_USER, NULL));
 397         res &= DIAG(hkl_parameter_min_max_set(axisB, -100., 180., HKL_UNIT_USER, NULL));
 398         res &= DIAG(hkl_parameter_min_max_set(axisC, -100., 180., HKL_UNIT_USER, NULL));
 399
 400         list = hkl_geometry_list_new();
 401
 402         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
 403                                               185. * HKL_DEGTORAD,
 404                                               -185.* HKL_DEGTORAD,
 405                                               185. * HKL_DEGTORAD));
 406         hkl_geometry_list_add(list, g);
 407
 408         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
 409                                               -190. * HKL_DEGTORAD,
 410                                               -190.* HKL_DEGTORAD,
 411                                               -190.* HKL_DEGTORAD));
 412         hkl_geometry_list_add(list, g);
 413
 414         res &= DIAG(hkl_geometry_set_values_v(g, HKL_UNIT_DEFAULT, NULL,
 415                                               180. * HKL_DEGTORAD,
 416                                               180.* HKL_DEGTORAD,
 417                                               180.* HKL_DEGTORAD));
 418         hkl_geometry_list_add(list, g);
 419
 420         is_int(3, hkl_geometry_list_n_items_get(list), __func__);
 421         hkl_geometry_list_remove_invalid(list);
 422         is_int(2, hkl_geometry_list_n_items_get(list), __func__);
 423
 424         ok(res, __func__);
 425
 426         hkl_geometry_free(g);
 427         hkl_geometry_list_free(list);
 428 }
 429
 430 int main(void)
 431 {
 432         plan(50);
 433
 434         add_holder();
 435         get_axis();
 436         update();
 437         set();
 438         axis_values_get_set();
 439         distance();
 440         is_valid();
 441         wavelength();
 442
 443         list();
 444         list_multiply_from_range();
 445         list_remove_invalid();
 446
 447         return 0;
 448 }