src/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-2009 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 <stdlib.h>
  23 #include <string.h>
  24
  25 #include <hkl/hkl-parameter.h>
  26
  27 HklParameter *hkl_parameter_new(char const *name,
  28                                 double min, double value, double max,
  29                                 int not_to_fit, int changed,
  30                                 HklUnit const *unit, HklUnit const *punit)
  31 {
  32         HklParameter *parameter;
  33
  34         parameter = malloc(sizeof(*parameter));
  35         if (!parameter)
  36                 die("Cannot allocate memory for an HklParameter");
  37
  38         if (hkl_parameter_init(parameter,
  39                                name, min, value, max,
  40                                not_to_fit, changed,
  41                                unit, punit)) {
  42                 free(parameter);
  43                 parameter = NULL;
  44         }
  45
  46         return parameter;
  47 }
  48
  49 HklParameter *hkl_parameter_new_copy(HklParameter const *self)
  50 {
  51         HklParameter *parameter = NULL;
  52
  53         parameter = malloc(sizeof(*parameter));
  54         if (!parameter)
  55                 die("Cannot allocate memory for an HklParameter");
  56
  57         *parameter = *self;
  58
  59         return parameter;
  60 }
  61
  62 int hkl_parameter_init(HklParameter *self, char const *name,
  63                        double min, double value, double max,
  64                        int not_to_fit, int changed,
  65                        HklUnit const *unit, HklUnit const *punit)
  66 {
  67         if (min <= value
  68             && value <= max
  69             && strcmp(name, "")
  70             && hkl_unit_compatible(unit, punit)) {
  71                 self->name = name;
  72                 self->range.min = min;
  73                 self->range.max = max;
  74                 self->value = value;
  75                 self->unit = unit;
  76                 self->punit = punit;
  77                 self->not_to_fit = not_to_fit;
  78                 self->changed = changed;
  79         } else
  80                 return HKL_FAIL;
  81
  82         return HKL_SUCCESS;
  83 }
  84
  85 void hkl_parameter_free(HklParameter *self)
  86 {
  87         free(self);
  88 }
  89
  90 void hkl_parameter_set_value(HklParameter *self, double value)
  91 {
  92         self->value = value;
  93         self->changed = HKL_TRUE;
  94 }
  95
  96 /* TODO test */
  97 double hkl_parameter_get_value_unit(HklParameter const *self)
  98 {
  99         double factor = hkl_unit_factor(self->unit, self->punit);
 100
 101         return self->value * factor;
 102 }
 103
 104 /* TODO test */
 105 int hkl_parameter_set_value_unit(HklParameter *self, double value)
 106 {
 107         double factor = hkl_unit_factor(self->unit, self->punit);
 108
 109         self->value = value / factor;
 110         self->changed = HKL_TRUE;
 111
 112         return HKL_SUCCESS;
 113 }
 114
 115 /* TODO test */
 116 void hkl_parameter_get_range_unit(HklParameter const *self, double *min, double *max)
 117 {
 118         double factor = hkl_unit_factor(self->unit, self->punit);
 119
 120         *min = factor * self->range.min;
 121         *max = factor * self->range.max;
 122 }
 123
 124 /* TODO test */
 125 void hkl_parameter_set_range(HklParameter *self, double min, double max)
 126 {
 127         self->range.min = min;
 128         self->range.max = max;
 129 }
 130
 131 /* TODO test */
 132 void hkl_parameter_set_range_unit(HklParameter *self, double min, double max)
 133 {
 134         double factor = hkl_unit_factor(self->unit, self->punit);
 135         self->range.min = min / factor;
 136         self->range.max = max / factor;
 137 }
 138
 139 void hkl_parameter_randomize(HklParameter *self)
 140 {
 141         if (!self->not_to_fit) {
 142                 double alea = (double)rand() / (RAND_MAX + 1.);
 143                 self->value = self->range.min
 144                         + (self->range.max - self->range.min) * alea;
 145                 self->changed = HKL_TRUE;
 146         }
 147 }
 148
 149 void hkl_parameter_fprintf(FILE *f, HklParameter *self)
 150 {
 151         double factor = hkl_unit_factor(self->unit, self->punit);
 152         if (self->punit)
 153                 fprintf(f, "\"%s\" : %f %s [%f : %f]",
 154                         self->name,
 155                         self->value * factor,
 156                         self->punit->repr,
 157                         self->range.min * factor,
 158                         self->range.max * factor);
 159         else
 160                 fprintf(f, "\"%s\" : %f [%f : %f]",
 161                         self->name,
 162                         self->value * factor,
 163                         self->range.min * factor,
 164                         self->range.max * factor);
 165 }