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-2013 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
  26 static void new(void)
  27 {
  28         HklSample *sample;
  29
  30         sample = hkl_sample_new("test");
  31
  32         hkl_sample_free(sample);
  33 }
  34
  35 static void add_reflection(void)
  36 {
  37         HklDetector *detector;
  38         const HklFactory *factory;
  39         HklGeometry *geometry;
  40         HklSample *sample;
  41         HklSampleReflection *ref;
  42
  43         factory = hkl_factory_get_by_name("E4CV");
  44         geometry = hkl_factory_create_new_geometry(factory);
  45
  46         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  47         hkl_detector_idx_set(detector, 1);
  48
  49         sample = hkl_sample_new("test");
  50
  51         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
  52         hkl_sample_add_reflection(sample, ref);
  53
  54         /* we can not add two times the same reflection */
  55         hkl_sample_add_reflection(sample, ref);
  56
  57         hkl_sample_free(sample);
  58         hkl_detector_free(detector);
  59         hkl_geometry_free(geometry);
  60 }
  61
  62 static void get_reflection(void)
  63 {
  64         HklDetector *detector;
  65         const HklFactory *factory;
  66         HklGeometry *geometry;
  67         HklSample *sample;
  68         HklSampleReflection *ref;
  69         HklSampleReflection *ref2;
  70
  71         factory = hkl_factory_get_by_name("E4CV");
  72         geometry = hkl_factory_create_new_geometry(factory);
  73
  74         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  75         hkl_detector_idx_set(detector, 1);
  76
  77         sample = hkl_sample_new("test");
  78
  79         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
  80         hkl_sample_add_reflection(sample, ref);
  81         ref2 = hkl_sample_first_reflection_get(sample);
  82         ok(0 == !ref, __func__);
  83         ok(ref == ref2, __func__);
  84         ok(NULL == hkl_sample_next_reflection_get(sample, ref2), __func__);
  85
  86         ref = hkl_sample_reflection_new(geometry, detector, -1, 0, 0);
  87         hkl_sample_add_reflection(sample, ref);
  88         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0);
  89         hkl_sample_add_reflection(sample, ref);
  90
  91         hkl_sample_free(sample);
  92         hkl_detector_free(detector);
  93         hkl_geometry_free(geometry);
  94 }
  95
  96 static void del_reflection(void)
  97 {
  98         HklDetector *detector;
  99         const HklFactory *factory;
 100         HklGeometry *geometry;
 101         HklSample *sample;
 102         HklSampleReflection *ref;
 103
 104         factory = hkl_factory_get_by_name("E4CV");
 105         geometry = hkl_factory_create_new_geometry(factory);
 106
 107         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 108         hkl_detector_idx_set(detector, 1);
 109
 110         sample = hkl_sample_new("test");
 111
 112         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
 113         hkl_sample_add_reflection(sample, ref);
 114         hkl_sample_del_reflection(sample, ref);
 115         ok (NULL == hkl_sample_first_reflection_get(sample), __func__);
 116
 117         hkl_sample_free(sample);
 118         hkl_detector_free(detector);
 119         hkl_geometry_free(geometry);
 120 }
 121
 122 static void  set_UB(void )
 123 {
 124         HklSample *sample;
 125         HklMatrix *UB = hkl_matrix_new_full(HKL_TAU/1.54, 0., 0.,
 126                                             0., 0., HKL_TAU/1.54,
 127                                             0., -HKL_TAU/1.54, 0.);
 128         HklMatrix *U = hkl_matrix_new_full(1., 0., 0.,
 129                                            0., 0., 1.,
 130                                            0.,-1., 0.);
 131
 132         sample = hkl_sample_new("test");
 133
 134         hkl_sample_UB_set(sample, UB);
 135         ok(HKL_TRUE == hkl_matrix_cmp(U,
 136                                       hkl_sample_U_get(sample)), __func__);
 137         is_double(-90. * HKL_DEGTORAD,
 138                   hkl_parameter_value_get(hkl_sample_ux_get(sample)),
 139                   HKL_EPSILON, __func__);
 140         is_double(0.,
 141                   hkl_parameter_value_get(hkl_sample_uy_get(sample)),
 142                   HKL_EPSILON, __func__);
 143         is_double(0.,
 144                   hkl_parameter_value_get(hkl_sample_uz_get(sample)),
 145                   HKL_EPSILON, __func__);
 146
 147         hkl_sample_free(sample);
 148         hkl_matrix_free(U);
 149         hkl_matrix_free(UB);
 150 }
 151
 152 static void compute_UB_busing_levy(void)
 153 {
 154         HklDetector *detector;
 155         const HklFactory *factory;
 156         HklGeometry *geometry;
 157         HklSample *sample;
 158         HklSampleReflection *r0, *r1, *r2, *r3;
 159         HklMatrix *m_I = hkl_matrix_new_full(1,0,0,
 160                                              0,1,0,
 161                                              0, 0, 1);
 162         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 163                                                0., 0., 1.,
 164                                                0.,-1., 0.);
 165
 166         factory = hkl_factory_get_by_name("E4CV");
 167         geometry = hkl_factory_create_new_geometry(factory);
 168
 169         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 170         hkl_detector_idx_set(detector, 1);
 171
 172         sample = hkl_sample_new("test");
 173
 174         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 175         r0 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1);
 176         hkl_sample_add_reflection(sample, r0);
 177
 178         hkl_geometry_set_values_unit_v(geometry, 30., 0., -90., 60.);
 179         r1 = hkl_sample_reflection_new(geometry, detector, -1, 0, 0);
 180         hkl_sample_add_reflection(sample, r1);
 181
 182         hkl_sample_compute_UB_busing_levy(sample, r0, r1);
 183         ok(HKL_TRUE == hkl_matrix_cmp(m_I, hkl_sample_U_get(sample)), __func__);
 184         is_double(0., hkl_parameter_value_get(hkl_sample_ux_get(sample)), HKL_EPSILON, __func__);
 185         is_double(0., hkl_parameter_value_get(hkl_sample_uy_get(sample)), HKL_EPSILON, __func__);
 186         is_double(0., hkl_parameter_value_get(hkl_sample_uz_get(sample)), HKL_EPSILON, __func__);
 187
 188         hkl_geometry_set_values_unit_v(geometry, 30., 0., 90., 60.);
 189         r2 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
 190         hkl_sample_add_reflection(sample, r2);
 191
 192         hkl_geometry_set_values_unit_v(geometry, 30., 0., 180., 60.);
 193         r3 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0);
 194         hkl_sample_add_reflection(sample, r3);
 195
 196         hkl_sample_compute_UB_busing_levy(sample, r2, r3);
 197         ok(HKL_TRUE == hkl_matrix_cmp(m_ref, hkl_sample_U_get(sample)), __func__);
 198         is_double(-90. * HKL_DEGTORAD, hkl_parameter_value_get(hkl_sample_ux_get(sample)), HKL_EPSILON, __func__);
 199         is_double(0., hkl_parameter_value_get(hkl_sample_uy_get(sample)), HKL_EPSILON, __func__);
 200         is_double(0., hkl_parameter_value_get(hkl_sample_uz_get(sample)), HKL_EPSILON, __func__);
 201
 202         hkl_sample_free(sample);
 203         hkl_detector_free(detector);
 204         hkl_geometry_free(geometry);
 205         hkl_matrix_free(m_ref);
 206         hkl_matrix_free(m_I);
 207 }
 208
 209 static void affine(void)
 210 {
 211         double a, b, c, alpha, beta, gamma;
 212         const HklFactory *factory;
 213         HklDetector *detector;
 214         HklGeometry *geometry;
 215         HklSample *sample;
 216         HklLattice *lattice;
 217         HklSampleReflection *ref;
 218         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 219                                                0., 1., 0.,
 220                                                0., 0., 1.);
 221
 222         factory = hkl_factory_get_by_name("E4CV");
 223         geometry = hkl_factory_create_new_geometry(factory);
 224
 225         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 226         hkl_detector_idx_set(detector, 1);
 227
 228         sample = hkl_sample_new("test");
 229         lattice = hkl_lattice_new(1, 5, 4,
 230                                   92 * HKL_DEGTORAD,
 231                                   81 * HKL_DEGTORAD,
 232                                   90 * HKL_DEGTORAD);
 233         hkl_sample_lattice_set(sample, lattice);
 234         hkl_lattice_free(lattice);
 235
 236         hkl_geometry_set_values_unit_v(geometry, 30., 0., 90., 60.);
 237         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
 238         hkl_sample_add_reflection(sample, ref);
 239
 240         hkl_geometry_set_values_unit_v(geometry, 30., 90., 0., 60.);
 241         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0);
 242         hkl_sample_add_reflection(sample, ref);
 243
 244         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 245         ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1);
 246         hkl_sample_add_reflection(sample, ref);
 247
 248         hkl_geometry_set_values_unit_v(geometry, 60., 60., 60., 60.);
 249         ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946);
 250         hkl_sample_add_reflection(sample, ref);
 251
 252         hkl_geometry_set_values_unit_v(geometry, 45., 45., 45., 60.);
 253         ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252);
 254         hkl_sample_add_reflection(sample, ref);
 255
 256         hkl_sample_affine(sample);
 257
 258         hkl_lattice_get(hkl_sample_lattice_get(sample),
 259                         &a, &b, &c, &alpha, &beta, &gamma);
 260
 261         ok(HKL_TRUE == hkl_matrix_cmp(m_ref, hkl_sample_U_get(sample)), __func__);
 262         is_double(1.54, a, HKL_EPSILON, __func__);
 263         is_double(1.54, b, HKL_EPSILON, __func__);
 264         is_double(1.54, c, HKL_EPSILON, __func__);
 265         is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
 266         is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
 267         is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
 268         is_double(0., hkl_parameter_value_get(hkl_sample_ux_get(sample)), HKL_EPSILON, __func__);
 269         is_double(0., hkl_parameter_value_get(hkl_sample_uy_get(sample)), HKL_EPSILON, __func__);
 270         is_double(0., hkl_parameter_value_get(hkl_sample_uz_get(sample)), HKL_EPSILON, __func__);
 271
 272         hkl_sample_free(sample);
 273         hkl_detector_free(detector);
 274         hkl_geometry_free(geometry);
 275         hkl_matrix_free(m_ref);
 276 }
 277
 278 static void get_reflections_xxx_angle(void)
 279 {
 280         HklDetector *detector;
 281         const HklFactory *factory;
 282         HklGeometry *geometry;
 283         HklSample *sample;
 284         HklLattice *lattice;
 285         HklSampleReflection *r0, *r1, *r2, *r3, *r4;
 286
 287         factory = hkl_factory_get_by_name("E4CV");
 288         geometry = hkl_factory_create_new_geometry(factory);
 289
 290         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 291         hkl_detector_idx_set(detector, 1);
 292
 293         sample = hkl_sample_new("test");
 294         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 295                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD);
 296         hkl_sample_lattice_set(sample, lattice);
 297         hkl_lattice_free(lattice);
 298
 299         hkl_geometry_set_values_unit_v(geometry, 30., 0., 90., 60.);
 300         r0 = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
 301         hkl_sample_add_reflection(sample, r0);
 302
 303         hkl_geometry_set_values_unit_v(geometry, 30., 90., 0., 60.);
 304         r1 = hkl_sample_reflection_new(geometry, detector, 0, 1, 0);
 305         hkl_sample_add_reflection(sample, r1);
 306
 307         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 308         r2 = hkl_sample_reflection_new(geometry, detector, 0, 0, 1);
 309         hkl_sample_add_reflection(sample, r2);
 310
 311         hkl_geometry_set_values_unit_v(geometry, 60., 60., 60., 60.);
 312         r3 = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946);
 313         hkl_sample_add_reflection(sample, r3);
 314
 315         hkl_geometry_set_values_unit_v(geometry, 45., 45., 45., 60.);
 316         r4 = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252);
 317         hkl_sample_add_reflection(sample, r4);
 318
 319         is_double(90 * HKL_DEGTORAD,
 320                   hkl_sample_get_reflection_theoretical_angle(sample, r0, r1),
 321                   HKL_EPSILON, __func__);
 322
 323         is_double(90 * HKL_DEGTORAD,
 324                   hkl_sample_get_reflection_mesured_angle(sample, r0, r1),
 325                   HKL_EPSILON, __func__);
 326
 327         is_double(90 * HKL_DEGTORAD,
 328                   hkl_sample_get_reflection_theoretical_angle(sample, r1, r2),
 329                   HKL_EPSILON, __func__);
 330
 331         is_double(90 * HKL_DEGTORAD,
 332                   hkl_sample_get_reflection_mesured_angle(sample, r1, r2),
 333                   HKL_EPSILON, __func__);
 334
 335         hkl_sample_free(sample);
 336         hkl_detector_free(detector);
 337         hkl_geometry_free(geometry);
 338 }
 339
 340 static void reflection_set_geometry(void)
 341 {
 342         double a, b, c, alpha, beta, gamma;
 343         HklDetector *detector;
 344         const HklFactory *factory;
 345         HklGeometry *geometry;
 346         HklSample *sample;
 347         HklLattice *lattice;
 348         HklSampleReflection *ref;
 349         HklMatrix *m_ref = hkl_matrix_new_full(1., 0., 0.,
 350                                                0., 1., 0.,
 351                                                0., 0., 1.);
 352
 353         factory = hkl_factory_get_by_name("E4CV");
 354         geometry = hkl_factory_create_new_geometry(factory);
 355
 356         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 357         hkl_detector_idx_set(detector, 1);
 358
 359         sample = hkl_sample_new("test");
 360         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 361                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD,90*HKL_DEGTORAD);
 362         hkl_sample_lattice_set(sample, lattice);
 363         hkl_lattice_free(lattice);
 364
 365         hkl_geometry_set_values_unit_v(geometry, 30., 0., 90., 60.);
 366         ref = hkl_sample_reflection_new(geometry, detector, 1, 0, 0);
 367         hkl_sample_add_reflection(sample, ref);
 368
 369         hkl_geometry_set_values_unit_v(geometry, 30., 90., 0., 60.);
 370         ref = hkl_sample_reflection_new(geometry, detector, 0, 1, 0);
 371         hkl_sample_add_reflection(sample, ref);
 372
 373         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 374         ref = hkl_sample_reflection_new(geometry, detector, 0, 0, 1);
 375         hkl_sample_add_reflection(sample, ref);
 376
 377         hkl_geometry_set_values_unit_v(geometry, 60., 60., 60., 60.);
 378         ref = hkl_sample_reflection_new(geometry, detector, .625, .75, -.216506350946);
 379         hkl_sample_add_reflection(sample, ref);
 380
 381         hkl_geometry_set_values_unit_v(geometry, 46., 45., 45., 60.);
 382         ref = hkl_sample_reflection_new(geometry, detector, .665975615037, .683012701892, .299950211252);
 383         hkl_sample_add_reflection(sample, ref);
 384
 385         /* correct the last reflection so the sample affinement must be ok. */
 386         hkl_geometry_set_values_unit_v(geometry, 45., 45., 45., 60.);
 387         hkl_sample_reflection_geometry_set(ref, geometry);
 388
 389         hkl_sample_affine(sample);
 390         hkl_lattice_get(hkl_sample_lattice_get(sample),
 391                         &a, &b, &c, &alpha, &beta, &gamma);
 392
 393         ok(HKL_TRUE == hkl_matrix_cmp(m_ref, hkl_sample_U_get(sample)), __func__);
 394         is_double(1.54, a, HKL_EPSILON, __func__);
 395         is_double(1.54, b, HKL_EPSILON, __func__);
 396         is_double(1.54, c, HKL_EPSILON, __func__);
 397         is_double(90 * HKL_DEGTORAD, alpha, HKL_EPSILON, __func__);
 398         is_double(90 * HKL_DEGTORAD, beta, HKL_EPSILON, __func__);
 399         is_double(90 * HKL_DEGTORAD, gamma, HKL_EPSILON, __func__);
 400         is_double(0., hkl_parameter_value_get(hkl_sample_ux_get(sample)), HKL_EPSILON, __func__);
 401         is_double(0., hkl_parameter_value_get(hkl_sample_uy_get(sample)), HKL_EPSILON, __func__);
 402         is_double(0., hkl_parameter_value_get(hkl_sample_uz_get(sample)), HKL_EPSILON, __func__);
 403
 404         hkl_sample_free(sample);
 405         hkl_detector_free(detector);
 406         hkl_geometry_free(geometry);
 407         hkl_matrix_free(m_ref);
 408 }
 409
 410 int main(int argc, char** argv)
 411 {
 412         plan(40);
 413
 414         new();
 415         add_reflection();
 416         get_reflection();
 417         del_reflection();
 418         set_UB();
 419         compute_UB_busing_levy();
 420         affine();
 421         get_reflections_xxx_angle();
 422
 423         reflection_set_geometry();
 424
 425         return 0;
 426 }