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