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