tests/hkl-axis-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 "hkl.h"
  23 #include <tap/basic.h>
  24 #include <tap/float.h>
  25 #include <tap/hkl-tap.h>
  26
  27 /* use these private methods */
  28 HklParameter *hkl_parameter_new_axis(const char *, const HklVector *axis_v);
  29 int hkl_parameter_is_valid(const HklParameter *parameter);
  30 void hkl_parameter_value_set_smallest_in_range(HklParameter *parameter);
  31 double hkl_parameter_value_get_closest(HklParameter *parameter, HklParameter *ref);
  32
  33 static void new(void)
  34 {
  35         HklParameter *axis;
  36         static HklVector v = {{1, 0, 0}};
  37         double min, max;
  38
  39         axis = hkl_parameter_new_axis("omega", &v);
  40
  41         is_string("omega", hkl_parameter_name_get(axis), __func__);
  42         hkl_parameter_min_max_get(axis, &min, &max, HKL_UNIT_DEFAULT);
  43         is_double(-M_PI, min, HKL_EPSILON, __func__);
  44         is_double(M_PI, max, HKL_EPSILON, __func__);
  45         is_double(0., hkl_parameter_value_get(axis, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
  46         ok(TRUE == hkl_parameter_fit_get(axis), __func__);
  47
  48         hkl_parameter_free(axis);
  49 }
  50
  51 static void get_quaternions(void)
  52 {
  53         static HklVector v_ref = {{1, 0, 0}};
  54         static HklQuaternion q1_ref = {{1, 0, 0, 0}};
  55         static HklQuaternion q2_ref = {{M_SQRT1_2, -M_SQRT1_2, 0, 0}};
  56         HklParameter *axis;
  57
  58         axis = hkl_parameter_new_axis("omega", &v_ref);
  59
  60         is_quaternion(&q1_ref, hkl_parameter_quaternion_get(axis), __func__);
  61
  62         ok(TRUE == hkl_parameter_value_set(axis, -M_PI_2, HKL_UNIT_DEFAULT, NULL), __func__);
  63         is_quaternion(&q2_ref, hkl_parameter_quaternion_get(axis), __func__);
  64
  65         hkl_parameter_free(axis);
  66 }
  67
  68 static void copy(void)
  69 {
  70         static HklVector v = {{1, 0, 0}};
  71         static HklQuaternion q_ref = {{M_SQRT1_2, -M_SQRT1_2, 0, 0}};
  72         HklParameter *axis;
  73         HklParameter *copy;
  74         double min, max;
  75
  76
  77         axis = hkl_parameter_new_axis("omega", &v);
  78         ok(TRUE == hkl_parameter_value_set(axis, -M_PI_2, HKL_UNIT_DEFAULT, NULL), __func__);
  79
  80         copy = hkl_parameter_new_copy(axis);
  81
  82         is_string("omega", hkl_parameter_name_get(copy), __func__);
  83         hkl_parameter_min_max_get(copy, &min, &max, HKL_UNIT_DEFAULT);
  84         is_double(-M_PI, min, HKL_EPSILON, __func__);
  85         is_double(M_PI, max, HKL_EPSILON, __func__);
  86         is_double(-M_PI_2, hkl_parameter_value_get(copy, HKL_UNIT_DEFAULT), HKL_EPSILON, __func__);
  87         ok(TRUE == hkl_parameter_fit_get(copy), __func__);
  88
  89         is_quaternion(&q_ref, hkl_parameter_quaternion_get(copy), __func__);
  90
  91         hkl_parameter_free(axis);
  92         hkl_parameter_free(copy);
  93 }
  94
  95 static void is_valid(void)
  96 {
  97         static HklVector v = {{1, 0, 0}};
  98         HklParameter *axis1;
  99
 100         axis1 = hkl_parameter_new_axis("omega", &v);
 101
 102         ok(TRUE == hkl_parameter_value_set(axis1, 45, HKL_UNIT_USER, NULL), __func__);
 103         ok(TRUE == hkl_parameter_is_valid(axis1), __func__);
 104
 105         /* change the range of axis1 */
 106         ok(TRUE == hkl_parameter_min_max_set(axis1, -270, 0, HKL_UNIT_USER, NULL), __func__);
 107         ok(FALSE == hkl_parameter_is_valid(axis1), __func__);
 108
 109         ok(TRUE == hkl_parameter_value_set(axis1, -45, HKL_UNIT_USER, NULL), __func__);
 110         ok(TRUE == hkl_parameter_is_valid(axis1), __func__);
 111
 112         ok(TRUE == hkl_parameter_min_max_set(axis1, 350, 450, HKL_UNIT_USER, NULL), __func__);
 113         ok(TRUE == hkl_parameter_value_set(axis1, 45, HKL_UNIT_USER, NULL), __func__);
 114         ok(TRUE == hkl_parameter_is_valid(axis1), __func__);
 115         ok(TRUE == hkl_parameter_value_set(axis1, -45, HKL_UNIT_USER, NULL), __func__);
 116         ok(FALSE == hkl_parameter_is_valid(axis1), __func__);
 117
 118         ok(TRUE == hkl_parameter_min_max_set(axis1, -10, 90, HKL_UNIT_USER, NULL), __func__);
 119         ok(TRUE == hkl_parameter_value_set(axis1, 405, HKL_UNIT_USER, NULL), __func__);
 120         ok(TRUE == hkl_parameter_is_valid(axis1), __func__);
 121         ok(TRUE == hkl_parameter_value_set(axis1, -405, HKL_UNIT_USER, NULL), __func__);
 122         ok(FALSE == hkl_parameter_is_valid(axis1), __func__);
 123
 124         hkl_parameter_free(axis1);
 125 }
 126
 127 static void set_value_smallest_in_range(void)
 128 {
 129         HklParameter *axis;
 130         static HklVector v = {{1, 0, 0}};
 131
 132         axis = hkl_parameter_new_axis("omega", &v);
 133
 134         ok(TRUE == hkl_parameter_min_max_set(axis, -190, 190, HKL_UNIT_USER, NULL), __func__);
 135
 136         ok(TRUE == hkl_parameter_value_set(axis, 185, HKL_UNIT_USER, NULL), __func__);
 137         hkl_parameter_value_set_smallest_in_range(axis);
 138         is_double(-175., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 139
 140         ok(TRUE == hkl_parameter_value_set(axis, 545, HKL_UNIT_USER, NULL), __func__);
 141         hkl_parameter_value_set_smallest_in_range(axis);
 142         is_double(-175., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 143
 144         ok(TRUE == hkl_parameter_value_set(axis, -185, HKL_UNIT_USER, NULL), __func__);
 145         hkl_parameter_value_set_smallest_in_range(axis);
 146         is_double(-185., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 147
 148         ok(TRUE == hkl_parameter_value_set(axis, 175, HKL_UNIT_USER, NULL), __func__);
 149         hkl_parameter_value_set_smallest_in_range(axis);
 150         is_double(-185., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 151
 152         ok(TRUE == hkl_parameter_value_set(axis, 190, HKL_UNIT_USER, NULL), __func__);
 153         hkl_parameter_value_set_smallest_in_range(axis);
 154         is_double(-170., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 155
 156         ok(TRUE == hkl_parameter_value_set(axis, -190, HKL_UNIT_USER, NULL), __func__);
 157         hkl_parameter_value_set_smallest_in_range(axis);
 158         is_double(-190., hkl_parameter_value_get(axis, HKL_UNIT_USER), HKL_EPSILON, __func__);
 159
 160         hkl_parameter_free(axis);
 161 }
 162
 163 static void get_value_closest(void)
 164 {
 165         HklParameter *axis1, *axis2;
 166         static HklVector v = {{1, 0, 0}};
 167
 168         axis1 = hkl_parameter_new_axis("omega", &v);
 169         axis2 = hkl_parameter_new_axis("omega", &v);
 170
 171         ok(TRUE == hkl_parameter_value_set(axis1, 0, HKL_UNIT_USER, NULL), __func__);
 172         ok(TRUE == hkl_parameter_value_set(axis2, 0, HKL_UNIT_USER, NULL), __func__);
 173         is_double(0., hkl_parameter_value_get_closest(axis1,
 174                                                       axis2),
 175                   HKL_EPSILON, __func__);
 176
 177         /* change the range of axis1 */
 178         ok(TRUE == hkl_parameter_min_max_set(axis1, -270, 180, HKL_UNIT_USER, NULL), __func__);
 179         ok(TRUE == hkl_parameter_value_set(axis1, 100, HKL_UNIT_USER, NULL), __func__);
 180
 181         ok(TRUE == hkl_parameter_value_set(axis2, -75, HKL_UNIT_USER, NULL), __func__);
 182         is_double(100 * HKL_DEGTORAD, hkl_parameter_value_get_closest(axis1,
 183                                                                       axis2),
 184                   HKL_EPSILON, __func__);
 185
 186         ok(TRUE == hkl_parameter_value_set(axis2, -85, HKL_UNIT_USER, NULL), __func__);
 187         is_double(-260 * HKL_DEGTORAD, hkl_parameter_value_get_closest(axis1,
 188                                                                        axis2),
 189                   HKL_EPSILON, __func__);
 190
 191         hkl_parameter_free(axis1);
 192         hkl_parameter_free(axis2);
 193 }
 194
 195 int main(void)
 196 {
 197         plan(53);
 198
 199         new();
 200         get_quaternions();
 201         copy();
 202         is_valid();
 203         set_value_smallest_in_range();
 204         get_value_closest();
 205
 206         return 0;
 207 }