hkl/hkl-pseudoaxis-auto-private.h

   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-2017 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 #ifndef __HKL_PSEUDOAXIS_AUTO_H__
  23 #define __HKL_PSEUDOAXIS_AUTO_H__
  24
  25 #include <gsl/gsl_vector_double.h>      // for gsl_vector
  26 #include <stddef.h>                     // for NULL
  27 #include <sys/types.h>                  // for uint
  28 #include "hkl-detector-private.h"       // for hkl_detector_new_copy
  29 #include "hkl-geometry-private.h"       // for hkl_geometry_new_copy
  30 #include "hkl-macros-private.h"         // for hkl_assert, etc
  31 #include "hkl-pseudoaxis-private.h"     // for HklModeOperations, etc
  32 #include "hkl.h"                        // for HklMode, hkl_detector_free, etc
  33 #include "hkl/ccan/container_of/container_of.h"  // for container_of
  34 #include "hkl/ccan/array_size/array_size.h"  // ARRAY_SIZE
  35
  36 G_BEGIN_DECLS
  37
  38 typedef struct _HklFunction HklFunction;
  39 typedef struct _HklModeAutoInfo HklModeAutoInfo;
  40 typedef struct _HklModeAutoWithInit HklModeAutoWithInit;
  41
  42 /***************/
  43 /* HklModeAuto */
  44 /***************/
  45
  46 struct _HklFunction
  47 {
  48         const uint size;
  49         int (* function) (const gsl_vector *x, void *params, gsl_vector *f);
  50 };
  51
  52 typedef darray(const HklFunction*) darray_function;
  53
  54 struct _HklModeAutoInfo {
  55         const HklModeInfo info;
  56         darray_function functions;
  57 };
  58
  59 #define HKL_MODE_OPERATIONS_AUTO_DEFAULTS       \
  60         HKL_MODE_OPERATIONS_DEFAULTS,           \
  61                 .set = hkl_mode_auto_set_real
  62
  63 #define CHECK_NAN(x, len) do{                           \
  64                 for(uint i=0; i<len; ++i)               \
  65                         if(gsl_isnan(x[i]))             \
  66                                 return GSL_EINVAL;      \
  67         }while(0)
  68
  69 #define HKL_MODE_AUTO_INFO(_name, _axes_r, _axes_w, _fn) .info={HKL_MODE_INFO(_name, _axes_r, _axes_w),}, .functions=DARRAY(_fn)
  70
  71 #define HKL_MODE_AUTO_INFO_WITH_PARAMS(_name, _axes_r, _axes_w, _fn, _parameters) .info={HKL_MODE_INFO_WITH_PARAMS(_name, _axes_r, _axes_w, _parameters)}, .functions=DARRAY(_fn)
  72
  73 extern HklMode *hkl_mode_auto_new(const HklModeAutoInfo *auto_info,
  74                                   const HklModeOperations *ops,
  75                                   int initialized);
  76
  77 extern void hkl_mode_auto_init(HklMode *self,
  78                                const HklModeAutoInfo *auto_info,
  79                                const HklModeOperations *ops,
  80                                int initialized);
  81
  82 extern int hkl_mode_auto_set_real(HklMode *self,
  83                                   HklEngine *engine,
  84                                   HklGeometry *geometry,
  85                                   HklDetector *detector,
  86                                   HklSample *sample,
  87                                   GError **error);
  88
  89 /***********************/
  90 /* HklModeAutoWithInit */
  91 /***********************/
  92
  93 struct _HklModeAutoWithInit {
  94         HklMode mode;
  95         HklGeometry *geometry;
  96         HklDetector *detector;
  97         HklSample *sample;
  98 };
  99
 100 #define HKL_MODE_AUTO_WITH_INIT_ERROR hkl_mode_auto_with_init_error_quark ()
 101
 102 static inline GQuark hkl_mode_auto_with_init_error_quark (void)
 103 {
 104         return g_quark_from_static_string ("hkl-mode-auto-with-init-error-quark");
 105 }
 106
 107 typedef enum {
 108         HKL_MODE_AUTO_WITH_INIT_ERROR_INIT /* can not set the pseudo axis engine */
 109 } HklModeError;
 110
 111 #define HKL_MODE_OPERATIONS_AUTO_WITH_INIT_DEFAULTS                     \
 112         HKL_MODE_OPERATIONS_AUTO_DEFAULTS,                              \
 113                 .capabilities = HKL_ENGINE_CAPABILITIES_READABLE | HKL_ENGINE_CAPABILITIES_WRITABLE | HKL_ENGINE_CAPABILITIES_INITIALIZABLE, \
 114                 .free = hkl_mode_auto_with_init_free_real,              \
 115                 .initialized_set = hkl_mode_auto_with_init_initialized_set_real
 116
 117 static NEEDED void hkl_mode_auto_with_init_free_real(HklMode *mode)
 118 {
 119         HklModeAutoWithInit *self = container_of(mode, HklModeAutoWithInit, mode);
 120
 121         if(self->geometry)
 122                 hkl_geometry_free(self->geometry);
 123         if(self->detector)
 124                 hkl_detector_free(self->detector);
 125         if(self->sample)
 126                 hkl_sample_free(self->sample);
 127
 128         hkl_mode_free_real(mode);
 129 }
 130
 131
 132 static NEEDED int hkl_mode_auto_with_init_initialized_set_real(HklMode *mode,
 133                                                                HklEngine *engine,
 134                                                                HklGeometry *geometry,
 135                                                                HklDetector *detector,
 136                                                                HklSample *sample,
 137                                                                int initialized,
 138                                                                GError **error)
 139 {
 140         HklModeAutoWithInit *self = container_of(mode, HklModeAutoWithInit, mode);
 141
 142         hkl_error(error == NULL || *error == NULL);
 143
 144         if(initialized){
 145                 if(geometry){
 146                         if(self->geometry)
 147                                 hkl_geometry_free(self->geometry);
 148                         self->geometry = hkl_geometry_new_copy(geometry);
 149                 }
 150                 if(detector){
 151                         if(self->detector)
 152                                 hkl_detector_free(self->detector);
 153                         self->detector = hkl_detector_new_copy(detector);
 154                 }
 155                 if(sample){
 156                         if(self->sample)
 157                                 hkl_sample_free(self->sample);
 158                         self->sample = hkl_sample_new_copy(sample);
 159                 }
 160         }
 161
 162         mode->initialized = initialized;
 163
 164         return TRUE;
 165 }
 166
 167 extern HklMode *hkl_mode_auto_with_init_new(const HklModeAutoInfo *info,
 168                                             const HklModeOperations *ops,
 169                                             int initialized);
 170
 171 G_END_DECLS
 172
 173 #endif /* __HKL_PSEUDOAXIS_AUTO_H__ */