tests/hkl-pseudoaxis-k6c-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-2014 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 degenerated(void)
  27 {
  28         int res = TRUE;
  29         HklEngineList *engines;
  30         HklEngine *engine;
  31         const darray_string *modes;
  32         const char **mode;
  33         const HklFactory *factory;
  34         HklGeometry *geometry;
  35         HklDetector *detector;
  36         HklSample *sample;
  37         static double hkl[] = {0, 1, 0};
  38
  39         factory = hkl_factory_get_by_name("K6C", NULL);
  40         geometry = hkl_factory_create_new_geometry(factory);
  41         sample = hkl_sample_new("test");
  42
  43         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  44
  45         engines = hkl_factory_create_new_engine_list(factory);
  46         hkl_engine_list_init(engines, geometry, detector, sample);
  47
  48         engine = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
  49         modes = hkl_engine_modes_names_get(engine);
  50
  51         darray_foreach(mode, *modes){
  52                 const darray_string *parameters;
  53                 HklGeometryList *geometries;
  54
  55                 hkl_engine_current_mode_set(engine, *mode, NULL);
  56                 parameters = hkl_engine_parameters_names_get(engine);
  57                 if (!strcasecmp(*mode, "constant_chi_vertical")){
  58                         size_t n_params = darray_size(*parameters);
  59                         double params[n_params];
  60
  61                         hkl_engine_parameters_values_get(engine,
  62                                                          params, n_params,
  63                                                          HKL_UNIT_DEFAULT);
  64                         params[0] = 1;
  65                         hkl_engine_parameters_values_set(engine,
  66                                                          params, n_params,
  67                                                          HKL_UNIT_DEFAULT, NULL);
  68                 }
  69                 if (!strcasecmp(*mode, "constant_incidence")){
  70                         size_t n_params = darray_size(*parameters);
  71                         double params[n_params];
  72
  73                         hkl_engine_parameters_values_get(engine,
  74                                                          params, n_params,
  75                                                          HKL_UNIT_DEFAULT);
  76                         params[3] = 1;
  77                         hkl_engine_parameters_values_set(engine,
  78                                                          params, n_params,
  79                                                          HKL_UNIT_DEFAULT, NULL);
  80                 }
  81
  82                 /* studdy this degenerated case */
  83                 geometries = hkl_engine_pseudo_axes_values_set(engine,
  84                                                                 hkl, ARRAY_SIZE(hkl),
  85                                                                 HKL_UNIT_DEFAULT, NULL);
  86                 if (geometries){
  87                         const HklGeometryListItem *item;
  88
  89                         HKL_GEOMETRY_LIST_FOREACH(item, geometries){
  90                                 hkl_geometry_set(geometry, hkl_geometry_list_item_geometry_get(item));
  91                                 res &= DIAG(check_pseudoaxes(engine, hkl, ARRAY_SIZE(hkl)));
  92                         }
  93                         hkl_geometry_list_free(geometries);
  94                 }
  95         }
  96
  97         ok(res == TRUE, "degenerated");
  98
  99         hkl_engine_list_free(engines);
 100         hkl_detector_free(detector);
 101         hkl_sample_free(sample);
 102         hkl_geometry_free(geometry);
 103 }
 104
 105 static void eulerians(void)
 106 {
 107         int res = TRUE;
 108         HklEngineList *engines;
 109         HklEngine *engine;
 110         const darray_string *modes;
 111         const char **mode;
 112         const HklGeometryListItem *item;
 113         const HklFactory *factory;
 114         HklGeometry *geometry;
 115         HklDetector *detector;
 116         HklSample *sample;
 117
 118         factory = hkl_factory_get_by_name("K6C", NULL);
 119         geometry = hkl_factory_create_new_geometry(factory);
 120         sample = hkl_sample_new("test");
 121
 122         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 123
 124         engines = hkl_factory_create_new_engine_list(factory);
 125         hkl_engine_list_init(engines, geometry, detector, sample);
 126
 127         engine = hkl_engine_list_engine_get_by_name(engines, "eulerians", NULL);
 128         modes = hkl_engine_modes_names_get(engine);
 129
 130         darray_foreach(mode, *modes){
 131                 double omega, chi, phi;
 132                 const darray_string *parameters;
 133                 HklGeometryList *geometries;
 134                 size_t n_params;
 135
 136                 hkl_engine_current_mode_set(engine, *mode, NULL);
 137                 parameters = hkl_engine_parameters_names_get(engine);
 138                 n_params = darray_size(*parameters);
 139                 if (n_params){
 140                         double params[n_params];
 141
 142                         hkl_engine_parameters_values_get(engine,
 143                                                          params, n_params,
 144                                                          HKL_UNIT_DEFAULT);
 145                         params[0] = 1;
 146                         hkl_engine_parameters_values_set(engine,
 147                                                          params, n_params,
 148                                                          HKL_UNIT_DEFAULT, NULL);
 149                 }
 150
 151                 /* studdy this degenerated case */
 152                 geometries = hkl_engine_set_values_v(engine, 0., 90. * HKL_DEGTORAD, 0.);
 153                 if (geometries) {
 154                         res &= DIAG(hkl_geometry_list_n_items_get(geometries) == 2);
 155
 156                         /* first solution = -180, -90, 180 */
 157                         item = hkl_geometry_list_items_first_get(geometries);
 158                         hkl_geometry_set(geometry,
 159                                          hkl_geometry_list_item_geometry_get(item));
 160                         res &= DIAG(check_pseudoaxes_v(engine, -180. * HKL_DEGTORAD, -90. * HKL_DEGTORAD, 180. * HKL_DEGTORAD));
 161
 162                         /* second solution = 0, 90, 0 */
 163                         item = hkl_geometry_list_items_next_get(geometries, item);
 164                         hkl_geometry_set(geometry,
 165                                          hkl_geometry_list_item_geometry_get(item));
 166                         res &= DIAG(check_pseudoaxes_v(engine, 0., 90. * HKL_DEGTORAD, 0.));
 167
 168                         /* no more solution */
 169                         res &= DIAG(hkl_geometry_list_items_next_get(geometries, item) == NULL);
 170
 171                         hkl_geometry_list_free(geometries);
 172                 }
 173         }
 174
 175         ok(res == TRUE, "eulerians");
 176
 177         hkl_engine_list_free(engines);
 178         hkl_detector_free(detector);
 179         hkl_sample_free(sample);
 180         hkl_geometry_free(geometry);
 181 }
 182
 183 static void q2(void)
 184 {
 185         int res = TRUE;
 186         HklEngineList *engines;
 187         HklEngine *engine;
 188         const darray_string *modes;
 189         const char **mode;
 190         const HklFactory *factory;
 191         HklGeometry *geometry;
 192         HklDetector *detector;
 193         HklSample *sample;
 194
 195         factory = hkl_factory_get_by_name("K6C", NULL);
 196         geometry = hkl_factory_create_new_geometry(factory);
 197         sample = hkl_sample_new("test");
 198
 199         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 200
 201         engines = hkl_factory_create_new_engine_list(factory);
 202         hkl_engine_list_init(engines, geometry, detector, sample);
 203
 204         engine = hkl_engine_list_engine_get_by_name(engines, "q2", NULL);
 205         modes = hkl_engine_modes_names_get(engine);
 206
 207         /* the init part */
 208         hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 30., 0., 0., 0., 60.);
 209         hkl_engine_initialized_set(engine, TRUE, NULL);
 210
 211         darray_foreach(mode, *modes){
 212                 double q, alpha;
 213
 214                 hkl_engine_current_mode_set(engine, *mode, NULL);
 215                 for(q=0.1; q<1.; q += 0.1)
 216                         for(alpha = -M_PI; alpha<M_PI; alpha += M_PI/180.){
 217                                 double values[] = {q, alpha};
 218                                 HklGeometryList *geometries;
 219
 220                                 geometries = hkl_engine_pseudo_axes_values_set(engine,
 221                                                                                values, ARRAY_SIZE(values),
 222                                                                                HKL_UNIT_DEFAULT, NULL);
 223                                 if(geometries){
 224                                         const HklGeometryListItem *item;
 225
 226                                         HKL_GEOMETRY_LIST_FOREACH(item, geometries){
 227                                                 hkl_geometry_set(geometry,
 228                                                                  hkl_geometry_list_item_geometry_get(item));
 229                                                 res &= DIAG(check_pseudoaxes(engine, values, 2));
 230                                         }
 231                                         hkl_geometry_list_free(geometries);
 232                                 }
 233                         }
 234         }
 235
 236         ok(res == TRUE, "q2");
 237
 238         hkl_engine_list_free(engines);
 239         hkl_detector_free(detector);
 240         hkl_sample_free(sample);
 241         hkl_geometry_free(geometry);
 242 }
 243
 244
 245 static void m15110(void)
 246 {
 247         int res = TRUE;
 248         HklEngineList *engines;
 249         HklEngine *engine;
 250         const HklFactory *factory;
 251         HklGeometry *geometry;
 252         HklDetector *detector;
 253         HklSample *sample;
 254
 255         factory = hkl_factory_get_by_name("K6C", NULL);
 256         geometry = hkl_factory_create_new_geometry(factory);
 257         sample = hkl_sample_new("test");
 258
 259         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 260
 261         engines = hkl_factory_create_new_engine_list(factory);
 262         hkl_engine_list_init(engines, geometry, detector, sample);
 263
 264         engine = hkl_engine_list_engine_get_by_name(engines, "psi", NULL);
 265
 266         /* the init part must succed */
 267         hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 62.95, 134.75, 0., 0., 60.);
 268         res &= DIAG(hkl_engine_initialized_set(engine, TRUE, NULL));
 269
 270         hkl_engine_list_free(engines);
 271         hkl_detector_free(detector);
 272         hkl_sample_free(sample);
 273         hkl_geometry_free(geometry);
 274
 275         ok(res == TRUE, "m15110");
 276 }
 277
 278 int main(int argc, char** argv)
 279 {
 280         plan(4);
 281
 282         degenerated();
 283         eulerians();
 284         q2();
 285         m15110();
 286
 287         return 0;
 288 }