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