hkl/hkl-parameter.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-2014 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 <stdio.h>                      // for fprintf, FILE
  23 #include <stdlib.h>                     // for free, malloc, NULL
  24 #include <string.h>                     // for strcmp
  25 #include "hkl-interval-private.h"       // for HklInterval
  26 #include "hkl-macros-private.h"         // for HKL_MALLOC
  27 #include "hkl-parameter-private.h"      // for _HklParameter, etc
  28 #include "hkl-unit-private.h"           // for hkl_unit_factor, HklUnit, etc
  29 #include "hkl.h"                        // for HklParameter, etc
  30 #include "hkl/ccan/darray/darray.h"     // for darray_size, darray_item, etc
  31
  32 /****************/
  33 /* HklParameter */
  34 /****************/
  35
  36 static int hkl_parameter_init(HklParameter *self, const char *name,
  37                               double min, double value, double max,
  38                               int fit, int changed,
  39                               const HklUnit *unit, const HklUnit *punit)
  40 {
  41         if (min <= value
  42             && value <= max
  43             && strcmp(name, "")
  44             && hkl_unit_compatible(unit, punit)) {
  45                 self->name = name;
  46                 self->range.min = min;
  47                 self->range.max = max;
  48                 self->_value = value;
  49                 self->unit = unit;
  50                 self->punit = punit;
  51                 self->fit = fit;
  52                 self->changed = changed;
  53                 self->ops = &hkl_parameter_operations_defaults;
  54         } else
  55                 return FALSE;
  56
  57         return TRUE;
  58 }
  59
  60 /**
  61  * hkl_parameter_new: (skip)
  62  * @name:
  63  * @min:
  64  * @value:
  65  * @max:
  66  * @fit:
  67  * @changed:
  68  * @unit:
  69  * @punit:
  70  *
  71  * create a new #HklParameter
  72  *
  73  * Returns:
  74  **/
  75 HklParameter *hkl_parameter_new(const char *name,
  76                                 double min, double value, double max,
  77                                 int fit, int changed,
  78                                 const HklUnit *unit, const HklUnit *punit)
  79 {
  80         HklParameter *self;
  81
  82         self = HKL_MALLOC(HklParameter);
  83
  84         if (!hkl_parameter_init(self,
  85                                 name, min, value, max,
  86                                 fit, changed,
  87                                 unit, punit)) {
  88                 free(self);
  89                 self = NULL;
  90         }
  91
  92         return self;
  93 }
  94
  95 /**
  96  * hkl_parameter_new_copy: (skip)
  97  * @self:
  98  *
  99  * copy an #HklParameter
 100  *
 101  * Returns:
 102  **/
 103 HklParameter *hkl_parameter_new_copy(const HklParameter *self)
 104 {
 105         return self->ops->copy(self);
 106 }
 107
 108 /**
 109  * hkl_parameter_free: (skip)
 110  * @self:
 111  *
 112  * delete an #HklParameter
 113  **/
 114 void hkl_parameter_free(HklParameter *self)
 115 {
 116         self->ops->free(self);
 117 }
 118
 119 /**
 120  * hkl_parameter_init_copy: (skip)
 121  * @self: the this ptr
 122  * @src: the parameter to copy from
 123  * @error: return location for a GError, or NULL
 124  *
 125  * Returns: TRUE on success, FALSE if an error occurred
 126  **/
 127 int hkl_parameter_init_copy(HklParameter *self, const HklParameter *src,
 128                             GError **error)
 129 {
 130         return self->ops->init_copy(self, src, error);
 131 }
 132
 133 const char *hkl_parameter_name_get(const HklParameter *self)
 134 {
 135         return self->name;
 136 }
 137
 138 /**
 139  * hkl_parameter_value_get:
 140  * @self: the this ptr
 141  *
 142  * Returns: the value of the #HklParameter
 143  **/
 144 inline double hkl_parameter_value_get(const HklParameter *self)
 145 {
 146         return self->_value;
 147 }
 148
 149 /**
 150  * hkl_parameter_value_unit_get:
 151  * @self: the this ptr
 152  *
 153  * Returns: the value of the #HklParameter expressed in the user unit
 154  **/
 155 inline double hkl_parameter_value_unit_get(const HklParameter *self)
 156 {
 157         double factor = hkl_unit_factor(self->unit, self->punit);
 158
 159         return self->_value * factor;
 160 }
 161
 162
 163 /**
 164  * hkl_parameter_value_get_closest:
 165  * @self: the this ptr
 166  * @ref: the reference #HklParameter
 167  *
 168  *
 169  *
 170  * Returns: the closest value of the ref #HklParameter from the
 171  *          current self #HklParameter
 172  **/
 173 inline double hkl_parameter_value_get_closest(const HklParameter *self,
 174                                               const HklParameter *ref)
 175 {
 176         return self->ops->get_value_closest(self, ref);
 177 }
 178
 179 /**
 180  * hkl_parameter_value_set: (skip)
 181  * @self: this ptr
 182  * @value: the value to set
 183  * @error: return location for a GError, or NULL
 184  *
 185  * set the value of an #HklParameter
 186  *
 187  * Returns: TRUE on success, FALSE if an error occurred
 188  **/
 189 inline int hkl_parameter_value_set(HklParameter *self, double value,
 190                                    GError **error)
 191 {
 192         return self->ops->set_value(self, value, error);
 193 }
 194
 195 /**
 196  * hkl_parameter_value_unit_set:
 197  * @self: the this ptr
 198  * @value: the value to set
 199  * @error: return location for a GError, or NULL
 200  *
 201  * set the value of the parameter express in the punit #HklUnit
 202  * @todo test
 203  *
 204  * Returns: TRUE on success, FALSE if an error occurred
 205  **/
 206 inline int hkl_parameter_value_unit_set(HklParameter *self, double value,
 207                                         GError **error)
 208 {
 209         return self->ops->set_value_unit(self, value, error);
 210 }
 211
 212 /**
 213  * hkl_parameter_value_set_smallest_in_range: (skip)
 214  * @self: the this ptr
 215  **/
 216 inline void hkl_parameter_value_set_smallest_in_range(HklParameter *self)
 217 {
 218         self->ops->set_value_smallest_in_range(self);
 219 }
 220
 221 /**
 222  * hkl_parameter_min_max_get: (skip)
 223  * @self:
 224  *
 225  * get the max value of the #HklParameter
 226  *
 227  **/
 228 void hkl_parameter_min_max_get(const HklParameter *self, double *min, double *max)
 229 {
 230         *min = self->range.min;
 231         *max = self->range.max;
 232 }
 233
 234 /**
 235  * hkl_parameter_min_max_unit_get: (skip)
 236  * @self:
 237  * @min:
 238  * @max:
 239  *
 240  * get the #HklParameter range, min, max
 241  * @todo test
 242  **/
 243 void hkl_parameter_min_max_unit_get(const HklParameter *self, double *min, double *max)
 244 {
 245         double factor = hkl_unit_factor(self->unit, self->punit);
 246
 247         *min = factor * self->range.min;
 248         *max = factor * self->range.max;
 249 }
 250
 251 /**
 252  * hkl_parameter_min_max_set: (skip)
 253  * @self: the this ptr
 254  * @min:
 255  * @max:
 256  * @error: return location for a GError, or NULL
 257  *
 258  * set the #HklParameter range.
 259  * @todo test and set the GError
 260  *
 261  * Returns: TRUE on success, FALSE if an error occurred
 262  **/
 263 int hkl_parameter_min_max_set(HklParameter *self, double min, double max,
 264                               GError **error)
 265 {
 266         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 267
 268         if (min > max){
 269                 g_set_error(error,
 270                             HKL_PARAMETER_ERROR,
 271                             HKL_PARAMETER_ERROR_MIN_MAX_SET,
 272                             "can not set this range min > max\n");
 273
 274                 return FALSE;
 275         }
 276
 277         self->range.min = min;
 278         self->range.max = max;
 279
 280         return TRUE;
 281 }
 282
 283 /**
 284  * hkl_parameter_min_max_unit_set:
 285  * @self: the this ptr
 286  * @min: the minimum value to set
 287  * @max: the maximum value to set
 288  * @error: return location for a GError, or NULL
 289  *
 290  * set the #HklParameter range.
 291  * @todo test and set the GError
 292  *
 293  * Returns: TRUE on success, FALSE if an error occurred
 294  **/
 295 int hkl_parameter_min_max_unit_set(HklParameter *self, double min, double max,
 296                                    GError **error)
 297 {
 298         double factor = hkl_unit_factor(self->unit, self->punit);
 299
 300         return hkl_parameter_min_max_set(self, min / factor, max / factor, error);
 301 }
 302
 303 /**
 304  * hkl_parameter_fit_get:
 305  * @self: the this ptr
 306  *
 307  * Retuen value: the #HklParameter fit value, True is the parameter can be fitted, not otherwise
 308  * @todo test
 309  **/
 310 int hkl_parameter_fit_get(const HklParameter *self)
 311 {
 312         return self->fit;
 313 }
 314
 315 /**
 316  * hkl_parameter_fit_set:
 317  * @self: the this ptr
 318  * @fit: the fit value to set
 319  *
 320  * set the #HklParameter fit value, True is the parameter can be fitted, not otherwise
 321  * @todo test
 322  **/
 323 void hkl_parameter_fit_set(HklParameter *self, int fit)
 324 {
 325         self->fit = fit;
 326 }
 327
 328 /**
 329  * hkl_parameter_randomize: (skip)
 330  * @self:
 331  *
 332  * randomize the #HklParameter value into the min,max range
 333  **/
 334 void hkl_parameter_randomize(HklParameter *self)
 335 {
 336         self->ops->randomize(self);
 337 }
 338
 339 /**
 340  * hkl_parameter_is_valid: (skip)
 341  * @self:
 342  *
 343  * check if the value of the #HklParameter is in the min,max range
 344  *
 345  * Returns:
 346  **/
 347 int hkl_parameter_is_valid(const HklParameter *self)
 348 {
 349         return self->ops->is_valid(self);
 350 }
 351
 352 /**
 353  * hkl_parameter_fprintf: (skip)
 354  * @f:
 355  * @self:
 356  *
 357  * print into the #FILE f an #HklParameter
 358  **/
 359 void hkl_parameter_fprintf(FILE *f, HklParameter *self)
 360 {
 361         double factor = hkl_unit_factor(self->unit, self->punit);
 362         if (self->punit)
 363                 fprintf(f, "\"%s\" : %.7f %s [%.7f : %.7f] (%d)",
 364                         self->name,
 365                         self->_value * factor,
 366                         self->punit->repr,
 367                         self->range.min * factor,
 368                         self->range.max * factor,
 369                         self->fit);
 370         else
 371                 fprintf(f, "\"%s\" : %.7f [%.7f : %.7f] (%d)",
 372                         self->name,
 373                         self->_value * factor,
 374                         self->range.min * factor,
 375                         self->range.max * factor,
 376                         self->fit);
 377 }