tests/hkl-pseudoaxis-soleil-sixs-med-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-2010 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/float.h>
  25 #include <tap/hkl-tap.h>
  26
  27 #include "hkl-axis-private.h" /* temporary */
  28
  29 #define GET_GAMMA(geometries) hkl_parameter_value_get(                  \
  30                 hkl_geometry_axis_get(                                  \
  31                         hkl_geometry_list_item_geometry_get(            \
  32                                 hkl_geometry_list_items_first_get((geometries))), \
  33                         "gamma", NULL), HKL_UNIT_USER)
  34
  35 static void qper_qpar(void)
  36 {
  37         HklEngineList *engines;
  38         HklEngine *engine;
  39         const HklFactory *factory;
  40         HklGeometry *geom;
  41         HklDetector *detector;
  42         HklSample *sample;
  43         size_t i, f_idx;
  44         double qper_qpar[2];
  45         double gamma;
  46         HklGeometryList *geometries;
  47         HklMatrix *U;
  48
  49         factory = hkl_factory_get_by_name("SOLEIL SIXS MED2+3", NULL);
  50         geom = hkl_factory_create_new_geometry(factory);
  51
  52         sample = hkl_sample_new("test");
  53         U = hkl_matrix_new_euler(-90.0 * HKL_DEGTORAD, 0., 0.);
  54         hkl_sample_U_set(sample, U, NULL);
  55         hkl_matrix_free(U);
  56
  57         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  58
  59         engines = hkl_factory_create_new_engine_list(factory);
  60         hkl_engine_list_init(engines, geom, detector, sample);
  61
  62         engine = hkl_engine_list_engine_get_by_name(engines, "qper_qpar", NULL);
  63
  64         /* the init part */
  65         hkl_geometry_set_values_v(geom, HKL_UNIT_USER, NULL, 0., 0.1, 0., 0., 90., 0.);
  66         hkl_engine_initialized_set(engine, TRUE, NULL);
  67
  68         /* gamma must be positif */
  69         qper_qpar[0] = 0.1;
  70         qper_qpar[1] = 4.;
  71         geometries = hkl_engine_pseudo_axes_values_set(engine, qper_qpar, ARRAY_SIZE(qper_qpar),
  72                                                         HKL_UNIT_DEFAULT, NULL);
  73         if(geometries){
  74                 gamma = GET_GAMMA(geometries);
  75                 is_double(2.61077, gamma, HKL_EPSILON * 10, __func__);
  76                 hkl_geometry_list_free(geometries);
  77         }
  78
  79         /* gamma must be negatif */
  80         qper_qpar[0] = -0.1;
  81         qper_qpar[1] = 4.;
  82         geometries = hkl_engine_pseudo_axes_values_set(engine, qper_qpar, ARRAY_SIZE(qper_qpar),
  83                                                         HKL_UNIT_DEFAULT, NULL);
  84         if(geometries){
  85                 gamma = GET_GAMMA(geometries);
  86                 is_double(-2.7956354, gamma, HKL_EPSILON * 10, __func__);
  87                 hkl_geometry_list_free(geometries);
  88         }
  89
  90         hkl_engine_list_free(engines);
  91         hkl_detector_free(detector);
  92         hkl_sample_free(sample);
  93         hkl_geometry_free(geom);
  94 }
  95
  96 static void med_2_3(void)
  97 {
  98         int res = TRUE;
  99         HklEngineList *engines;
 100         HklEngine *hkl;
 101         const HklFactory *factory;
 102         const HklGeometryListItem *item;
 103         HklGeometry *geometry;
 104         HklGeometryList *geometries;
 105         HklDetector *detector;
 106         HklSample *sample;
 107         HklLattice *lattice;
 108         HklMatrix *U;
 109         static double positions[] = {0, 1, -14.27, 99.62, 60.98, 0};
 110         static double hkl_p[] = {1.95, 2, 6};
 111
 112         /* Wavelength 1.54980 */
 113         /* Mode       mu_fixed */
 114         /* Ux -90.59 Uy -9.97 Uz 176.35  */
 115         /* A 4.759 B 4.759 C 12.992  */
 116         /* Alpha 90 Beta 90 Gamma 120  */
 117
 118         factory = hkl_factory_get_by_name("SOLEIL SIXS MED2+3", NULL);
 119         geometry = hkl_factory_create_new_geometry(factory);
 120
 121         hkl_geometry_axes_values_set(geometry,
 122                                      positions, ARRAY_SIZE(positions), HKL_UNIT_USER,
 123                                      NULL);
 124         hkl_geometry_wavelength_set(geometry, 1.54980, HKL_UNIT_DEFAULT, NULL);
 125
 126         sample = hkl_sample_new("test");
 127         lattice = hkl_lattice_new(4.759, 4.759, 12.992,
 128                                   90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 120*HKL_DEGTORAD,
 129                                   NULL);
 130         hkl_sample_lattice_set(sample, lattice);
 131         hkl_lattice_free(lattice);
 132         U = hkl_matrix_new_euler(-90.59 * HKL_DEGTORAD,
 133                                  -9.97 * HKL_DEGTORAD,
 134                                  176.35 * HKL_DEGTORAD);
 135         hkl_sample_U_set(sample, U, NULL);
 136         hkl_matrix_free(U);
 137
 138         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 139
 140         engines = hkl_factory_create_new_engine_list(factory);
 141         hkl_engine_list_init(engines, geometry, detector, sample);
 142
 143         hkl = hkl_engine_list_engine_get_by_name(engines, "hkl", NULL);
 144         hkl_engine_current_mode_set(hkl, "mu_fixed", NULL);
 145
 146         /* hkl 1.95, 2, 6 (should not fail) */
 147         geometries = hkl_engine_pseudo_axes_values_set(hkl,
 148                                                        hkl_p, ARRAY_SIZE(hkl_p),
 149                                                        HKL_UNIT_DEFAULT, NULL);
 150         res &= DIAG((geometries != NULL));
 151         hkl_geometry_list_free(geometries);
 152
 153         ok(res == TRUE, __func__);
 154
 155         hkl_engine_list_free(engines);
 156         hkl_detector_free(detector);
 157         hkl_sample_free(sample);
 158         hkl_geometry_free(geometry);
 159 }
 160
 161 int main(int argc, char** argv)
 162 {
 163         plan(3);
 164
 165         qper_qpar();
 166         med_2_3();
 167
 168         return 0;
 169 }