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-2016 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         void                  (*fprintf)(FILE *f, const HklParameter *self);
  83         const HklVector *     (*axis_v_get)(const HklParameter *self);
  84         const HklQuaternion * (*quaternion_get)(const HklParameter *self);
  85 };
  86
  87 #define HKL_PARAMETER_OPERATIONS_DEFAULTS                               \
  88         .copy = hkl_parameter_copy_real,                                \
  89                 .free = hkl_parameter_free_real,                        \
  90                 .init_copy = hkl_parameter_init_copy_real,              \
  91                 .get_value_closest = hkl_parameter_value_get_closest_real, \
  92                 .set_value = hkl_parameter_value_set_real,              \
  93                 .set_value_smallest_in_range = hkl_parameter_value_set_smallest_in_range_real, \
  94                 .randomize = hkl_parameter_randomize_real,              \
  95                 .is_valid = hkl_parameter_is_valid_real,                \
  96                 .fprintf = hkl_parameter_fprintf_real,                  \
  97                 .axis_v_get = hkl_parameter_axis_v_get_real,            \
  98                 .quaternion_get = hkl_parameter_quaternion_get_real
  99
 100 static inline HklParameter *hkl_parameter_copy_real(const HklParameter *self)
 101 {
 102         HklParameter *dup = HKL_MALLOC(HklParameter);
 103
 104         *dup = *self;
 105
 106         return dup;
 107 }
 108
 109 static inline void hkl_parameter_free_real(HklParameter *self)
 110 {
 111         free(self);
 112 }
 113
 114 static inline int hkl_parameter_init_copy_real(HklParameter *self, const HklParameter *src,
 115                                                GError **error)
 116 {
 117         hkl_error (error == NULL || *error == NULL);
 118         hkl_error (self->name == src->name || strcmp(self->name, src->name) == 0);
 119
 120         *self = *src;
 121         self->changed = TRUE;
 122
 123         return TRUE;
 124 }
 125
 126 static inline double hkl_parameter_value_get_closest_real(const HklParameter *self,
 127                                                           UNUSED const HklParameter *ref)
 128 {
 129         return self->_value;
 130 }
 131
 132 static inline int hkl_parameter_value_set_real(HklParameter *self, double value,
 133                                                HklUnitEnum unit_type, GError **error)
 134 {
 135         hkl_error (error == NULL || *error == NULL);
 136
 137         switch (unit_type) {
 138         case HKL_UNIT_DEFAULT:
 139                 self->_value = value;
 140                 break;
 141         case HKL_UNIT_USER:
 142                 self->_value = value / hkl_unit_factor(self->unit, self->punit);
 143                 break;
 144         }
 145         self->changed = TRUE;
 146
 147         return TRUE;
 148 }
 149
 150 static inline void hkl_parameter_value_set_smallest_in_range_real(UNUSED HklParameter *self)
 151 {
 152         /* DOES NOTHING for a standard parameter */
 153 }
 154
 155 static inline void hkl_parameter_randomize_real(HklParameter *self)
 156 {
 157         if (self->fit) {
 158                 double alea = (double)rand() / (RAND_MAX + 1.);
 159                 self->_value = self->range.min
 160                         + (self->range.max - self->range.min) * alea;
 161                 self->changed = TRUE;
 162         }
 163 }
 164
 165 static inline int hkl_parameter_is_valid_real(const HklParameter *self)
 166 {
 167         if(self->_value < (self->range.min - HKL_EPSILON)
 168            || self->_value > (self->range.max + HKL_EPSILON))
 169                 return FALSE;
 170         else
 171                 return TRUE;
 172 }
 173
 174 static inline void hkl_parameter_fprintf_real(FILE *f, const HklParameter *self)
 175 {
 176         double factor = hkl_unit_factor(self->unit, self->punit);
 177         if (self->punit)
 178                 fprintf(f, "\"%s\" : %.7f %s [%.7f : %.7f] (%d)",
 179                         self->name,
 180                         self->_value * factor,
 181                         self->punit->repr,
 182                         self->range.min * factor,
 183                         self->range.max * factor,
 184                         self->fit);
 185         else
 186                 fprintf(f, "\"%s\" : %.7f [%.7f : %.7f] (%d)",
 187                         self->name,
 188                         self->_value * factor,
 189                         self->range.min * factor,
 190                         self->range.max * factor,
 191                         self->fit);
 192 }
 193
 194 static inline const HklVector *hkl_parameter_axis_v_get_real(UNUSED const HklParameter *self)
 195 {
 196         return NULL;
 197 }
 198
 199 static inline const HklQuaternion *hkl_parameter_quaternion_get_real(UNUSED const HklParameter *self)
 200 {
 201         return NULL;
 202 }
 203
 204 static NEEDED HklParameterOperations hkl_parameter_operations_defaults = {
 205         HKL_PARAMETER_OPERATIONS_DEFAULTS,
 206 };
 207
 208
 209 extern HklParameter *hkl_parameter_new(const char *name, const char *description,
 210                                        double min, double value, double max,
 211                                        int fit, int changed,
 212                                        const HklUnit *unit,
 213                                        const HklUnit *punit);
 214
 215 extern int hkl_parameter_init_copy(HklParameter *self, const HklParameter *src,
 216                                    GError **error);
 217
 218 extern double hkl_parameter_value_get_closest(const HklParameter *self,
 219                                               const HklParameter *ref);
 220
 221 extern void hkl_parameter_value_set_smallest_in_range(HklParameter *self);
 222
 223 extern int hkl_parameter_is_valid(const HklParameter *self);
 224
 225 extern void hkl_parameter_fprintf(FILE *f, HklParameter *self);
 226
 227 /********************/
 228 /* HklParameterList */
 229 /********************/
 230
 231 typedef darray(HklParameter *) darray_parameter;
 232
 233 G_END_DECLS
 234
 235 #endif /* __HKL_PARAMETER_PRIVATE_H__ */