tests/hkl-lattice-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 CHECK_PARAM(_lattice, _param, _value)                           \
  28         is_double((_value),                                             \
  29                   hkl_parameter_value_get(hkl_lattice_## _param ##_get(_lattice), \
  30                                           HKL_UNIT_DEFAULT),            \
  31                   HKL_EPSILON, __func__);
  32
  33 #define CHECK_LATTICE(_lattice, _a, _b, _c, _alpha, _beta, _gamma) do { \
  34                 CHECK_PARAM(_lattice, a, _a);                           \
  35                 CHECK_PARAM(_lattice, b, _b);                           \
  36                 CHECK_PARAM(_lattice, c, _c);                           \
  37                 CHECK_PARAM(_lattice, alpha, _alpha);                   \
  38                 CHECK_PARAM(_lattice, beta, _beta);                     \
  39                 CHECK_PARAM(_lattice, gamma, _gamma);                   \
  40         }while(0)
  41
  42 #define SET_PARAM(_lattice, _param, _value) do {                        \
  43                 GError *error;                                          \
  44                 HklParameter *p = hkl_parameter_new_copy(hkl_lattice_ ## _param ## _get(_lattice)); \
  45                 ok(hkl_parameter_value_set(p, _value, HKL_UNIT_DEFAULT, NULL), __func__); \
  46                 ok(TRUE == hkl_lattice_ ## _param ## _set(_lattice, p, NULL), __func__); \
  47                 error = NULL;                                           \
  48                 ok(TRUE == hkl_lattice_ ## _param ## _set(_lattice, p, &error), __func__); \
  49                 ok(error == NULL, __func__);                            \
  50                 hkl_parameter_free(p);                                  \
  51         }while(0)
  52                                 \
  53 #define SET_LATTICE(_lattice, _a, _b, _c, _alpha, _beta, _gamma) do{    \
  54                 SET_PARAM(_lattice, a, _a);                             \
  55                 SET_PARAM(_lattice, b, _b);                             \
  56                 SET_PARAM(_lattice, c, _c);                             \
  57                 SET_PARAM(_lattice, alpha, _alpha);                     \
  58                 SET_PARAM(_lattice, beta, _beta);                       \
  59                 SET_PARAM(_lattice, gamma, _gamma);                     \
  60         }while(0)
  61
  62 static void new(void)
  63 {
  64         HklLattice *lattice;
  65         GError *error;
  66
  67         /* can not set this lattice */
  68         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  69                                   90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
  70                                   NULL);
  71         ok(NULL == lattice, __func__);
  72
  73         /* check GError generation */
  74         error = NULL;
  75         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  76                                   90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
  77                                   &error);
  78         ok(NULL == lattice, __func__);
  79         ok(error != NULL, __func__);
  80         g_clear_error(&error);
  81
  82         /* but can create this one */
  83         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  84                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
  85                                   NULL);
  86         ok(0 == !lattice, __func__);
  87
  88         CHECK_LATTICE(lattice,
  89                       1.54, 1.54, 1.54,
  90                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
  91
  92         /* but can create this one and no GError are produce */
  93         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  94                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
  95                                   &error);
  96         ok(0 == !lattice, __func__);
  97         ok(error == NULL, __func__);
  98
  99         CHECK_LATTICE(lattice,
 100                       1.54, 1.54, 1.54,
 101                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 102
 103         hkl_lattice_free(lattice);
 104 }
 105
 106 static void new_copy(void)
 107 {
 108         HklLattice *lattice;
 109         HklLattice *copy;
 110
 111         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 112                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 113                                   NULL);
 114
 115         /* copy constructor */
 116         copy = hkl_lattice_new_copy(lattice);
 117
 118         CHECK_LATTICE(copy,
 119                       1.54, 1.54, 1.54,
 120                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 121
 122         hkl_lattice_free(lattice);
 123         hkl_lattice_free(copy);
 124 }
 125
 126 static void set(void)
 127 {
 128         HklLattice *lattice;
 129         GError *error;
 130
 131         lattice = hkl_lattice_new_default();
 132
 133         /* can not set this lattice */
 134         ok(FALSE == hkl_lattice_set(lattice,
 135                                     1.54, 1.54, 1.54,
 136                                     90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
 137                                     HKL_UNIT_DEFAULT, NULL),
 138            __func__);
 139
 140         /* can not set this lattice with GError */
 141         error = NULL;
 142         ok(FALSE == hkl_lattice_set(lattice,
 143                                     1.54, 1.54, 1.54,
 144                                     90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
 145                                     HKL_UNIT_DEFAULT, &error),
 146            __func__);
 147         ok(error != NULL, __func__);
 148         g_clear_error(&error);
 149
 150         /* can set this lattice */
 151         ok(TRUE == hkl_lattice_set(lattice,
 152                                    1.54, 1.54, 1.54,
 153                                    90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD,
 154                                    HKL_UNIT_DEFAULT, NULL),
 155            __func__);
 156         CHECK_LATTICE(lattice,
 157                       1.54, 1.54, 1.54,
 158                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
 159
 160         /* can set this lattice with no GError set */
 161         ok(TRUE == hkl_lattice_set(lattice,
 162                                    1.54, 1.54, 1.54,
 163                                    90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 164                                    HKL_UNIT_DEFAULT, &error),
 165            __func__);
 166         ok(error == NULL, __func__);
 167         CHECK_LATTICE(lattice,
 168                       1.54, 1.54, 1.54,
 169                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 170
 171
 172
 173         /* can set this lattice in HKL_UNIT_USER with no GError set */
 174         ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54, 90, 91, 92,
 175                                    HKL_UNIT_USER, NULL),
 176            __func__);
 177         CHECK_LATTICE(lattice,
 178                       1.54, 1.54, 1.54,
 179                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
 180
 181         /* can set this lattice in HKL_UNIT_USER with no GError set */
 182         ok(TRUE == hkl_lattice_set(lattice,
 183                                    1.54, 1.54, 1.54, 90, 91, 90,
 184                                    HKL_UNIT_USER, &error),
 185            __func__);
 186         ok(error == NULL, __func__);
 187         CHECK_LATTICE(lattice,
 188                       1.54, 1.54, 1.54,
 189                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 190
 191         /* check individual accessor */
 192         SET_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
 193         CHECK_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
 194
 195         hkl_lattice_free(lattice);
 196 }
 197
 198 static void reciprocal(void)
 199 {
 200         HklLattice *lattice;
 201         HklLattice *reciprocal;
 202
 203         lattice = hkl_lattice_new_default();
 204         reciprocal = hkl_lattice_new_default();
 205
 206         /* cubic */
 207         ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
 208                                    90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 209                                    HKL_UNIT_DEFAULT, NULL),
 210            __func__);
 211
 212         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 213
 214         CHECK_LATTICE(reciprocal,
 215                       HKL_TAU / 1.54, HKL_TAU / 1.54, HKL_TAU / 1.54,
 216                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 217
 218         /* orthorombic */
 219         ok(TRUE == hkl_lattice_set(lattice,
 220                                    1., 3., 4.,
 221                                    90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 222                                    HKL_UNIT_DEFAULT, NULL),
 223            __func__);
 224         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 225
 226         CHECK_LATTICE(reciprocal,
 227                       HKL_TAU / 1., HKL_TAU / 3., HKL_TAU / 4.,
 228                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 229
 230         /* hexagonal1 */
 231         ok(TRUE == hkl_lattice_set(lattice,
 232                                    1., 2., 1.,
 233                                    90 * HKL_DEGTORAD, 120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 234                                    HKL_UNIT_DEFAULT, NULL),
 235            __func__);
 236         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 237
 238         CHECK_LATTICE(reciprocal,
 239                       HKL_TAU * 2. / sqrt(3.), HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.),
 240                       90. * HKL_DEGTORAD, 60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
 241
 242         /* hexagonal2 */
 243         ok(TRUE == hkl_lattice_set(lattice, 2., 1., 1.,
 244                                    120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 245                                    HKL_UNIT_DEFAULT, NULL),
 246            __func__);
 247         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 248
 249         CHECK_LATTICE(reciprocal,
 250                       HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.), HKL_TAU * 2. / sqrt(3.),
 251                       60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
 252
 253         /* triclinic1 */
 254         ok(TRUE == hkl_lattice_set(lattice, 9.32, 8.24, 13.78,
 255                                    91.23 * HKL_DEGTORAD, 93.64 * HKL_DEGTORAD, 122.21 * HKL_DEGTORAD,
 256                                    HKL_UNIT_DEFAULT, NULL),
 257            __func__);
 258         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 259
 260         CHECK_LATTICE(reciprocal,
 261                       HKL_TAU * 0.1273130168,HKL_TAU * 0.1437422974,HKL_TAU * 0.0728721120,
 262                       1.5052513337, 1.482101482, 1.0055896011);
 263
 264         /* triclinic2 */
 265         ok(TRUE == hkl_lattice_set(lattice, 18.423, 18.417,
 266                                    18.457, 89.99 * HKL_DEGTORAD, 89.963 * HKL_DEGTORAD, 119.99 * HKL_DEGTORAD,
 267                                    HKL_UNIT_DEFAULT, NULL),
 268            __func__);
 269         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 270
 271         CHECK_LATTICE(reciprocal,
 272                       HKL_TAU * 0.0626708259,HKL_TAU * 0.0626912310,HKL_TAU * 0.0541800061,
 273                       1.5713705262, 1.5716426508, 1.0473718249);
 274
 275         hkl_lattice_free(lattice);
 276         hkl_lattice_free(reciprocal);
 277 }
 278
 279 static void volume(void)
 280 {
 281         HklLattice *lattice;
 282         HklLattice *reciprocal;
 283
 284         lattice = hkl_lattice_new_default();
 285         reciprocal = hkl_lattice_new_default();
 286
 287         /* cubic */
 288         DIAG(hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
 289                              90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 290                              HKL_UNIT_DEFAULT, NULL));
 291         CHECK_PARAM(lattice, volume, 1.54*1.54*1.54);
 292
 293         hkl_lattice_reciprocal(lattice, reciprocal);
 294         CHECK_PARAM(reciprocal, volume, (HKL_TAU * HKL_TAU * HKL_TAU)/(1.54*1.54*1.54));
 295
 296         hkl_lattice_free(lattice);
 297         hkl_lattice_free(reciprocal);
 298 }
 299
 300 static void get_B(void)
 301 {
 302         HklMatrix *B_ref = hkl_matrix_new_full(HKL_TAU / 1.54, 0, 0,
 303                                                0, HKL_TAU / 1.54, 0,
 304                                                0, 0, HKL_TAU / 1.54);
 305         HklLattice *lattice;
 306         HklMatrix *B = hkl_matrix_new();
 307
 308         /* cubic */
 309         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 310                                   90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 311                                   NULL);
 312
 313         hkl_lattice_get_B(lattice, B);
 314         is_matrix(B_ref, B, __func__);
 315
 316         hkl_lattice_free(lattice);
 317         hkl_matrix_free(B);
 318         hkl_matrix_free(B_ref);
 319 }
 320
 321 static void get_1_B(void)
 322 {
 323         HklMatrix *I_ref = hkl_matrix_new_full(1, 0, 0,
 324                                                0, 1, 0,
 325                                                0, 0, 1);
 326         HklLattice *lattice;
 327         HklMatrix *I = hkl_matrix_new();
 328         HklMatrix *B_1 = hkl_matrix_new();
 329
 330         /* cubic */
 331         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 332                                   90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 333                                   NULL);
 334
 335         hkl_lattice_get_B(lattice, I);
 336         hkl_lattice_get_1_B(lattice, B_1);
 337
 338         /* B times B^-1 = Identity */
 339         hkl_matrix_times_matrix(I, B_1);
 340         is_matrix(I_ref, I, __func__);
 341
 342         hkl_lattice_free(lattice);
 343         hkl_matrix_free(B_1);
 344         hkl_matrix_free(I);
 345         hkl_matrix_free(I_ref);
 346 }
 347
 348 int main(void)
 349 {
 350         plan(139);
 351
 352         new();
 353         new_copy();
 354         set();
 355         reciprocal();
 356         volume();
 357         get_B();
 358         get_1_B();
 359
 360         return 0;
 361 }