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-2019, 2021, 2023, 2024 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         /* check GError generation */
  83         error = NULL;
  84         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  85                                   90*HKL_DEGTORAD, (90+360)*HKL_DEGTORAD, 90*HKL_DEGTORAD,
  86                                   &error);
  87         ok(NULL == lattice, __func__);
  88         ok(error != NULL, __func__);
  89         g_clear_error(&error);
  90
  91         /* but can create this one */
  92         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
  93                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
  94                                   NULL);
  95         ok(0 == !lattice, __func__);
  96         CHECK_LATTICE(lattice,
  97                       1.54, 1.54, 1.54,
  98                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
  99         hkl_lattice_free(lattice);
 100
 101         /* but can create this one and no GError are produce */
 102         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 103                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 104                                   &error);
 105         ok(0 == !lattice, __func__);
 106         ok(error == NULL, __func__);
 107         CHECK_LATTICE(lattice,
 108                       1.54, 1.54, 1.54,
 109                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 110         hkl_lattice_free(lattice);
 111 }
 112
 113 static void new_copy(void)
 114 {
 115         HklLattice *lattice;
 116         HklLattice *copy;
 117
 118         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 119                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 120                                   NULL);
 121
 122         /* copy constructor */
 123         copy = hkl_lattice_new_copy(lattice);
 124
 125         CHECK_LATTICE(copy,
 126                       1.54, 1.54, 1.54,
 127                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 128
 129         hkl_lattice_free(lattice);
 130         hkl_lattice_free(copy);
 131 }
 132
 133 static void set(void)
 134 {
 135         HklLattice *lattice;
 136         GError *error;
 137
 138         lattice = hkl_lattice_new_default();
 139
 140         /* can not set this lattice */
 141         ok(FALSE == hkl_lattice_set(lattice,
 142                                     1.54, 1.54, 1.54,
 143                                     90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
 144                                     HKL_UNIT_DEFAULT, NULL),
 145            __func__);
 146
 147         /* check that the lattice was not changed */
 148         CHECK_LATTICE(lattice,
 149                       1.54, 1.54, 1.54,
 150                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 151
 152         /* can not set this lattice with GError */
 153         error = NULL;
 154         ok(FALSE == hkl_lattice_set(lattice,
 155                                     1.54, 1.54, 1.54,
 156                                     90*HKL_DEGTORAD, 10*HKL_DEGTORAD, 120*HKL_DEGTORAD,
 157                                     HKL_UNIT_DEFAULT, &error),
 158            __func__);
 159         ok(error != NULL, __func__);
 160         g_clear_error(&error);
 161
 162         /* can set this lattice */
 163         ok(TRUE == hkl_lattice_set(lattice,
 164                                    1.54, 1.54, 1.54,
 165                                    90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD,
 166                                    HKL_UNIT_DEFAULT, NULL),
 167            __func__);
 168         CHECK_LATTICE(lattice,
 169                       1.54, 1.54, 1.54,
 170                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
 171
 172         /* can set this lattice with no GError set */
 173         ok(TRUE == hkl_lattice_set(lattice,
 174                                    1.54, 1.54, 1.54,
 175                                    90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 176                                    HKL_UNIT_DEFAULT, &error),
 177            __func__);
 178         ok(error == NULL, __func__);
 179         CHECK_LATTICE(lattice,
 180                       1.54, 1.54, 1.54,
 181                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 182
 183
 184
 185         /* can set this lattice in HKL_UNIT_USER with no GError set */
 186         ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54, 90, 91, 92,
 187                                    HKL_UNIT_USER, NULL),
 188            __func__);
 189         CHECK_LATTICE(lattice,
 190                       1.54, 1.54, 1.54,
 191                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 92*HKL_DEGTORAD);
 192
 193         /* can set this lattice in HKL_UNIT_USER with no GError set */
 194         ok(TRUE == hkl_lattice_set(lattice,
 195                                    1.54, 1.54, 1.54, 90, 91, 90,
 196                                    HKL_UNIT_USER, &error),
 197            __func__);
 198         ok(error == NULL, __func__);
 199         CHECK_LATTICE(lattice,
 200                       1.54, 1.54, 1.54,
 201                       90*HKL_DEGTORAD, 91*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 202
 203         /* check individual accessor */
 204         SET_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
 205         CHECK_LATTICE(lattice, 1.54, 1.54, 1.54, 90*HKL_DEGTORAD, 91 * HKL_DEGTORAD, 91 * HKL_DEGTORAD);
 206
 207         hkl_lattice_free(lattice);
 208 }
 209
 210 static void reciprocal(void)
 211 {
 212         HklLattice *lattice;
 213         HklLattice *reciprocal;
 214
 215         lattice = hkl_lattice_new_default();
 216         reciprocal = hkl_lattice_new_default();
 217
 218         /* cubic */
 219         ok(TRUE == hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
 220                                    90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 221                                    HKL_UNIT_DEFAULT, NULL),
 222            __func__);
 223
 224         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 225
 226         CHECK_LATTICE(reciprocal,
 227                       HKL_TAU / 1.54, HKL_TAU / 1.54, HKL_TAU / 1.54,
 228                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 229
 230         /* orthorombic */
 231         ok(TRUE == hkl_lattice_set(lattice,
 232                                    1., 3., 4.,
 233                                    90 * HKL_DEGTORAD, 90 * 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 / 1., HKL_TAU / 3., HKL_TAU / 4.,
 240                       90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 241
 242         /* hexagonal1 */
 243         ok(TRUE == hkl_lattice_set(lattice,
 244                                    1., 2., 1.,
 245                                    90 * HKL_DEGTORAD, 120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 246                                    HKL_UNIT_DEFAULT, NULL),
 247            __func__);
 248         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 249
 250         CHECK_LATTICE(reciprocal,
 251                       HKL_TAU * 2. / sqrt(3.), HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.),
 252                       90. * HKL_DEGTORAD, 60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
 253
 254         /* hexagonal2 */
 255         ok(TRUE == hkl_lattice_set(lattice, 2., 1., 1.,
 256                                    120 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 257                                    HKL_UNIT_DEFAULT, NULL),
 258            __func__);
 259         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 260
 261         CHECK_LATTICE(reciprocal,
 262                       HKL_TAU / 2., HKL_TAU * 2. / sqrt(3.), HKL_TAU * 2. / sqrt(3.),
 263                       60. * HKL_DEGTORAD, 90. * HKL_DEGTORAD, 90. * HKL_DEGTORAD);
 264
 265         /* triclinic1 */
 266         ok(TRUE == hkl_lattice_set(lattice, 9.32, 8.24, 13.78,
 267                                    91.23 * HKL_DEGTORAD, 93.64 * HKL_DEGTORAD, 122.21 * HKL_DEGTORAD,
 268                                    HKL_UNIT_DEFAULT, NULL),
 269            __func__);
 270         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 271
 272         CHECK_LATTICE(reciprocal,
 273                       HKL_TAU * 0.1273130168,HKL_TAU * 0.1437422974,HKL_TAU * 0.0728721120,
 274                       1.5052513337, 1.482101482, 1.0055896011);
 275
 276         /* triclinic2 */
 277         ok(TRUE == hkl_lattice_set(lattice, 18.423, 18.417,
 278                                    18.457, 89.99 * HKL_DEGTORAD, 89.963 * HKL_DEGTORAD, 119.99 * HKL_DEGTORAD,
 279                                    HKL_UNIT_DEFAULT, NULL),
 280            __func__);
 281         ok(TRUE == hkl_lattice_reciprocal(lattice, reciprocal), __func__);
 282
 283         CHECK_LATTICE(reciprocal,
 284                       HKL_TAU * 0.0626708259,HKL_TAU * 0.0626912310,HKL_TAU * 0.0541800061,
 285                       1.5713705262, 1.5716426508, 1.0473718249);
 286
 287         hkl_lattice_free(lattice);
 288         hkl_lattice_free(reciprocal);
 289 }
 290
 291 static void volume(void)
 292 {
 293         HklLattice *lattice;
 294         HklLattice *reciprocal;
 295
 296         lattice = hkl_lattice_new_default();
 297         reciprocal = hkl_lattice_new_default();
 298
 299         /* cubic */
 300         (DIAG(hkl_lattice_set(lattice, 1.54, 1.54, 1.54,
 301                               90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD,
 302                               HKL_UNIT_DEFAULT, NULL)));
 303         CHECK_PARAM(lattice, volume, 1.54*1.54*1.54);
 304
 305         hkl_lattice_reciprocal(lattice, reciprocal);
 306         CHECK_PARAM(reciprocal, volume, (HKL_TAU * HKL_TAU * HKL_TAU)/(1.54*1.54*1.54));
 307
 308         hkl_lattice_free(lattice);
 309         hkl_lattice_free(reciprocal);
 310 }
 311
 312 static void get_B(void)
 313 {
 314         HklMatrix *B_ref = hkl_matrix_new_full(HKL_TAU / 1.54, 0, 0,
 315                                                0, HKL_TAU / 1.54, 0,
 316                                                0, 0, HKL_TAU / 1.54);
 317         HklLattice *lattice;
 318         HklMatrix *B = hkl_matrix_new();
 319
 320         /* cubic */
 321         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 322                                   90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 323                                   NULL);
 324
 325         hkl_lattice_get_B(lattice, B);
 326         is_matrix(B_ref, B, __func__);
 327
 328         hkl_lattice_free(lattice);
 329         hkl_matrix_free(B);
 330         hkl_matrix_free(B_ref);
 331 }
 332
 333 static void get_1_B(void)
 334 {
 335         HklMatrix *I_ref = hkl_matrix_new_full(1, 0, 0,
 336                                                0, 1, 0,
 337                                                0, 0, 1);
 338         HklLattice *lattice;
 339         HklMatrix *I = hkl_matrix_new();
 340         HklMatrix *B_1 = hkl_matrix_new();
 341
 342         /* cubic */
 343         lattice = hkl_lattice_new(1.54, 1.54, 1.54,
 344                                   90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD, 90 * HKL_DEGTORAD,
 345                                   NULL);
 346
 347         hkl_lattice_get_B(lattice, I);
 348         hkl_lattice_get_1_B(lattice, B_1);
 349
 350         /* B times B^-1 = Identity */
 351         hkl_matrix_times_matrix(I, B_1);
 352         is_matrix(I_ref, I, __func__);
 353
 354         hkl_lattice_free(lattice);
 355         hkl_matrix_free(B_1);
 356         hkl_matrix_free(I);
 357         hkl_matrix_free(I_ref);
 358 }
 359
 360 int main(void)
 361 {
 362         plan(147);
 363
 364         new();
 365         new_copy();
 366         set();
 367         reciprocal();
 368         volume();
 369         get_B();
 370         get_1_B();
 371
 372         return 0;
 373 }