tests/hkl-pseudoaxis-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  */
  22 #include <alloca.h>
  23 #include <string.h>
  24 #include "hkl.h"
  25 #include <tap/basic.h>
  26
  27 #define with_log 1
  28
  29 static int test_engine(HklEngine *engine, HklEngineList *engine_list, unsigned int n)
  30 {
  31         uint i;
  32         int unreachable = 0;
  33         int ko = HKL_FALSE;
  34         const char **mode;
  35         const HklGeometryList *geometries = hkl_engine_list_geometries_get(engine_list);
  36         HklGeometry *geometry = hkl_engine_list_geometry_get(engine_list);
  37         const darray_string *modes = hkl_engine_modes_get(engine);
  38         const darray_string *pseudo_axes = hkl_engine_pseudo_axes_names_get(engine);
  39         const size_t n_pseudo_axes = darray_size(*pseudo_axes);
  40         double targets[n_pseudo_axes];
  41         double currents[n_pseudo_axes];
  42         double garbages[n_pseudo_axes];
  43
  44         /* randomize the geometry */
  45         hkl_geometry_randomize(geometry);
  46
  47         darray_foreach(mode, *modes){
  48                 hkl_engine_select_mode(engine, *mode);
  49                 /* for now unactive the eulerians check */
  50                 if(!strcmp(*mode, "eulerians"))
  51                         continue;
  52                 unreachable = 0;
  53
  54                 for(i=0;i<n && !ko;++i) {
  55                         size_t j;
  56                         HklParameter **pseudo_axis;
  57
  58                         /* randomize the pseudoAxes values */
  59                         hkl_engine_pseudo_axes_randomize(engine);
  60                         hkl_engine_pseudo_axes_values_get(engine, targets, n_pseudo_axes);
  61
  62                         /* randomize the parameters */
  63                         hkl_engine_parameters_randomize(engine);
  64
  65                         /* pseudo -> geometry */
  66                         hkl_engine_initialize(engine, NULL);
  67
  68                         /* geometry -> pseudo */
  69                         if(hkl_engine_set(engine, NULL)) {
  70                                 const HklGeometryListItem *item;
  71
  72                                 HKL_GEOMETRY_LIST_FOREACH(item, geometries){
  73                                         /* first modify the pseudoAxes values */
  74                                         /* to be sure that the result is the */
  75                                         /* computed result. */
  76
  77                                         hkl_engine_pseudo_axes_values_set(engine,
  78                                                                           garbages, n_pseudo_axes,
  79                                                                           NULL);
  80
  81                                         hkl_geometry_set(geometry,
  82                                                          hkl_geometry_list_item_geometry_get(item));
  83                                         hkl_engine_get(engine, NULL);
  84
  85                                         hkl_engine_pseudo_axes_values_get(engine,
  86                                                                           currents, n_pseudo_axes);
  87                                         for(j=0; j<n_pseudo_axes; ++j)
  88                                                 ko |= fabs(targets[j] - currents[j]) >= HKL_EPSILON;
  89                                         if(ko)
  90                                                 break;
  91                                 }
  92                         }else
  93                                 unreachable++;
  94                 }
  95 #if with_log
  96                 fprintf(stderr, "\n\"%s\" \"%s\" \"%s\"",
  97                         hkl_geometry_name_get(geometry),
  98                         hkl_engine_name_get(engine),
  99                         *mode);
 100                 fprintf(stderr, " unreachable : %d/%d", unreachable, i);
 101                 if(ko){
 102                         fprintf(stderr, " ko");
 103                         /* print the hkl internals if the test failed */
 104                         fprintf(stderr, "\n    expected : ");
 105                         for(uint j=0; j<n_pseudo_axes; ++j)
 106                                 fprintf(stderr, " %f", targets[j]);
 107                         fprintf(stderr, " obtained : ");
 108                         for(uint j=0; j<n_pseudo_axes; ++j)
 109                                 fprintf(stderr, " %f", currents[j]);
 110                         hkl_engine_fprintf(stderr, engine);
 111                         exit(0);
 112                 }else{
 113                         fprintf(stderr, " ok");
 114                 }
 115 #endif
 116         }
 117
 118         return !ko;
 119 }
 120
 121 static int test_engines(HklEngineList *engine_list, int n)
 122 {
 123         int res = HKL_TRUE;
 124         HklEngine **engine;
 125         darray_engine *engines = hkl_engine_list_engines_get(engine_list);
 126
 127         darray_foreach(engine, *engines){
 128                 res &= test_engine(*engine, engine_list, n);
 129         }
 130
 131 #if with_log
 132         fprintf(stderr, "\n");
 133 #endif
 134         return res;
 135 }
 136
 137 static void factories(void)
 138 {
 139         int res = HKL_TRUE;
 140         uint i, n;
 141         HklEngineList *engines;
 142         HklFactory **factories;
 143
 144         factories = hkl_factory_get_all(&n);
 145         for(i=0;i<n; i++){
 146                 engines = hkl_factory_create_new_engine_list(factories[i]);
 147                 hkl_engine_list_free(engines);
 148         }
 149
 150         ok(res == HKL_TRUE, "factories");
 151 }
 152
 153 static void set(int nb_iter)
 154 {
 155         HklFactory **factories;
 156         unsigned int i, n;
 157         HklGeometry *geometry = NULL;
 158         HklDetector *detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 159         HklSample *sample = hkl_sample_new("test");
 160         HklEngineList *engines;
 161         int res = HKL_TRUE;
 162
 163         /* attach to the second holder */
 164         hkl_detector_idx_set(detector, 1);
 165
 166         factories = hkl_factory_get_all(&n);
 167         for(i=0; i<n; i++){
 168                 geometry = hkl_factory_create_new_geometry(factories[i]);
 169                 engines = hkl_factory_create_new_engine_list(factories[i]);
 170                 hkl_engine_list_init(engines, geometry, detector, sample);
 171                 res &= test_engines(engines, nb_iter);
 172                 hkl_geometry_free(geometry);
 173                 hkl_engine_list_free(engines);
 174         }
 175
 176         hkl_detector_free(detector);
 177         hkl_sample_free(sample);
 178
 179         ok(res == HKL_TRUE, "set");
 180 }
 181
 182 int main(int argc, char** argv)
 183 {
 184         double n;
 185
 186         plan(2);
 187
 188         if (argc > 1)
 189                 n = atoi(argv[1]);
 190         else
 191                 n = 10;
 192
 193         factories();
 194         set(n);
 195
 196         return 0;
 197 }