test/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-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
  25 static void new(void)
  26 {
  27         HklAxis *axis;
  28         static HklVector v = {{1, 0, 0}};
  29
  30         axis = hkl_axis_new("omega", &v);
  31
  32         is_string("omega", ((HklParameter *)axis)->name, __func__);
  33         is_double(-M_PI, ((HklParameter *)axis)->range.min, HKL_EPSILON, __func__);
  34         is_double(M_PI, ((HklParameter *)axis)->range.max, HKL_EPSILON, __func__);
  35         is_double(0., hkl_parameter_get_value(&axis->parameter), HKL_EPSILON, __func__);
  36         ok(HKL_TRUE == ((HklParameter *)axis)->fit, __func__);
  37         ok(HKL_TRUE == ((HklParameter *)axis)->changed, __func__);
  38
  39         hkl_axis_free(axis);
  40 }
  41
  42 static void get_quaternions(void)
  43 {
  44         HklAxis *axis;
  45         static HklVector v = {{1, 0, 0}};
  46
  47         axis = hkl_axis_new("omega", &v);
  48
  49         is_double(1., axis->q.data[0], HKL_EPSILON, __func__);
  50         is_double(0., axis->q.data[1], HKL_EPSILON, __func__);
  51         is_double(0., axis->q.data[2], HKL_EPSILON, __func__);
  52         is_double(0., axis->q.data[3], HKL_EPSILON, __func__);
  53
  54         hkl_parameter_set_value(&axis->parameter, -M_PI_2);
  55         is_double(1./sqrt(2.), axis->q.data[0], HKL_EPSILON, __func__);
  56         is_double(-1./sqrt(2.), axis->q.data[1], HKL_EPSILON, __func__);
  57         is_double(0., axis->q.data[2], HKL_EPSILON, __func__);
  58         is_double(0., axis->q.data[3], HKL_EPSILON, __func__);
  59
  60         hkl_axis_free(axis);
  61 }
  62
  63 static void is_valid(void)
  64 {
  65         HklAxis *axis1;
  66         static HklVector v = {{1, 0, 0}};
  67
  68         axis1 = hkl_axis_new("omega", &v);
  69
  70         hkl_parameter_set_value_unit(&axis1->parameter, 45);
  71         ok(HKL_TRUE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  72
  73         /* change the range of axis1 */
  74         hkl_parameter_set_range_unit(&axis1->parameter, -270, 0);
  75         ok(HKL_FALSE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  76
  77         hkl_parameter_set_value_unit(&axis1->parameter, -45);
  78         ok(HKL_TRUE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  79
  80         hkl_parameter_set_range_unit(&axis1->parameter, 350, 450);
  81         hkl_parameter_set_value_unit(&axis1->parameter, 45);
  82         ok(HKL_TRUE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  83         hkl_parameter_set_value_unit(&axis1->parameter, -45);
  84         ok(HKL_FALSE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  85
  86         hkl_parameter_set_range_unit(&axis1->parameter, -10, 90);
  87         hkl_parameter_set_value_unit(&axis1->parameter, 405);
  88         ok(HKL_TRUE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  89         hkl_parameter_set_value_unit(&axis1->parameter, -405);
  90         ok(HKL_FALSE == hkl_parameter_is_valid(&axis1->parameter), __func__);
  91
  92         hkl_axis_free(axis1);
  93 }
  94
  95 static void set_value_smallest_in_range(void)
  96 {
  97         HklAxis *axis;
  98         static HklVector v = {{1, 0, 0}};
  99
 100         axis = hkl_axis_new("omega", &v);
 101
 102         hkl_parameter_set_range_unit(&axis->parameter, -190, 190);
 103
 104         hkl_parameter_set_value_unit(&axis->parameter, 185);
 105         hkl_axis_set_value_smallest_in_range(axis);
 106         is_double(-175., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 107
 108         hkl_parameter_set_value_unit(&axis->parameter, 545);
 109         hkl_axis_set_value_smallest_in_range(axis);
 110         is_double(-175., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 111
 112         hkl_parameter_set_value_unit(&axis->parameter, -185);
 113         hkl_axis_set_value_smallest_in_range(axis);
 114         is_double(-185., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 115
 116         hkl_parameter_set_value_unit(&axis->parameter, 175);
 117         hkl_axis_set_value_smallest_in_range(axis);
 118         is_double(-185., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 119
 120         hkl_parameter_set_value_unit(&axis->parameter, 190);
 121         hkl_axis_set_value_smallest_in_range(axis);
 122         is_double(-170., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 123
 124         hkl_parameter_set_value_unit(&axis->parameter, -190);
 125         hkl_axis_set_value_smallest_in_range(axis);
 126         is_double(-190., hkl_parameter_get_value_unit(&axis->parameter), HKL_EPSILON, __func__);
 127
 128         hkl_axis_free(axis);
 129 }
 130
 131 static void get_value_closest(void)
 132 {
 133         HklAxis *axis1, *axis2;
 134         static HklVector v = {{1, 0, 0}};
 135
 136         axis1 = hkl_axis_new("omega", &v);
 137         axis2 = hkl_axis_new("omega", &v);
 138
 139         hkl_parameter_set_value_unit(&axis1->parameter, 0);
 140         hkl_parameter_set_value_unit(&axis2->parameter, 0);
 141         is_double(0., hkl_parameter_get_value_closest(&axis1->parameter,
 142                                                       &axis2->parameter),
 143                   HKL_EPSILON, __func__);
 144
 145         /* change the range of axis1 */
 146         hkl_parameter_set_range_unit(&axis1->parameter, -270, 180);
 147         hkl_parameter_set_value_unit(&axis1->parameter, 100);
 148
 149         hkl_parameter_set_value_unit(&axis2->parameter, -75);
 150         is_double(100 * HKL_DEGTORAD, hkl_parameter_get_value_closest(&axis1->parameter,
 151                                                                       &axis2->parameter),
 152                   HKL_EPSILON, __func__);
 153
 154         hkl_parameter_set_value_unit(&axis2->parameter, -85);
 155         is_double(-260 * HKL_DEGTORAD, hkl_parameter_get_value_closest(&axis1->parameter,
 156                                                                        &axis2->parameter),
 157                   HKL_EPSILON, __func__);
 158
 159         hkl_axis_free(axis1);
 160         hkl_axis_free(axis2);
 161 }
 162
 163 int main(int argc, char** argv)
 164 {
 165         plan(30);
 166
 167         new();
 168         get_quaternions();
 169         is_valid();
 170         set_value_smallest_in_range();
 171         get_value_closest();
 172
 173         return 0;
 174 }