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