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-2013 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 = HKL_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");
  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         hkl_detector_idx_set(detector, 1);
  43
  44         engines = hkl_factory_create_new_engine_list(factory);
  45         hkl_engine_list_init(engines, geometry, detector, sample);
  46
  47         engine = hkl_engine_list_get_by_name(engines, "hkl");
  48
  49         /* geometry -> pseudo */
  50         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
  51         hkl_engine_get(engine, NULL);
  52         res &= check_pseudoaxes_v(engine, 0., 1., 0.);
  53
  54         hkl_geometry_set_values_unit_v(geometry, 30., 0., 90., 60.);
  55         hkl_engine_get(engine, NULL);
  56         res &= check_pseudoaxes_v(engine, 1., 0., 0.);
  57
  58         hkl_geometry_set_values_unit_v(geometry, 30., 0., -90., 60.);
  59         hkl_engine_get(engine, NULL);
  60         res &= check_pseudoaxes_v(engine, -1., 0., 0.);
  61
  62         hkl_geometry_set_values_unit_v(geometry, 30., 0., 180., 60.);
  63         hkl_engine_get(engine, NULL);
  64         res &= check_pseudoaxes_v(engine, 0., -1., 0.);
  65
  66         hkl_geometry_set_values_unit_v(geometry, 45., 0., 135., 90.);
  67         hkl_engine_get(engine, NULL);
  68         res &= check_pseudoaxes_v(engine, 1., -1., 0.);
  69
  70         ok(res == HKL_TRUE, "getter");
  71
  72         hkl_engine_list_free(engines);
  73         hkl_detector_free(detector);
  74         hkl_sample_free(sample);
  75         hkl_geometry_free(geometry);
  76 }
  77
  78 static void degenerated(void)
  79 {
  80         int res = HKL_TRUE;
  81         HklEngineList *engines;
  82         HklEngine *engine;
  83         HklMode **mode;
  84         darray_mode *modes;
  85         const HklFactory *factory;
  86         HklGeometry *geometry;
  87         const HklGeometryList *geometries;
  88         HklDetector *detector;
  89         HklSample *sample;
  90         HklParameterList *pseudo_axes;
  91
  92         factory = hkl_factory_get_by_name("E4CH");
  93         geometry = hkl_factory_create_new_geometry(factory);
  94         sample = hkl_sample_new("test");
  95
  96         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  97         hkl_detector_idx_set(detector, 1);
  98
  99         engines = hkl_factory_create_new_engine_list(factory);
 100         hkl_engine_list_init(engines, geometry, detector, sample);
 101         geometries = hkl_engine_list_geometries(engines);
 102
 103         engine = hkl_engine_list_get_by_name(engines, "hkl");
 104         modes = hkl_engine_modes(engine);
 105         pseudo_axes = hkl_engine_pseudo_axes(engine);
 106
 107         darray_foreach(mode, *modes){
 108                 static double values[] = {0, 0, 1};
 109                 darray_parameter *parameters;
 110
 111                 hkl_engine_select_mode(engine, *mode);
 112                 parameters = hkl_mode_parameters(*mode);
 113                 if (darray_size(*parameters))
 114                         hkl_parameter_value_set(darray_item(*parameters, 0), 0, NULL);
 115
 116                 /* studdy this degenerated case */
 117                 hkl_parameter_list_values_set(pseudo_axes, values, 3, NULL);
 118                 if(hkl_engine_set(engine, NULL)){
 119                         const darray_item *items = hkl_geometry_list_items_get(geometries);
 120                         HklGeometryListItem **item;
 121
 122                         darray_foreach(item, *items){
 123                                 static double null[] = {0, 0, 0};
 124
 125                                 hkl_parameter_list_values_set(pseudo_axes, null, 3, NULL);
 126                                 hkl_geometry_set(geometry,
 127                                                  hkl_geometry_list_item_geometry_get(*item));
 128                                 hkl_engine_get(engine, NULL);
 129                                 res &= check_pseudoaxes(engine, values, 3);
 130                         }
 131                 }
 132         }
 133
 134         ok(res == HKL_TRUE, "degenerated");
 135
 136         hkl_engine_list_free(engines);
 137         hkl_detector_free(detector);
 138         hkl_sample_free(sample);
 139         hkl_geometry_free(geometry);
 140 }
 141
 142 static void psi_getter(void)
 143 {
 144         int res = HKL_TRUE;
 145         HklEngineList *engines;
 146         HklEngine *engine;
 147         const HklFactory *factory;
 148         HklGeometry *geometry;
 149         HklDetector *detector;
 150         HklSample *sample;
 151         double hkl[3];
 152         HklMode *mode;
 153         HklParameterList *parameters;
 154
 155         factory = hkl_factory_get_by_name("E4CH");
 156         geometry = hkl_factory_create_new_geometry(factory);
 157         sample = hkl_sample_new("test");
 158
 159         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 160         hkl_detector_idx_set(detector, 1);
 161
 162         engines = hkl_factory_create_new_engine_list(factory);
 163         hkl_engine_list_init(engines, geometry, detector, sample);
 164
 165         engine = hkl_engine_list_get_by_name(engines, "psi");
 166         mode = hkl_engine_mode(engine);
 167         parameters = hkl_mode_parameters(mode);
 168
 169         /* the getter part */
 170         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 171         hkl_engine_initialize(engine, NULL);
 172
 173         hkl[0] = 1, hkl[1] = 0, hkl[2] = 0;
 174         hkl_parameter_list_values_set(parameters,
 175                                       hkl, ARRAY_SIZE(hkl), NULL);
 176         res &= hkl_engine_get(engine, NULL);
 177         res &= check_pseudoaxes_v(engine, 0.);
 178
 179         /* here Q and <h, k, l>_ref are colinear must FAIL */
 180         hkl[0] = 0, hkl[1] = 1, hkl[2] = 0;
 181         hkl_parameter_list_values_set(parameters,
 182                                       hkl, ARRAY_SIZE(hkl), NULL);
 183         res &= !hkl_engine_get(engine, NULL);
 184
 185         hkl[0] = -1, hkl[1] = 0, hkl[2] = 0;
 186         hkl_parameter_list_values_set(parameters,
 187                                       hkl, ARRAY_SIZE(hkl), NULL);
 188         res &= hkl_engine_get(engine, NULL);
 189         res &= check_pseudoaxes_v(engine, 180. * HKL_DEGTORAD);
 190
 191         hkl[0] = 0, hkl[1] = 0, hkl[2] = -1;
 192         hkl_parameter_list_values_set(parameters,
 193                                       hkl, ARRAY_SIZE(hkl), NULL);
 194         res &= hkl_engine_get(engine, NULL);
 195         res &= check_pseudoaxes_v(engine, 90. * HKL_DEGTORAD);
 196
 197         /* Q and <h, k, l>_ref are colinear so must FAIL */
 198         hkl[0] = 0, hkl[1] = -1, hkl[2] = 0;
 199         hkl_parameter_list_values_set(parameters,
 200                                       hkl, ARRAY_SIZE(hkl), NULL);
 201         res &= !hkl_engine_get(engine, NULL);
 202
 203         ok(res == HKL_TRUE, "psi getter");
 204
 205         hkl_engine_list_free(engines);
 206         hkl_detector_free(detector);
 207         hkl_sample_free(sample);
 208         hkl_geometry_free(geometry);
 209 }
 210
 211 static void psi_setter(void)
 212 {
 213         int res = HKL_TRUE;
 214         HklEngineList *engines;
 215         HklEngine *engine;
 216         HklMode **mode;
 217         darray_mode *modes;
 218         const HklFactory *factory;
 219         HklGeometry *geometry;
 220         const HklGeometryList *geometries;
 221         HklDetector *detector;
 222         HklSample *sample;
 223         static double hkl[] = {1, 0, 0};
 224         HklParameterList *pseudo_axes;
 225
 226         factory = hkl_factory_get_by_name("E4CH");
 227         geometry = hkl_factory_create_new_geometry(factory);
 228         sample = hkl_sample_new("test");
 229
 230         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 231         hkl_detector_idx_set(detector, 1);
 232
 233         engines = hkl_factory_create_new_engine_list(factory);
 234         hkl_engine_list_init(engines, geometry, detector, sample);
 235         geometries = hkl_engine_list_geometries(engines);
 236
 237         engine = hkl_engine_list_get_by_name(engines, "psi");
 238         modes = hkl_engine_modes(engine);
 239         pseudo_axes = hkl_engine_pseudo_axes(engine);
 240
 241         /* the init part */
 242         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 243         hkl_parameter_list_values_set(hkl_mode_parameters(hkl_engine_mode(engine)),
 244                                       hkl, ARRAY_SIZE(hkl), NULL);
 245         hkl_engine_initialize(engine, NULL);
 246
 247         darray_foreach(mode, *modes){
 248                 double psi;
 249
 250                 hkl_engine_select_mode(engine, *mode);
 251                 for(psi=-180 * HKL_DEGTORAD;psi<180 * HKL_DEGTORAD;psi += HKL_DEGTORAD){
 252                         hkl_parameter_list_values_set(pseudo_axes, &psi, 1, NULL);
 253                         if(hkl_engine_set(engine, NULL)){
 254                                 const darray_item *items = hkl_geometry_list_items_get(geometries);
 255                                 HklGeometryListItem **item;
 256
 257                                 darray_foreach(item, *items){
 258                                         static double null[] = {0};
 259
 260                                         hkl_parameter_list_values_set(pseudo_axes,
 261                                                                       null, ARRAY_SIZE(null),
 262                                                                       NULL);
 263                                         hkl_geometry_set(geometry,
 264                                                          hkl_geometry_list_item_geometry_get(*item));
 265                                         hkl_engine_get(engine, NULL);
 266                                         res &= check_pseudoaxes_v(engine, psi);
 267                                 }
 268                         }
 269                 }
 270         }
 271
 272         ok(res == HKL_TRUE, "psi setter");
 273
 274         hkl_engine_list_free(engines);
 275         hkl_detector_free(detector);
 276         hkl_sample_free(sample);
 277         hkl_geometry_free(geometry);
 278 }
 279
 280
 281 static void q(void)
 282 {
 283         int res = HKL_TRUE;
 284         HklEngineList *engines;
 285         HklEngine *engine;
 286         HklMode **mode;
 287         darray_mode *modes;
 288         const HklFactory *factory;
 289         HklGeometry *geometry;
 290         const HklGeometryList *geometries;
 291         HklDetector *detector;
 292         HklSample *sample;
 293         HklParameterList *pseudo_axes;
 294
 295         factory = hkl_factory_get_by_name("E4CH");
 296         geometry = hkl_factory_create_new_geometry(factory);
 297         sample = hkl_sample_new("test");
 298
 299         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 300         hkl_detector_idx_set(detector, 1);
 301
 302         engines = hkl_factory_create_new_engine_list(factory);
 303         hkl_engine_list_init(engines, geometry, detector, sample);
 304         geometries = hkl_engine_list_geometries(engines);
 305
 306         engine = hkl_engine_list_get_by_name(engines, "q");
 307         modes = hkl_engine_modes(engine);
 308         pseudo_axes = hkl_engine_pseudo_axes(engine);
 309
 310         /* the init part */
 311         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 312         hkl_engine_initialize(engine, NULL);
 313
 314         darray_foreach(mode, *modes){
 315                 double q;
 316
 317                 hkl_engine_select_mode(engine, *mode);
 318                 for(q=-1.; q<1.; q += 0.1){
 319                         hkl_parameter_list_values_set(pseudo_axes, &q, 1, NULL);
 320
 321                         if(hkl_engine_set(engine, NULL)){
 322                                 const darray_item *items = hkl_geometry_list_items_get(geometries);
 323                                 HklGeometryListItem **item;
 324
 325                                 darray_foreach(item, *items){
 326                                         static double null[] = {0};
 327                                         hkl_parameter_list_values_set(pseudo_axes,
 328                                                                       null, ARRAY_SIZE(null),
 329                                                                       NULL);
 330
 331                                         hkl_geometry_set(geometry,
 332                                                          hkl_geometry_list_item_geometry_get(*item));
 333                                         hkl_engine_get(engine, NULL);
 334                                         res &= check_pseudoaxes(engine, &q, 1);
 335                                 }
 336                         }
 337                 }
 338         }
 339
 340         ok(res == HKL_TRUE, "q");
 341
 342         hkl_engine_list_free(engines);
 343         hkl_detector_free(detector);
 344         hkl_sample_free(sample);
 345         hkl_geometry_free(geometry);
 346 }
 347
 348 static void hkl_psi_constant_horizontal(void)
 349 {
 350         int res = HKL_TRUE;
 351         HklEngineList *engines;
 352         HklEngine *engine;
 353         HklMode *mode;
 354         const HklFactory *factory;
 355         HklGeometry *geometry;
 356         const HklGeometryList *geometries;
 357         HklDetector *detector;
 358         HklSample *sample;
 359         static double hkl[] = {1, 0, 1};
 360         static double hkl2[] = {1, 1, 0};
 361         HklParameterList *pseudo_axes;
 362
 363         factory = hkl_factory_get_by_name("E4CH");
 364         geometry = hkl_factory_create_new_geometry(factory);
 365         sample = hkl_sample_new("test");
 366
 367         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 368         hkl_detector_idx_set(detector, 1);
 369
 370         engines = hkl_factory_create_new_engine_list(factory);
 371         hkl_engine_list_init(engines, geometry, detector, sample);
 372         geometries = hkl_engine_list_geometries(engines);
 373
 374         engine = hkl_engine_list_get_by_name(engines, "hkl");
 375         mode = hkl_engine_mode(engine);
 376         pseudo_axes = hkl_engine_pseudo_axes(engine);
 377
 378         hkl_engine_select_mode_by_name(engine,
 379                                        "psi_constant");
 380
 381         /* the init part */
 382         hkl_geometry_set_values_unit_v(geometry, 30., 0., 0., 60.);
 383         hkl_parameter_list_values_set(hkl_mode_parameters(mode),
 384                                       hkl2, ARRAY_SIZE(hkl2), NULL);
 385         hkl_engine_initialize(engine, NULL);
 386
 387         hkl_parameter_list_values_set(pseudo_axes,
 388                                       hkl, ARRAY_SIZE(hkl), NULL);
 389         if(hkl_engine_set(engine, NULL)){
 390                 const darray_item *items = hkl_geometry_list_items_get(geometries);
 391                 HklGeometryListItem **item;
 392
 393                 darray_foreach(item, *items){
 394                         static double null[] = {0, 0, 0};
 395
 396                         hkl_parameter_list_values_set(pseudo_axes,
 397                                                       null, ARRAY_SIZE(null),
 398                                                       NULL);
 399                         hkl_geometry_set(geometry,
 400                                          hkl_geometry_list_item_geometry_get(*item));
 401                         hkl_engine_get(engine, NULL);
 402                         res &= check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl));
 403                 }
 404         }
 405
 406         ok(res == HKL_TRUE, "psi constant horizontal");
 407
 408         hkl_engine_list_free(engines);
 409         hkl_detector_free(detector);
 410         hkl_sample_free(sample);
 411         hkl_geometry_free(geometry);
 412 }
 413
 414 int main(int argc, char** argv)
 415 {
 416         plan(6);
 417
 418         getter();
 419         degenerated();
 420         psi_getter();
 421         psi_setter();
 422         q();
 423         hkl_psi_constant_horizontal();
 424
 425         return 0;
 426 }