tests/hkl-sample-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 #define SET(_sample, _param, _value) do{                                \
  28                 HklParameter *parameter = hkl_parameter_new_copy(hkl_sample_ ## _param ## _get(_sample)); \
  29                 GError *error;                                          \
  30                 ok(TRUE == hkl_parameter_value_set(parameter, _value, HKL_UNIT_DEFAULT, NULL), __func__); \
  31                 error = NULL;                                           \
  32                 ok(TRUE == hkl_parameter_value_set(parameter, _value, HKL_UNIT_DEFAULT, &error), __func__); \
  33                 ok(error == NULL, __func__);                            \
  34                 ok(TRUE == hkl_sample_ ## _param ## _set(_sample, parameter, NULL), __func__); \
  35                 ok(TRUE == hkl_sample_ ## _param ## _set(_sample, parameter, &error), __func__); \
  36                 ok(error == NULL, __func__);                            \
  37                 hkl_parameter_free(parameter);                          \
  38         }while(0)
  39
  40 #define SET_UX_UY_UZ(_sample, _ux, _uy, _uz) do{        \
  41         SET(_sample, ux, _ux);\
  42         SET(_sample, uy, _uy);\
  43         SET(_sample, uz, _uz);\
  44 }while(0)
  45
  46 #define CHECK(_sample, _param, _value) do{                              \
  47                 is_double(_value,                                       \
  48                           hkl_parameter_value_get(hkl_sample_## _param ## _get(sample), HKL_UNIT_DEFAULT), \
  49                           HKL_EPSILON, __func__);                       \
  50         }while(0)
  51
  52 #define CHECK_UX_UY_UZ(_sample, _ux, _uy, _uz) do{      \
  53                 CHECK(_sample, ux, _ux);                \
  54                 CHECK(_sample, uy, _uy);                \
  55                 CHECK(_sample, uz, _uz);                \
  56         }while(0)
  57
  58
  59 static void new(void)
  60 {
  61         HklSample *sample;
  62
  63         sample = hkl_sample_new("test");
  64
  65         hkl_sample_free(sample);
  66 }
  67
  68 static void add_reflection(void)
  69 {
  70         HklDetector *detector;
  71         const HklFactory *factory;
  72         HklGeometry *geometry;
  73         HklSample *sample;
  74         HklSampleReflection *ref;
  75
  76         factory = hkl_factory_get_by_name("E4CV", NULL);
  77         geometry = hkl_factory_create_new_geometry(factory);
  78
  79         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  80
  81         sample = hkl_sample_new("test");
  82
  83         ok(hkl_sample_n_reflections_get(sample) == 0, __func__);
  84         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
  85         hkl_sample_add_reflection(sample, ref);
  86         ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
  87
  88         /* we can not add two times the same reflection */
  89         hkl_sample_add_reflection(sample, ref);
  90         ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
  91
  92         hkl_sample_free(sample);
  93         hkl_detector_free(detector);
  94         hkl_geometry_free(geometry);
  95 }
  96
  97 static void get_reflection(void)
  98 {
  99         HklDetector *detector;
 100         const HklFactory *factory;
 101         HklGeometry *geometry;
 102         HklSample *sample;
 103         HklSampleReflection *ref;
 104         HklSampleReflection *ref2;
 105
 106         factory = hkl_factory_get_by_name("E4CV", NULL);
 107         geometry = hkl_factory_create_new_geometry(factory);
 108
 109         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 110
 111         sample = hkl_sample_new("test");
 112
 113         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 114         hkl_sample_add_reflection(sample, ref);
 115         ref2 = hkl_sample_reflections_first_get(sample);
 116         ok(0 == !ref, __func__);
 117         ok(ref == ref2, __func__);
 118         ok(NULL == hkl_sample_reflections_next_get(sample, ref2), __func__);
 119
 120         ref = hkl_sample_reflection_new(geometry, detector, -1, 0, 0, NULL);
 121         hkl_sample_add_reflection(sample, ref);
 122         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
 123         hkl_sample_add_reflection(sample, ref);
 124
 125         hkl_sample_free(sample);
 126         hkl_detector_free(detector);
 127         hkl_geometry_free(geometry);
 128 }
 129
 130 static void del_reflection(void)
 131 {
 132         HklDetector *detector;
 133         const HklFactory *factory;
 134         HklGeometry *geometry;
 135         HklSample *sample;
 136         HklSampleReflection *ref;
 137
 138         factory = hkl_factory_get_by_name("E4CV", NULL);
 139         geometry = hkl_factory_create_new_geometry(factory);
 140
 141         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 142
 143         sample = hkl_sample_new("test");
 144
 145         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 146         hkl_sample_add_reflection(sample, ref);
 147         ok(hkl_sample_n_reflections_get(sample) == 1, __func__);
 148         hkl_sample_del_reflection(sample, ref);
 149         ok(hkl_sample_n_reflections_get(sample) == 0, __func__);
 150         ok (NULL == hkl_sample_reflections_first_get(sample), __func__);
 151
 152         hkl_sample_free(sample);
 153         hkl_detector_free(detector);
 154         hkl_geometry_free(geometry);
 155 }
 156
 157 static void set_ux_uy_uz(void)
 158 {
 159         HklSample *sample;
 160
 161         sample = hkl_sample_new("test");
 162
 163         SET_UX_UY_UZ(sample, 1 * HKL_DEGTORAD, 2 * HKL_DEGTORAD, 3 * HKL_DEGTORAD);
 164         CHECK_UX_UY_UZ(sample, 1 * HKL_DEGTORAD, 2 * HKL_DEGTORAD, 3 * HKL_DEGTORAD);
 165
 166         hkl_sample_free(sample);
 167 }
 168
 169 static void set_UB(void)
 170 {
 171         GError *error;
 172         HklSample *sample;
 173         const HklMatrix *_UB;
 174         HklMatrix *UB = hkl_matrix_new_full(HKL_TAU/1.54, 0., 0.,
 175                                             0., 0., HKL_TAU/1.54,
 176                                             0., -HKL_TAU/1.54, 0.);
 177         HklMatrix *U = hkl_matrix_new_full(1., 0., 0.,
 178                                            0., 0., 1.,
 179                                            0.,-1., 0.);
 180
 181         HklMatrix *UB_wrong = hkl_matrix_new_full(0., 0., 0.,
 182                                                   0., 0., 0.,
 183                                                   0., 0., 0.);
 184
 185         sample = hkl_sample_new("test");
 186
 187         /* check that reading and writing the current UB works */
 188         _UB = hkl_sample_UB_get(sample);
 189         ok(TRUE == hkl_sample_UB_set(sample, _UB, NULL), __func__);
 190         error = NULL;
 191         ok(TRUE == hkl_sample_UB_set(sample, _UB, &error), __func__);
 192         ok(error == NULL, __func__);
 193
 194         CHECK_UX_UY_UZ(sample, 0., 0., 0.);
 195
 196         /* set a new valid UB matrix */
 197         error = NULL;
 198         ok(TRUE == hkl_sample_UB_set(sample, UB, NULL), __func__);
 199         ok(TRUE == hkl_sample_UB_set(sample, UB, &error), __func__);
 200         ok(error == NULL, __func__);
 201         is_matrix(U, hkl_sample_U_get(sample), __func__);
 202
 203         CHECK_UX_UY_UZ(sample, -90. * HKL_DEGTORAD, 0., 0.);
 204
 205         /* set a non-valid UB matrix */
 206         error = NULL;
 207         ok(FALSE == hkl_sample_UB_set(sample, UB_wrong, &error), __func__);
 208         ok(error != NULL, __func__);
 209         g_clear_error(&error);
 210         is_matrix(U, hkl_sample_U_get(sample), __func__);
 211
 212         hkl_sample_free(sample);
 213         hkl_matrix_free(UB_wrong);
 214         hkl_matrix_free(U);
 215         hkl_matrix_free(UB);
 216 }
 217
 218 static void compute_UB_busing_levy(void)
 219 {
 220         GError *error;
 221         HklDetector *detector;
 222         const HklFactory *factory;
 223         HklGeometry *geometry;
 224         HklSample *sample;
 225         HklSampleReflection *r0, *r1, *r2, *r3;
 226         HklMatrix *m_I = hkl_matrix_new_full(1,0,0,
 227                                              0,1,0,
 228                                              0, 0, 1);
 229         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 230                                                0., 0., 1.,
 231                                                0.,-1., 0.);
 232
 233         factory = hkl_factory_get_by_name("E4CV", NULL);
 234         geometry = hkl_factory_create_new_geometry(factory);
 235
 236         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 237
 238         sample = hkl_sample_new("test");
 239
 240         /* first test */
 241         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
 242         r0 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
 243         hkl_sample_add_reflection(sample, r0);
 244
 245         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., -90., 60.), __func__);
 246         r1 = hkl_sample_reflection_new(geometry, detector, -1, 0, 0, NULL);
 247         hkl_sample_add_reflection(sample, r1);
 248
 249         ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r0, r1, NULL), __func__);
 250         is_matrix(m_I, hkl_sample_U_get(sample), __func__);
 251
 252         error = NULL;
 253         ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r0, r1, &error), __func__);
 254         ok(error == NULL, __func__);
 255         is_matrix(m_I, hkl_sample_U_get(sample), __func__);
 256
 257         CHECK_UX_UY_UZ(sample, 0., 0., 0.);
 258
 259         /* second test */
 260         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
 261         r2 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 262         hkl_sample_add_reflection(sample, r2);
 263
 264         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 180., 60.), __func__);
 265         r3 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
 266         hkl_sample_add_reflection(sample, r3);
 267
 268         ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r2, r3, NULL), __func__);
 269         is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
 270
 271         error = NULL;
 272         ok(TRUE == hkl_sample_compute_UB_busing_levy(sample, r2, r3, &error), __func__);
 273         ok(error == NULL, __func__);
 274         is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
 275
 276         CHECK_UX_UY_UZ(sample, -90. * HKL_DEGTORAD, 0., 0.);
 277
 278         /* failling test */
 279         ok(FALSE == hkl_sample_compute_UB_busing_levy(sample, r0, r0, NULL), __func__);
 280
 281         error = NULL;
 282         ok(FALSE == hkl_sample_compute_UB_busing_levy(sample, r0, r0, &error), __func__);
 283         ok(error != NULL, __func__);
 284         g_clear_error(&error);
 285         is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
 286
 287         hkl_sample_free(sample);
 288         hkl_detector_free(detector);
 289         hkl_geometry_free(geometry);
 290         hkl_matrix_free(m_ref);
 291         hkl_matrix_free(m_I);
 292 }
 293
 294 static void affine(void)
 295 {
 296         GError *error;
 297         double a, b, c, alpha, beta, gamma;
 298         const HklFactory *factory;
 299         HklDetector *detector;
 300         HklGeometry *geometry;
 301         HklSample *sample;
 302         HklLattice *lattice;
 303         HklSampleReflection *ref;
 304         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 305                                                0., 1., 0.,
 306                                                0., 0., 1.);
 307
 308         factory = hkl_factory_get_by_name("E4CV", NULL);
 309         geometry = hkl_factory_create_new_geometry(factory);
 310
 311         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 312
 313         sample = hkl_sample_new("test");
 314         lattice = hkl_lattice_new(1, 5, 4,
 315                                   92 * HKL_DEGTORAD,
 316                                   81 * HKL_DEGTORAD,
 317                                   90 * HKL_DEGTORAD,
 318                                   NULL);
 319         hkl_sample_lattice_set(sample, lattice);
 320         hkl_lattice_free(lattice);
 321
 322         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
 323         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 324         hkl_sample_add_reflection(sample, ref);
 325
 326         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
 327         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
 328         hkl_sample_add_reflection(sample, ref);
 329
 330         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
 331         ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
 332         hkl_sample_add_reflection(sample, ref);
 333
 334         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
 335         ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
 336         hkl_sample_add_reflection(sample, ref);
 337
 338         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
 339         ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
 340         hkl_sample_add_reflection(sample, ref);
 341
 342
 343         ok(TRUE == hkl_sample_affine(sample, NULL), __func__);
 344
 345         error = NULL;
 346         ok(TRUE == hkl_sample_affine(sample, &error), __func__);
 347         ok(error == NULL, __func__);
 348
 349         hkl_lattice_get(hkl_sample_lattice_get(sample),
 350                         &a, &b, &c, &alpha, &beta, &gamma, HKL_UNIT_DEFAULT);
 351
 352         is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
 353         is_double(1.54, a, HKL_EPSILON, __func__);
 354         is_double(1.54, b, HKL_EPSILON, __func__);
 355         is_double(1.54, c, HKL_EPSILON, __func__);
 356         is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
 357         is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
 358         is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
 359         CHECK_UX_UY_UZ(sample, 0., 0., 0.);
 360
 361         hkl_sample_free(sample);
 362         hkl_detector_free(detector);
 363         hkl_geometry_free(geometry);
 364         hkl_matrix_free(m_ref);
 365 }
 366
 367 static void get_reflections_xxx_angle(void)
 368 {
 369         HklDetector *detector;
 370         const HklFactory *factory;
 371         HklGeometry *geometry;
 372         HklSample *sample;
 373         HklLattice *lattice;
 374         HklSampleReflection *r0, *r1, *r2, *r3, *r4;
 375
 376         factory = hkl_factory_get_by_name("E4CV", NULL);
 377         geometry = hkl_factory_create_new_geometry(factory);
 378
 379         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 380
 381         sample = hkl_sample_new("test");
 382         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 383                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD,
 384                                   NULL);
 385         hkl_sample_lattice_set(sample, lattice);
 386         hkl_lattice_free(lattice);
 387
 388         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
 389         r0 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 390         hkl_sample_add_reflection(sample, r0);
 391
 392         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
 393         r1 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
 394         hkl_sample_add_reflection(sample, r1);
 395
 396         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
 397         r2 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
 398         hkl_sample_add_reflection(sample, r2);
 399
 400         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
 401         r3 = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
 402         hkl_sample_add_reflection(sample, r3);
 403
 404         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
 405         r4 = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
 406         hkl_sample_add_reflection(sample, r4);
 407
 408         is_double(90 * HKL_DEGTORAD,
 409                   hkl_sample_get_reflection_theoretical_angle(sample, r0, r1),
 410                   HKL_EPSILON, __func__);
 411
 412         is_double(90 * HKL_DEGTORAD,
 413                   hkl_sample_get_reflection_measured_angle(sample, r0, r1),
 414                   HKL_EPSILON, __func__);
 415
 416         is_double(90 * HKL_DEGTORAD,
 417                   hkl_sample_get_reflection_theoretical_angle(sample, r1, r2),
 418                   HKL_EPSILON, __func__);
 419
 420         is_double(90 * HKL_DEGTORAD,
 421                   hkl_sample_get_reflection_measured_angle(sample, r1, r2),
 422                   HKL_EPSILON, __func__);
 423
 424         hkl_sample_free(sample);
 425         hkl_detector_free(detector);
 426         hkl_geometry_free(geometry);
 427 }
 428
 429 static void reflection_set_geometry(void)
 430 {
 431         double a, b, c, alpha, beta, gamma;
 432         HklDetector *detector;
 433         const HklFactory *factory;
 434         HklGeometry *geometry;
 435         HklSample *sample;
 436         HklLattice *lattice;
 437         HklSampleReflection *ref;
 438         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 439                                                0., 1., 0.,
 440                                                0., 0., 1.);
 441
 442         factory = hkl_factory_get_by_name("E4CV", NULL);
 443         geometry = hkl_factory_create_new_geometry(factory);
 444
 445         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 446
 447         sample = hkl_sample_new("test");
 448         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 449                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD,
 450                                   NULL);
 451         hkl_sample_lattice_set(sample, lattice);
 452         hkl_lattice_free(lattice);
 453
 454         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.), __func__);
 455         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0, NULL);
 456         hkl_sample_add_reflection(sample, ref);
 457
 458         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 90., 0., 60.), __func__);
 459         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0, NULL);
 460         hkl_sample_add_reflection(sample, ref);
 461
 462         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.), __func__);
 463         ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1, NULL);
 464         hkl_sample_add_reflection(sample, ref);
 465
 466         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 60., 60., 60., 60.), __func__);
 467         ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946, NULL);
 468         hkl_sample_add_reflection(sample, ref);
 469
 470         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 46., 45., 45., 60.), __func__);
 471         ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252, NULL);
 472         hkl_sample_add_reflection(sample, ref);
 473
 474         /* correct the last reflection so the sample affinement must be ok. */
 475         ok(TRUE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 45., 45., 60.), __func__);
 476         hkl_sample_reflection_geometry_set(ref, geometry);
 477
 478         ok(TRUE == hkl_sample_affine(sample, NULL), __func__);
 479         hkl_lattice_get(hkl_sample_lattice_get(sample),
 480                         &a, &b, &c, &alpha, &beta, &gamma,
 481                         HKL_UNIT_DEFAULT);
 482
 483         is_matrix(m_ref, hkl_sample_U_get(sample), __func__);
 484         is_double(1.54, a, HKL_EPSILON, __func__);
 485         is_double(1.54, b, HKL_EPSILON, __func__);
 486         is_double(1.54, c, HKL_EPSILON, __func__);
 487         is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
 488         is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
 489         is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
 490         CHECK_UX_UY_UZ(sample, 0., 0., 0.);
 491
 492         hkl_sample_free(sample);
 493         hkl_detector_free(detector);
 494         hkl_geometry_free(geometry);
 495         hkl_matrix_free(m_ref);
 496 }
 497
 498 int main(void)
 499 {
 500         plan(114);
 501
 502         new();
 503         add_reflection();
 504         get_reflection();
 505         del_reflection();
 506         set_ux_uy_uz();
 507         set_UB();
 508         compute_UB_busing_levy();
 509         affine();
 510         get_reflections_xxx_angle();
 511
 512         reflection_set_geometry();
 513
 514         return 0;
 515 }