test/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-2011 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 <hkl.h>
  24 #include <tap/basic.h>
  25
  26 #define with_log 1
  27 #define N 4
  28
  29 static int test_engine(HklPseudoAxisEngine *engine, HklGeometry *geometry,
  30                        HklDetector *detector, HklSample *sample, int n)
  31 {
  32         size_t i, j, k, f_idx;
  33         double *values = alloca(engine->pseudoAxes_len * sizeof(*values));
  34         int unreachable = 0;
  35         int ko = HKL_FALSE;
  36
  37         /* randomize the geometry */
  38         hkl_geometry_randomize(geometry);
  39
  40         for(f_idx=0; f_idx<engine->modes_len; ++f_idx) {
  41                 size_t len;
  42
  43                 hkl_pseudo_axis_engine_select_mode(engine, f_idx);
  44                 /* for now unactive the eulerians check */
  45                 if(!strcmp(engine->mode->name, "eulerians"))
  46                         continue;
  47                 unreachable = 0;
  48
  49                 len = engine->pseudoAxes_len;
  50                 for(i=0;i<n && !ko;++i) {
  51                         /* randomize the pseudoAxes values */
  52                         for(j=0; j<len; ++j) {
  53                                 HklParameter *parameter = (HklParameter *)(engine->pseudoAxes[j]);
  54                                 hkl_parameter_randomize(parameter);
  55
  56                                 values[j] = parameter->value;
  57                         }
  58
  59                         /* randomize the parameters */
  60                         for(j=0; j<engine->mode->parameters_len; ++j)
  61                                 hkl_parameter_randomize(&engine->mode->parameters[j]);
  62
  63                         /* pseudo -> geometry */
  64                         hkl_pseudo_axis_engine_initialize(engine, NULL);
  65                         /* hkl_pseudo_axis_engine_fprintf(stderr, engine); */
  66
  67                         /* geometry -> pseudo */
  68                         if(hkl_pseudo_axis_engine_set(engine, NULL)) {
  69                                 for(j=0; j<engine->engines->geometries->len && !ko; ++j) {
  70                                         /* first modify the pseudoAxes values */
  71                                         /* to be sure that the result is the */
  72                                         /* computed result. */
  73                                         for(k=0; k<len; ++k)
  74                                                 ((HklParameter *)engine->pseudoAxes[k])->value = 0.;
  75
  76                                         hkl_geometry_init_geometry(geometry,
  77                                                                    engine->engines->geometries->items[j].geometry);
  78                                         hkl_pseudo_axis_engine_get(engine, NULL);
  79
  80                                         for(k=0; k<len; ++k)
  81                                                 ko |= fabs(values[k] - ((HklParameter *)engine->pseudoAxes[k])->value) >= HKL_EPSILON;
  82                                 }
  83                         }else
  84                                 unreachable++;
  85                 }
  86 #if with_log
  87                 fprintf(stderr, "\n\"%s\" \"%s\" \"%s\"",
  88                         engine->geometry->config->name,
  89                         engine->name,
  90                         engine->mode->name);
  91                 fprintf(stderr, " unreachable : %d/%d", unreachable, i);
  92                 if(ko){
  93                         fprintf(stderr, " ko");
  94                         /* print the hkl internals if the test failed */
  95                         fprintf(stderr, "\n    expected : ");
  96                         for(k=0; k<len; ++k)
  97                                 fprintf(stderr, " %f", values[k]);
  98                         fprintf(stderr, " obtained : ");
  99                         for(k=0; k<len; ++k)
 100                                 fprintf(stderr, " %f", ((HklParameter *)engine->pseudoAxes[k])->value);
 101                         hkl_pseudo_axis_engine_fprintf(stdout, engine);
 102                 }else{
 103                         fprintf(stderr, " ok");
 104                 }
 105 #endif
 106         }
 107
 108         return !ko;
 109 }
 110
 111 static int test_engines(HklPseudoAxisEngineList *engines, int n)
 112 {
 113         int res = HKL_TRUE;
 114
 115         size_t i;
 116         for(i=0; i<engines->len; ++i)
 117                 res &= test_engine(engines->engines[i],
 118                                    engines->geometry,
 119                                    engines->detector,
 120                                    engines->sample,
 121                                    n);
 122
 123 #if with_log
 124         fprintf(stderr, "\n");
 125 #endif
 126         return res;
 127 }
 128
 129 static void set(void)
 130 {
 131         const HklGeometryConfig *config;
 132         HklGeometry *geometry = NULL;
 133         HklDetector *detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 134         HklSample *sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
 135         HklPseudoAxisEngineList *engines;
 136         int res = HKL_TRUE;
 137
 138         /* attach to the second holder */
 139         detector->idx = 1;
 140
 141         /* test all E4CV engines */
 142         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_EULERIAN4C_VERTICAL);
 143         geometry = hkl_geometry_factory_new(config);
 144         engines = hkl_pseudo_axis_engine_list_factory(config);
 145         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 146         res &= test_engines(engines, N);
 147         hkl_geometry_free(geometry);
 148         hkl_pseudo_axis_engine_list_free(engines);
 149
 150         /* test all E6C HKL engines */
 151         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_EULERIAN6C);
 152         geometry = hkl_geometry_factory_new(config);
 153         engines = hkl_pseudo_axis_engine_list_factory(config);
 154         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 155         res &= test_engines(engines, N);
 156         hkl_geometry_free(geometry);
 157         hkl_pseudo_axis_engine_list_free(engines);
 158
 159         /* test all K4CV HKL engines */
 160         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA4C_VERTICAL);
 161         geometry = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 162         engines = hkl_pseudo_axis_engine_list_factory(config);
 163         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 164         res &= test_engines(engines, N);
 165         hkl_geometry_free(geometry);
 166         hkl_pseudo_axis_engine_list_free(engines);
 167
 168         /* test all K6C engines */
 169         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
 170         geometry = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 171         engines = hkl_pseudo_axis_engine_list_factory(config);
 172         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 173         res &= test_engines(engines, N);
 174         hkl_geometry_free(geometry);
 175         hkl_pseudo_axis_engine_list_free(engines);
 176
 177         /* test all ZAXIS engines */
 178         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_ZAXIS);
 179         geometry = hkl_geometry_factory_new(config);
 180         engines = hkl_pseudo_axis_engine_list_factory(config);
 181         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 182         res &= test_engines(engines, N);
 183         hkl_geometry_free(geometry);
 184         hkl_pseudo_axis_engine_list_free(engines);
 185
 186         /* test all SOLEIL SIXS MED 2+2 engines */
 187         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_SOLEIL_SIXS_MED_2_2);
 188         geometry = hkl_geometry_factory_new(config);
 189         engines = hkl_pseudo_axis_engine_list_factory(config);
 190         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 191         res &= test_engines(engines, N);
 192         hkl_geometry_free(geometry);
 193         hkl_pseudo_axis_engine_list_free(engines);
 194
 195         /* test all SOLEIL MARS engines */
 196         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_SOLEIL_MARS);
 197         geometry = hkl_geometry_factory_new(config);
 198         engines = hkl_pseudo_axis_engine_list_factory(config);
 199         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 200         res &= test_engines(engines, N);
 201         hkl_geometry_free(geometry);
 202         hkl_pseudo_axis_engine_list_free(engines);
 203
 204         /* test all SOLEIL SIXS MED 1+2 engines */
 205         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_SOLEIL_SIXS_MED_1_2);
 206         geometry = hkl_geometry_factory_new(config);
 207         engines = hkl_pseudo_axis_engine_list_factory(config);
 208         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 209         res &= test_engines(engines, N);
 210         hkl_geometry_free(geometry);
 211         hkl_pseudo_axis_engine_list_free(engines);
 212
 213         /* test all PETRA3 P09 EH2 engines */
 214         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_PETRA3_P09_EH2);
 215         geometry = hkl_geometry_factory_new(config);
 216         engines = hkl_pseudo_axis_engine_list_factory(config);
 217         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 218         res &= test_engines(engines, N);
 219         hkl_geometry_free(geometry);
 220         hkl_pseudo_axis_engine_list_free(engines);
 221
 222         /* test all E4CH engines */
 223         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_EULERIAN4C_HORIZONTAL);
 224         geometry = hkl_geometry_factory_new(config);
 225         engines = hkl_pseudo_axis_engine_list_factory(config);
 226         hkl_pseudo_axis_engine_list_init(engines, geometry, detector, sample);
 227         res &= test_engines(engines, N);
 228         hkl_geometry_free(geometry);
 229         hkl_pseudo_axis_engine_list_free(engines);
 230
 231         hkl_detector_free(detector);
 232         hkl_sample_free(sample);
 233
 234         ok(res == HKL_TRUE, "set");
 235 }
 236
 237 int main(int argc, char** argv)
 238 {
 239         plan(1);
 240
 241         set();
 242
 243         return 0;
 244 }