tests/hkl-pseudoaxis-e4cv-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-2017 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/hkl-tap.h>
  25
  26 static void getter(void)
  27 {
  28         int res = TRUE;
  29         HklEngineList *engines;
  30         HklEngine *engine;
  31         HklGeometry *geometry;
  32         HklDetector *detector;
  33         HklSample *sample;
  34         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
  35
  36         geometry = newGeometry(gconf);
  37         engines = newEngines(gconf);
  38         sample = newSample(cu);
  39
  40         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  41
  42         hkl_engine_list_init(engines, geometry, detector, sample);
  43
  44         engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
  45
  46         /* geometry -> pseudo */
  47         res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 0., 60.));
  48         res &= DIAG(check_pseudoaxes_v(engine, 0., 0., 1.));
  49
  50         res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 90., 60.));
  51         res &= DIAG(check_pseudoaxes_v(engine, 1., 0., 0.));
  52
  53         res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., -90., 60.));
  54         res &= DIAG(check_pseudoaxes_v(engine, -1., 0., 0.));
  55
  56         res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 30., 0., 180., 60.));
  57         res &= DIAG(check_pseudoaxes_v(engine, 0., 0., -1.));
  58
  59         res &= DIAG(hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 45., 0., 135., 90.));
  60         res &= DIAG(check_pseudoaxes_v(engine, 1., 0., -1.));
  61
  62         ok(res == TRUE, "getter");
  63
  64         hkl_engine_list_free(engines);
  65         hkl_detector_free(detector);
  66         hkl_sample_free(sample);
  67         hkl_geometry_free(geometry);
  68 }
  69
  70 static void degenerated(void)
  71 {
  72         int res = TRUE;
  73         HklEngineList *engines;
  74         HklEngine *engine;
  75         const char **mode;
  76         const darray_string *modes;
  77         HklGeometry *geometry;
  78         HklDetector *detector;
  79         HklSample *sample;
  80         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
  81
  82         geometry = newGeometry(gconf);
  83         engines = newEngines(gconf);
  84         sample = newSample(cu);
  85
  86         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  87
  88         hkl_engine_list_init(engines, geometry, detector, sample);
  89
  90         engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
  91         modes = hkl_engine_modes_names_get(engine);
  92
  93         darray_foreach(mode, *modes){
  94                 static double values[] = {0, 0, 1};
  95                 HklGeometryList *geometries;
  96                 size_t n_params;
  97
  98                 res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
  99                 const darray_string *parameters = hkl_engine_parameters_names_get(engine);
 100                 n_params = darray_size(*parameters);
 101                 if (n_params){
 102                         double params[n_params];
 103
 104                         hkl_engine_parameters_values_get(engine, params, n_params, HKL_UNIT_DEFAULT);
 105                         params[0] = 0;
 106                         res &= DIAG(hkl_engine_parameters_values_set(engine, params, n_params, HKL_UNIT_DEFAULT, NULL));
 107                 }
 108
 109                 /* studdy this degenerated case */
 110                 geometries = hkl_engine_pseudo_axis_values_set(engine, values, 3, HKL_UNIT_DEFAULT, NULL);
 111                 if(geometries){
 112                         const HklGeometryListItem *item;
 113
 114                         HKL_GEOMETRY_LIST_FOREACH(item, geometries){
 115                                 hkl_geometry_set(geometry,
 116                                                  hkl_geometry_list_item_geometry_get(item));
 117                                 res &= DIAG(check_pseudoaxes(engine, values, ARRAY_SIZE(values)));
 118                         }
 119                         hkl_geometry_list_free(geometries);
 120                 }
 121         }
 122
 123         ok(res == TRUE, "degenerated");
 124
 125         hkl_engine_list_free(engines);
 126         hkl_detector_free(detector);
 127         hkl_sample_free(sample);
 128         hkl_geometry_free(geometry);
 129 }
 130
 131 static void psi_getter(void)
 132 {
 133         int res = TRUE;
 134         HklEngineList *engines;
 135         HklEngine *engine;
 136         HklGeometry *geometry;
 137         HklDetector *detector;
 138         HklSample *sample;
 139         double hkl[3];
 140         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
 141
 142         geometry = newGeometry(gconf);
 143         engines = newEngines(gconf);
 144         sample = newSample(cu);
 145
 146         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 147
 148         hkl_engine_list_init(engines, geometry, detector, sample);
 149
 150         engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
 151
 152         /* the getter part */
 153         res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
 154
 155         /* 1 0 0 */
 156         hkl[0] = 1, hkl[1] = 0, hkl[2] = 0;
 157         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 158         res &= DIAG(check_pseudoaxes_v(engine, 0.));
 159
 160         /* 0 1 0*/
 161         hkl[0] = 0, hkl[1] = 1, hkl[2] = 0;
 162         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 163         res &= DIAG(check_pseudoaxes_v(engine, 90. * HKL_DEGTORAD));
 164
 165         /* here Q and <h, k, l>_ref are colinear must FAIL */
 166         hkl[0] = 0, hkl[1] = 0, hkl[2] = 1;
 167         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 168         res &= DIAG(!check_pseudoaxes_v(engine, 0. * HKL_DEGTORAD));
 169
 170         /* -1 0 0 */
 171         hkl[0] = -1, hkl[1] = 0, hkl[2] = 0;
 172         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 173         res &= DIAG(check_pseudoaxes_v(engine, 180. * HKL_DEGTORAD));
 174
 175         /* 0 -1 0 */
 176         hkl[0] = 0, hkl[1] = -1, hkl[2] = 0;
 177         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 178         res &= DIAG(check_pseudoaxes_v(engine, -90. * HKL_DEGTORAD));
 179
 180         /* Q and <h, k, l>_ref are colinear so must FAIL */
 181         hkl[0] = 0, hkl[1] = 0, hkl[2] = -1;
 182         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 183         res &= DIAG(!check_pseudoaxes_v(engine, 0. * HKL_DEGTORAD));
 184
 185         ok(res == TRUE, "psi getter");
 186
 187         hkl_engine_list_free(engines);
 188         hkl_detector_free(detector);
 189         hkl_sample_free(sample);
 190         hkl_geometry_free(geometry);
 191 }
 192
 193 static void psi_setter(void)
 194 {
 195         int res = TRUE;
 196         HklEngineList *engines;
 197         HklEngine *engine;
 198         const darray_string *modes;
 199         const char **mode;
 200         HklGeometry *geometry;
 201         HklDetector *detector;
 202         HklSample *sample;
 203         static double hkl[] = {1, 0, 0};
 204         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
 205
 206         geometry = newGeometry(gconf);
 207         engines = newEngines(gconf);
 208         sample = newSample(cu);
 209
 210         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 211
 212         hkl_engine_list_init(engines, geometry, detector, sample);
 213
 214         engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
 215         modes = hkl_engine_modes_names_get(engine);
 216
 217         /* the init part */
 218         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl, ARRAY_SIZE(hkl), HKL_UNIT_DEFAULT, NULL));
 219         res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
 220
 221         darray_foreach(mode, *modes){
 222                 double psi;
 223
 224                 res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
 225                 for(psi=-180 * HKL_DEGTORAD;psi<180 * HKL_DEGTORAD;psi += HKL_DEGTORAD){
 226                         HklGeometryList *geometries;
 227
 228                         geometries = hkl_engine_pseudo_axis_values_set(engine, &psi, 1,
 229                                                                        HKL_UNIT_DEFAULT, NULL);
 230                         if(geometries){
 231                                 const HklGeometryListItem *item;
 232
 233                                 HKL_GEOMETRY_LIST_FOREACH(item, geometries){
 234                                         hkl_geometry_set(geometry,
 235                                                          hkl_geometry_list_item_geometry_get(item));
 236                                         res &= DIAG(check_pseudoaxes_v(engine, psi));
 237                                 }
 238                                 hkl_geometry_list_free(geometries);
 239                         }
 240                 }
 241         }
 242
 243         ok(res == TRUE, "psi setter");
 244
 245         hkl_engine_list_free(engines);
 246         hkl_detector_free(detector);
 247         hkl_sample_free(sample);
 248         hkl_geometry_free(geometry);
 249 }
 250
 251 static void q(void)
 252 {
 253         int res = TRUE;
 254         HklEngineList *engines;
 255         HklEngine *engine;
 256         const darray_string *modes;
 257         const char **mode;
 258         HklGeometry *geometry;
 259         HklDetector *detector;
 260         HklSample *sample;
 261         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
 262
 263         geometry = newGeometry(gconf);
 264         engines = newEngines(gconf);
 265         sample = newSample(cu);
 266
 267         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 268
 269         hkl_engine_list_init(engines, geometry, detector, sample);
 270
 271         engine = hkl_engine_list_engine_get_by_name(engines, "q", NULL);
 272         modes = hkl_engine_modes_names_get(engine);
 273
 274         /* the init part */
 275         res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
 276
 277         darray_foreach(mode, *modes){
 278                 double q;
 279
 280                 res &= DIAG(hkl_engine_current_mode_set(engine, *mode, NULL));
 281                 for(q=-1.; q<1.; q += 0.1){
 282                         HklGeometryList *geometries;
 283
 284                         geometries = hkl_engine_pseudo_axis_values_set(engine, &q, 1,
 285                                                                        HKL_UNIT_DEFAULT, NULL);
 286                         if(geometries){
 287                                 const HklGeometryListItem *item;
 288
 289                                 HKL_GEOMETRY_LIST_FOREACH(item, geometries){
 290                                         hkl_geometry_set(geometry,
 291                                                          hkl_geometry_list_item_geometry_get(item));
 292                                         res &= DIAG(check_pseudoaxes(engine, &q, 1));
 293                                 }
 294                                 hkl_geometry_list_free(geometries);
 295                         }
 296                 }
 297         }
 298
 299         ok(res == TRUE, "q");
 300
 301         hkl_engine_list_free(engines);
 302         hkl_detector_free(detector);
 303         hkl_sample_free(sample);
 304         hkl_geometry_free(geometry);
 305 }
 306
 307 static void hkl_psi_constant_vertical(void)
 308 {
 309         int res = TRUE;
 310         HklEngineList *engines;
 311         HklEngine *engine;
 312         HklGeometry *geometry;
 313         HklGeometryList *geometries;
 314         HklDetector *detector;
 315         HklSample *sample;
 316         static double hkl[] = {1, 0, 1};
 317         static double hkl2[] = {1, 1, 0};
 318         struct Geometry gconf = E4cv(1.54, 30., 0., 0., 60.);
 319
 320         geometry = newGeometry(gconf);
 321         engines = newEngines(gconf);
 322         sample = newSample(cu);
 323
 324         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 325
 326         hkl_engine_list_init(engines, geometry, detector, sample);
 327
 328         engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
 329
 330         res &= DIAG(hkl_engine_current_mode_set(engine, "psi_constant", NULL));
 331
 332         /* the init part */
 333         res &= DIAG(hkl_engine_parameters_values_set(engine, hkl2, ARRAY_SIZE(hkl2), HKL_UNIT_DEFAULT, NULL));
 334         res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
 335
 336         geometries = hkl_engine_pseudo_axis_values_set(engine, hkl, ARRAY_SIZE(hkl),
 337                                                        HKL_UNIT_DEFAULT, NULL);
 338         if(geometries){
 339                 const HklGeometryListItem *item;
 340
 341                 HKL_GEOMETRY_LIST_FOREACH(item, geometries){
 342                         hkl_geometry_set(geometry,
 343                                          hkl_geometry_list_item_geometry_get(item));
 344                         res &= DIAG(check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl)));
 345                 }
 346                 hkl_geometry_list_free(geometries);
 347         }
 348
 349         ok(res == TRUE, "psi constant vertical");
 350
 351         hkl_engine_list_free(engines);
 352         hkl_detector_free(detector);
 353         hkl_sample_free(sample);
 354         hkl_geometry_free(geometry);
 355 }
 356
 357 int main(void)
 358 {
 359         plan(6);
 360
 361         getter();
 362         degenerated();
 363         psi_getter();
 364         psi_setter();
 365         q();
 366         hkl_psi_constant_vertical();
 367
 368         return 0;
 369 }