tests/hkl-bench-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-2016 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 <stdio.h>
  23 #include <sys/time.h>
  24 #include <tap/basic.h>
  25 #include "hkl.h"
  26
  27 static void hkl_test_bench_run_real(HklEngine *engine, HklGeometry *geometry,
  28                                     double values[], size_t n_values, size_t n)
  29 {
  30         size_t i;
  31         const darray_string *modes = hkl_engine_modes_names_get(engine);
  32         const char **mode;
  33
  34         /* pseudo -> geometry */
  35         darray_foreach(mode, *modes){
  36                 double min, max, mean;
  37                 const darray_string *parameters;
  38                 size_t n_params;
  39
  40                 if (FALSE == hkl_engine_current_mode_set(engine, *mode, NULL))
  41                         continue;
  42
  43                 parameters = hkl_engine_parameters_names_get(engine);
  44                 n_params = darray_size(*parameters);
  45                 if (n_params){
  46                         double params[n_params];
  47
  48                         hkl_engine_parameters_values_get(engine,
  49                                                          params, n_params,
  50                                                          HKL_UNIT_DEFAULT);
  51                         values[0] = 1;
  52                         if(FALSE == hkl_engine_parameters_values_set(engine,
  53                                                                      params, n_params,
  54                                                                      HKL_UNIT_DEFAULT, NULL))
  55                                 continue;
  56                 }
  57
  58                 mean = max = 0;
  59                 min = 1000; /* arbitrary value always greater than the real min */
  60                 for(i=0; i<n; ++i){
  61                         struct timeval debut, fin, dt;
  62                         double t;
  63                         HklGeometryList *solutions;
  64
  65                         if(FALSE == hkl_geometry_set_values_v(geometry, HKL_UNIT_USER, NULL, 0., 0., 0., 0., 10., 10.))
  66                                 break;
  67                         gettimeofday(&debut, NULL);
  68                         solutions = hkl_engine_pseudo_axis_values_set(engine, values, n_values, HKL_UNIT_DEFAULT, NULL);
  69                         if (NULL != solutions)
  70                                 hkl_geometry_list_free(solutions);
  71                         gettimeofday(&fin, NULL);
  72                         timersub(&fin, &debut, &dt);
  73                         t = dt.tv_sec * 1000. + dt.tv_usec / 1000.;
  74                         min = t < min ? t : min;
  75                         max = t > max ? t : max;
  76                         mean += t;
  77                 }
  78                 fprintf(stdout, "\"%s\" \"%s\" \"%s\" (%d/%d) iterations %f / %f / %f [min/mean/max] ms each\n",
  79                         hkl_geometry_name_get(geometry),
  80                         hkl_engine_name_get(engine),
  81                         *mode, n, i, min, mean/n, max);
  82         }
  83 }
  84
  85 static void hkl_test_bench_run_v(HklEngineList *engines, HklGeometry *geometry,
  86                                  char const *name, unsigned int n, ...)
  87 {
  88         va_list ap;
  89         size_t i;
  90         HklEngine *engine = hkl_engine_list_engine_get_by_name(engines, name, NULL);
  91         size_t n_values = darray_size(*hkl_engine_pseudo_axis_names_get(engine));
  92         double values[n_values];
  93
  94         va_start(ap, n);
  95         for(i=0; i<n_values; ++i)
  96                 values[i] = va_arg(ap, double);
  97         va_end(ap);
  98
  99         hkl_test_bench_run_real(engine, geometry, values, n_values, n);
 100 }
 101
 102 static void hkl_test_bench_k6c(int n)
 103 {
 104         const HklFactory *factory;
 105         HklEngineList *engines;
 106         HklGeometry *geom;
 107         HklDetector *detector;
 108         HklSample *sample;
 109
 110         factory = hkl_factory_get_by_name("K6C", NULL);
 111
 112         geom = hkl_factory_create_new_geometry(factory);
 113
 114         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 115
 116         sample = hkl_sample_new("test");
 117
 118         engines = hkl_factory_create_new_engine_list(factory);
 119         hkl_engine_list_init(engines, geom, detector, sample);
 120
 121         hkl_test_bench_run_v(engines, geom, "hkl", n, 1., 0., 0.);
 122         hkl_test_bench_run_v(engines, geom, "eulerians", n, 0., 90*HKL_DEGTORAD, 0.);
 123         hkl_test_bench_run_v(engines, geom, "psi", n, 10.*HKL_DEGTORAD);
 124         hkl_test_bench_run_v(engines, geom, "q2", n, 1., 10.*HKL_DEGTORAD);
 125         hkl_test_bench_run_v(engines, geom, "qper_qpar", n, 1., 1.);
 126
 127         hkl_engine_list_free(engines);
 128         hkl_sample_free(sample);
 129         hkl_detector_free(detector);
 130         hkl_geometry_free(geom);
 131 }
 132
 133 static void hkl_test_bench_eulerians(void)
 134 {
 135         HklEngineList *engines;
 136         HklEngine *engine;
 137         const char **mode;
 138         const darray_string *modes;
 139         const HklFactory *factory;
 140         HklGeometry *geometry;
 141         HklDetector *detector;
 142         HklSample *sample;
 143
 144         factory = hkl_factory_get_by_name("K6C", NULL);
 145
 146         geometry = hkl_factory_create_new_geometry(factory);
 147         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 148
 149         sample = hkl_sample_new("test");
 150         engines = hkl_factory_create_new_engine_list(factory);
 151         hkl_engine_list_init(engines, geometry, detector, sample);
 152
 153         engine = hkl_engine_list_engine_get_by_name(engines, "eulerians", NULL);
 154         modes = hkl_engine_modes_names_get(engine);
 155
 156         darray_foreach(mode, *modes){
 157                 static double values[3] = {0, 90 * HKL_DEGTORAD, 0};
 158                 HklGeometryList *solutions;
 159
 160                 if(FALSE == hkl_engine_current_mode_set(engine, *mode, NULL))
 161                         continue;
 162
 163                 /* studdy this degenerated case */
 164                 solutions = hkl_engine_pseudo_axis_values_set(engine,
 165                                                                values, ARRAY_SIZE(values),
 166                                                                HKL_UNIT_DEFAULT, NULL);
 167                 if (solutions) {
 168                         const HklGeometryListItem *item;
 169
 170                         HKL_GEOMETRY_LIST_FOREACH(item, solutions){
 171                                 hkl_geometry_set(geometry,
 172                                                  hkl_geometry_list_item_geometry_get(item));
 173                                 if(FALSE == hkl_engine_pseudo_axis_values_get(engine, values, ARRAY_SIZE(values),
 174                                                                               HKL_UNIT_DEFAULT, NULL))
 175                                         break;
 176                         }
 177                         hkl_geometry_list_free(solutions);
 178                 }
 179         }
 180
 181         hkl_engine_list_free(engines);
 182         hkl_sample_free(sample);
 183         hkl_detector_free(detector);
 184         hkl_geometry_free(geometry);
 185 }
 186
 187 int main(int argc, char **argv)
 188 {
 189         int n;
 190
 191         plan(1);
 192
 193         if (argc > 1)
 194                 n = atoi(argv[1]);
 195         else
 196                 n = 10;
 197
 198         hkl_test_bench_k6c(n);
 199         hkl_test_bench_eulerians();
 200
 201         ok(TRUE == TRUE, __func__);
 202
 203         return 0;
 204 }