hkl/hkl-parameter-private.h

   1
   2 /* This file is part of the hkl library.
   3  *
   4  * The hkl library is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * The hkl library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Copyright (C) 2003-2023 Synchrotron SOLEIL
  18  *                         L'Orme des Merisiers Saint-Aubin
  19  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  20  *
  21  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  22  */
  23 #ifndef __HKL_PARAMETER_PRIVATE_H__
  24 #define __HKL_PARAMETER_PRIVATE_H__
  25
  26 #include "datatype99.h"
  27
  28 #include <math.h>                       // for M_PI
  29 #include <stdio.h>                      // for FILE, fprintf, NULL
  30 #include <stdlib.h>                     // for free, rand, RAND_MAX
  31 #include "ccan/compiler/compiler.h"
  32 #include "hkl-interval-private.h"       // for HklInterval
  33 #include "hkl-macros-private.h"         // for HKL_MALLOC
  34 #include "hkl-unit-private.h"           // for HklUnit, hkl_unit_factor
  35 #include "hkl.h"                        // for HklParameter, TRUE, etc
  36
  37 G_BEGIN_DECLS
  38
  39 datatype(
  40         HklParameterType,
  41         (Parameter),
  42         (Rotation, HklVector),
  43         (RotationWithOrigin, HklVector, HklVector),
  44         (Translation, HklVector)
  45         );
  46
  47 typedef struct _HklParameterOperations HklParameterOperations;
  48
  49 struct _HklParameter {
  50         const char *name;
  51         const char *description;
  52         HklInterval range;
  53         double _value;
  54         const HklUnit *unit;
  55         const HklUnit *punit;
  56         int fit;
  57         int changed;
  58         const HklParameterOperations *ops;
  59         HklParameterType type;
  60 };
  61
  62 #define HKL_PARAMETER_DEFAULTS .name="dummy", .description="no description", .range={.min=-DBL_MAX, .max=DBL_MAX}, ._value=0, .unit=NULL, .punit=NULL, .fit=TRUE, .changed=TRUE, .ops = &hkl_parameter_operations_defaults
  63
  64 #define HKL_PARAMETER_DEFAULTS_LENGTH HKL_PARAMETER_DEFAULTS, .unit = &hkl_unit_length_meter, .punit = &hkl_unit_length_meter
  65
  66 #define HKL_PARAMETER_DEFAULTS_ANGLE HKL_PARAMETER_DEFAULTS, .range={.min=-M_PI, .max=M_PI}, .unit = &hkl_unit_angle_rad, .punit = &hkl_unit_angle_deg
  67
  68 #define HKL_PARAMETER_ERROR hkl_parameter_error_quark ()
  69
  70 static inline GQuark hkl_parameter_error_quark (void)
  71 {
  72         return g_quark_from_static_string ("hkl-parameter-error-quark");
  73 }
  74
  75 typedef enum {
  76         HKL_PARAMETER_ERROR_MIN_MAX_SET, /* can not set the min max */
  77         HKL_PARAMETER_ERROR_VALUE_SET, /* can not set the value */
  78 } HklParameterError;
  79
  80 /****************/
  81 /* HklParameter */
  82 /****************/
  83
  84 struct _HklParameterOperations {
  85         HklParameter *        (*copy)(const HklParameter *self);
  86         void                  (*free)(HklParameter *self);
  87         int                   (*init_copy)(HklParameter *self, const HklParameter *src,
  88                                            GError **error);
  89         double                (*get_value_closest)(const HklParameter *self,
  90                                                    const HklParameter *other);
  91         int                   (*set_value)(HklParameter *self, double value,
  92                                            HklUnitEnum unit_type, GError **error);
  93         void                  (*set_value_smallest_in_range)(HklParameter *self);
  94         void                  (*randomize)(HklParameter *self);
  95         int                   (*is_permutable)(const HklParameter *self);
  96         int                   (*is_valid)(const HklParameter *self);
  97         int                   (*is_valid_range)(const HklParameter *self);
  98         void                  (*fprintf)(FILE *f, const HklParameter *self);
  99         const HklVector *     (*axis_v_get)(const HklParameter *self);
 100         const HklQuaternion * (*quaternion_get)(const HklParameter *self);
 101         int                   (*transformation_cmp)(const HklParameter *self, const HklParameter *p2);
 102         HklVector             (*transformation_apply)(const HklParameter *self, const HklVector *v);
 103         double                (*orthodromic_distance_get)(const HklParameter *self, double v);
 104         HklParameterType      (*type_get) (const HklParameter *self);
 105 };
 106
 107 #define HKL_PARAMETER_OPERATIONS_DEFAULTS                               \
 108         .copy = hkl_parameter_copy_real,                                \
 109                 .free = hkl_parameter_free_real,                        \
 110                 .init_copy = hkl_parameter_init_copy_real,              \
 111                 .get_value_closest = hkl_parameter_value_get_closest_real, \
 112                 .set_value = hkl_parameter_value_set_real,              \
 113                 .set_value_smallest_in_range = hkl_parameter_value_set_smallest_in_range_real, \
 114                 .randomize = hkl_parameter_randomize_real,              \
 115                 .is_permutable = hkl_parameter_is_permutable_real,      \
 116                 .is_valid = hkl_parameter_is_valid_real,                \
 117                 .is_valid_range = hkl_parameter_is_valid_real,          \
 118                 .fprintf = hkl_parameter_fprintf_real,                  \
 119                 .axis_v_get = hkl_parameter_axis_v_get_real,            \
 120                 .quaternion_get = hkl_parameter_quaternion_get_real,    \
 121                 .transformation_cmp = hkl_parameter_transformation_cmp_real, \
 122                 .transformation_apply = hkl_parameter_transformation_apply_real, \
 123                 .orthodromic_distance_get = hkl_parameter_orthodromic_distance_get_real, \
 124                 .type_get = hkl_parameter_type_get_real
 125
 126 static inline HklParameter *hkl_parameter_copy_real(const HklParameter *self)
 127 {
 128         HklParameter *dup = g_new(HklParameter, 1);
 129
 130         *dup = *self;
 131
 132         return dup;
 133 }
 134
 135 static inline void hkl_parameter_free_real(HklParameter *self)
 136 {
 137         free(self);
 138 }
 139
 140 static inline int hkl_parameter_init_copy_real(HklParameter *self, const HklParameter *src,
 141                                                GError **error)
 142 {
 143         hkl_error (error == NULL || *error == NULL);
 144         hkl_error (self->name == src->name || strcmp(self->name, src->name) == 0);
 145
 146         *self = *src;
 147         self->changed = TRUE;
 148
 149         return TRUE;
 150 }
 151
 152 static inline double hkl_parameter_value_get_closest_real(const HklParameter *self,
 153                                                           UNUSED const HklParameter *ref)
 154 {
 155         return self->_value;
 156 }
 157
 158 static inline int hkl_parameter_value_set_real(HklParameter *self, double value,
 159                                                HklUnitEnum unit_type, GError **error)
 160 {
 161         hkl_error (error == NULL || *error == NULL);
 162
 163         if (!isfinite(value)){
 164                 g_set_error(error,
 165                             HKL_PARAMETER_ERROR,
 166                             HKL_PARAMETER_ERROR_VALUE_SET,
 167                             "It is forbiden to set the (%s) parameter value with the non-finite %f value\n",
 168                             self->name, value);
 169                 return FALSE;
 170         }
 171
 172         switch (unit_type) {
 173         case HKL_UNIT_DEFAULT:
 174                 self->_value = value;
 175                 break;
 176         case HKL_UNIT_USER:
 177                 self->_value = value / hkl_unit_factor(self->unit, self->punit);
 178                 break;
 179         }
 180         self->changed = TRUE;
 181
 182         return TRUE;
 183 }
 184
 185 static inline void hkl_parameter_value_set_smallest_in_range_real(UNUSED HklParameter *self)
 186 {
 187         /* DOES NOTHING for a standard parameter */
 188 }
 189
 190 static inline void hkl_parameter_randomize_real(HklParameter *self)
 191 {
 192         if (self->fit) {
 193                 double alea = (double)rand() / (RAND_MAX + 1.);
 194                 self->_value = self->range.min
 195                         + (self->range.max - self->range.min) * alea;
 196                 self->changed = TRUE;
 197         }
 198 }
 199
 200 static inline int hkl_parameter_is_permutable_real(UNUSED const HklParameter *self)
 201 {
 202         return FALSE;
 203 }
 204
 205 static inline int hkl_parameter_is_valid_real(const HklParameter *self)
 206 {
 207         if(self->_value < (self->range.min - HKL_EPSILON)
 208            || self->_value > (self->range.max + HKL_EPSILON))
 209                 return FALSE;
 210         else
 211                 return TRUE;
 212 }
 213
 214 static inline void hkl_parameter_fprintf_real(FILE *f, const HklParameter *self)
 215 {
 216         double factor = hkl_unit_factor(self->unit, self->punit);
 217         if (self->punit)
 218                 fprintf(f, "\"%s\" : %.7f %s [%.7f : %.7f] (%d)",
 219                         self->name,
 220                         self->_value * factor,
 221                         self->punit->repr,
 222                         self->range.min * factor,
 223                         self->range.max * factor,
 224                         self->fit);
 225         else
 226                 fprintf(f, "\"%s\" : %.7f [%.7f : %.7f] (%d)",
 227                         self->name,
 228                         self->_value * factor,
 229                         self->range.min * factor,
 230                         self->range.max * factor,
 231                         self->fit);
 232 }
 233
 234 static inline const HklVector *hkl_parameter_axis_v_get_real(UNUSED const HklParameter *self)
 235 {
 236         return NULL;
 237 }
 238
 239 static inline const HklQuaternion *hkl_parameter_quaternion_get_real(UNUSED const HklParameter *self)
 240 {
 241         return NULL;
 242 }
 243
 244 static inline int hkl_parameter_transformation_cmp_real(const HklParameter *self, const HklParameter *p2)
 245 {
 246         return self->ops != p2->ops;
 247 }
 248
 249 static inline HklVector hkl_parameter_transformation_apply_real(UNUSED const HklParameter *self,
 250                                                                 const HklVector *v)
 251 {
 252         return *v;
 253 }
 254
 255 static inline double hkl_parameter_orthodromic_distance_get_real(const HklParameter *self,
 256                                                                  UNUSED double value)
 257 {
 258         return self->_value;
 259 }
 260
 261 static inline HklParameterType hkl_parameter_type_get_real(const HklParameter *self)
 262 {
 263         return self->type;
 264 }
 265
 266 static NEEDED HklParameterOperations hkl_parameter_operations_defaults = {
 267         HKL_PARAMETER_OPERATIONS_DEFAULTS,
 268 };
 269
 270
 271 extern HklParameter *hkl_parameter_new(const char *name, const char *description,
 272                                        double min, double value, double max,
 273                                        int fit, int changed,
 274                                        const HklUnit *unit,
 275                                        const HklUnit *punit);
 276
 277 extern int hkl_parameter_init_copy(HklParameter *self, const HklParameter *src,
 278                                    GError **error);
 279
 280 extern int hkl_parameter_is_permutable(const HklParameter *self);
 281
 282 extern double hkl_parameter_value_get_closest(const HklParameter *self,
 283                                               const HklParameter *ref);
 284
 285 extern void hkl_parameter_value_set_smallest_in_range(HklParameter *self);
 286
 287 extern int hkl_parameter_is_valid(const HklParameter *self);
 288
 289 extern int hkl_parameter_is_valid_range(const HklParameter *self);
 290
 291 extern void hkl_parameter_fprintf(FILE *f, const HklParameter *self);
 292
 293 extern int hkl_parameter_transformation_cmp(const HklParameter *self,
 294                                             const HklParameter *p2);
 295
 296 extern HklVector hkl_parameter_transformation_apply(const HklParameter *self,
 297                                                     const HklVector *v);
 298
 299 extern double hkl_parameter_orthodromic_distance_get(const HklParameter *self,
 300                                                      double value);
 301
 302 extern HklParameterType hkl_parameter_type_get(const HklParameter *self);
 303
 304 /********************/
 305 /* HklParameterList */
 306 /********************/
 307
 308 typedef darray(HklParameter *) darray_parameter;
 309 typedef darray(const HklParameter) darray_const_parameter;
 310
 311 G_END_DECLS
 312
 313 #endif /* __HKL_PARAMETER_PRIVATE_H__ */