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-2017 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 <math.h>                       // for M_PI
  27 #include <stdio.h>                      // for FILE, fprintf, NULL
  28 #include <stdlib.h>                     // for free, rand, RAND_MAX
  29 #include "ccan/compiler/compiler.h"
  30 #include "hkl-interval-private.h"       // for HklInterval
  31 #include "hkl-macros-private.h"         // for HKL_MALLOC
  32 #include "hkl-unit-private.h"           // for HklUnit, hkl_unit_factor
  33 #include "hkl.h"                        // for HklParameter, TRUE, etc
  34
  35 G_BEGIN_DECLS
  36
  37 typedef struct _HklParameterOperations HklParameterOperations;
  38
  39 struct _HklParameter {
  40         const char *name;
  41         const char *description;
  42         HklInterval range;
  43         double _value;
  44         const HklUnit *unit;
  45         const HklUnit *punit;
  46         int fit;
  47         int changed;
  48         const HklParameterOperations *ops;
  49 };
  50
  51 #define HKL_PARAMETER_DEFAULTS .name="dummy", .description="no description", .range={.min=0, .max=0}, ._value=0, .unit=NULL, .punit=NULL, .fit=TRUE, .changed=TRUE, .ops = &hkl_parameter_operations_defaults
  52
  53 #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
  54
  55 #define HKL_PARAMETER_ERROR hkl_parameter_error_quark ()
  56
  57 static inline GQuark hkl_parameter_error_quark (void)
  58 {
  59         return g_quark_from_static_string ("hkl-parameter-error-quark");
  60 }
  61
  62 typedef enum {
  63         HKL_PARAMETER_ERROR_MIN_MAX_SET, /* can not set the min max */
  64 } HklParameterError;
  65
  66 /****************/
  67 /* HklParameter */
  68 /****************/
  69
  70 struct _HklParameterOperations {
  71         HklParameter *        (*copy)(const HklParameter *self);
  72         void                  (*free)(HklParameter *self);
  73         int                   (*init_copy)(HklParameter *self, const HklParameter *src,
  74                                            GError **error);
  75         double                (*get_value_closest)(const HklParameter *self,
  76                                                    const HklParameter *other);
  77         int                   (*set_value)(HklParameter *self, double value,
  78                                            HklUnitEnum unit_type, GError **error);
  79         void                  (*set_value_smallest_in_range)(HklParameter *self);
  80         void                  (*randomize)(HklParameter *self);
  81         int                   (*is_valid)(const HklParameter *self);
  82         int                   (*is_valid_range)(const HklParameter *self);
  83         void                  (*fprintf)(FILE *f, const HklParameter *self);
  84         const HklVector *     (*axis_v_get)(const HklParameter *self);
  85         const HklQuaternion * (*quaternion_get)(const HklParameter *self);
  86 };
  87
  88 #define HKL_PARAMETER_OPERATIONS_DEFAULTS                               \
  89         .copy = hkl_parameter_copy_real,                                \
  90                 .free = hkl_parameter_free_real,                        \
  91                 .init_copy = hkl_parameter_init_copy_real,              \
  92                 .get_value_closest = hkl_parameter_value_get_closest_real, \
  93                 .set_value = hkl_parameter_value_set_real,              \
  94                 .set_value_smallest_in_range = hkl_parameter_value_set_smallest_in_range_real, \
  95                 .randomize = hkl_parameter_randomize_real,              \
  96                 .is_valid = hkl_parameter_is_valid_real,                \
  97                 .is_valid_range = hkl_parameter_is_valid_real,          \
  98                 .fprintf = hkl_parameter_fprintf_real,                  \
  99                 .axis_v_get = hkl_parameter_axis_v_get_real,            \
 100                 .quaternion_get = hkl_parameter_quaternion_get_real
 101
 102 static inline HklParameter *hkl_parameter_copy_real(const HklParameter *self)
 103 {
 104         HklParameter *dup = HKL_MALLOC(HklParameter);
 105
 106         *dup = *self;
 107
 108         return dup;
 109 }
 110
 111 static inline void hkl_parameter_free_real(HklParameter *self)
 112 {
 113         free(self);
 114 }
 115
 116 static inline int hkl_parameter_init_copy_real(HklParameter *self, const HklParameter *src,
 117                                                GError **error)
 118 {
 119         hkl_error (error == NULL || *error == NULL);
 120         hkl_error (self->name == src->name || strcmp(self->name, src->name) == 0);
 121
 122         *self = *src;
 123         self->changed = TRUE;
 124
 125         return TRUE;
 126 }
 127
 128 static inline double hkl_parameter_value_get_closest_real(const HklParameter *self,
 129                                                           UNUSED const HklParameter *ref)
 130 {
 131         return self->_value;
 132 }
 133
 134 static inline int hkl_parameter_value_set_real(HklParameter *self, double value,
 135                                                HklUnitEnum unit_type, GError **error)
 136 {
 137         hkl_error (error == NULL || *error == NULL);
 138
 139         switch (unit_type) {
 140         case HKL_UNIT_DEFAULT:
 141                 self->_value = value;
 142                 break;
 143         case HKL_UNIT_USER:
 144                 self->_value = value / hkl_unit_factor(self->unit, self->punit);
 145                 break;
 146         }
 147         self->changed = TRUE;
 148
 149         return TRUE;
 150 }
 151
 152 static inline void hkl_parameter_value_set_smallest_in_range_real(UNUSED HklParameter *self)
 153 {
 154         /* DOES NOTHING for a standard parameter */
 155 }
 156
 157 static inline void hkl_parameter_randomize_real(HklParameter *self)
 158 {
 159         if (self->fit) {
 160                 double alea = (double)rand() / (RAND_MAX + 1.);
 161                 self->_value = self->range.min
 162                         + (self->range.max - self->range.min) * alea;
 163                 self->changed = TRUE;
 164         }
 165 }
 166
 167 static inline int hkl_parameter_is_valid_real(const HklParameter *self)
 168 {
 169         if(self->_value < (self->range.min - HKL_EPSILON)
 170            || self->_value > (self->range.max + HKL_EPSILON))
 171                 return FALSE;
 172         else
 173                 return TRUE;
 174 }
 175
 176 static inline void hkl_parameter_fprintf_real(FILE *f, const HklParameter *self)
 177 {
 178         double factor = hkl_unit_factor(self->unit, self->punit);
 179         if (self->punit)
 180                 fprintf(f, "\"%s\" : %.7f %s [%.7f : %.7f] (%d)",
 181                         self->name,
 182                         self->_value * factor,
 183                         self->punit->repr,
 184                         self->range.min * factor,
 185                         self->range.max * factor,
 186                         self->fit);
 187         else
 188                 fprintf(f, "\"%s\" : %.7f [%.7f : %.7f] (%d)",
 189                         self->name,
 190                         self->_value * factor,
 191                         self->range.min * factor,
 192                         self->range.max * factor,
 193                         self->fit);
 194 }
 195
 196 static inline const HklVector *hkl_parameter_axis_v_get_real(UNUSED const HklParameter *self)
 197 {
 198         return NULL;
 199 }
 200
 201 static inline const HklQuaternion *hkl_parameter_quaternion_get_real(UNUSED const HklParameter *self)
 202 {
 203         return NULL;
 204 }
 205
 206 static NEEDED HklParameterOperations hkl_parameter_operations_defaults = {
 207         HKL_PARAMETER_OPERATIONS_DEFAULTS,
 208 };
 209
 210
 211 extern HklParameter *hkl_parameter_new(const char *name, const char *description,
 212                                        double min, double value, double max,
 213                                        int fit, int changed,
 214                                        const HklUnit *unit,
 215                                        const HklUnit *punit);
 216
 217 extern int hkl_parameter_init_copy(HklParameter *self, const HklParameter *src,
 218                                    GError **error);
 219
 220 extern double hkl_parameter_value_get_closest(const HklParameter *self,
 221                                               const HklParameter *ref);
 222
 223 extern void hkl_parameter_value_set_smallest_in_range(HklParameter *self);
 224
 225 extern int hkl_parameter_is_valid(const HklParameter *self);
 226
 227 extern int hkl_parameter_is_valid_range(const HklParameter *self);
 228
 229 extern void hkl_parameter_fprintf(FILE *f, HklParameter *self);
 230
 231 /********************/
 232 /* HklParameterList */
 233 /********************/
 234
 235 typedef darray(HklParameter *) darray_parameter;
 236
 237 G_END_DECLS
 238
 239 #endif /* __HKL_PARAMETER_PRIVATE_H__ */