hkl/hkl-pseudoaxis-common-readonly.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-2016 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 "hkl-pseudoaxis-common-readonly-private.h"
  23 #include "hkl-pseudoaxis-private.h"
  24
  25 /* incidence */
  26
  27 typedef struct _HklEngineIncidence HklEngineIncidence;
  28
  29 struct _HklEngineIncidence
  30 {
  31         HklEngine engine;
  32         HklParameter *incidence;
  33         HklParameter *azimuth;
  34 };
  35
  36 #define HKL_MODE_INCIDENCE_ERROR hkl_mode_incidence_error_quark ()
  37
  38 static GQuark hkl_mode_incidence_error_quark (void)
  39 {
  40         return g_quark_from_static_string ("hkl-mode-incidence-error-quark");
  41 }
  42
  43 typedef enum {
  44         HKL_MODE_INCIDENCE_ERROR_GET, /* can not get the engine */
  45         HKL_MODE_INCIDENCE_ERROR_SET, /* can not set the engine */
  46 } HklModeIncidenceError;
  47
  48 static int hkl_mode_incidence_get_real(HklMode *base,
  49                                        HklEngine *engine,
  50                                        HklGeometry *geometry,
  51                                        HklDetector *detector,
  52                                        HklSample *sample,
  53                                        GError **error)
  54 {
  55         HklVector ki;
  56         double incidence;
  57         double azimuth;
  58         static const HklVector Y = {
  59                 .data = {0, 1, 0},
  60         };
  61
  62         if (!base || !engine || !engine->mode || !geometry || !detector || !sample){
  63                 g_set_error(error,
  64                             HKL_MODE_INCIDENCE_ERROR,
  65                             HKL_MODE_INCIDENCE_ERROR_GET,
  66                             "internal error");
  67                 return FALSE;
  68         }
  69         HklEngineIncidence *engine_incidence = container_of(engine, HklEngineIncidence, engine);
  70         const HklModeIncidence *mode = container_of(base, HklModeIncidence, parent);
  71         HklVector n = {
  72                 .data = {
  73                         mode->n_x->_value,
  74                         mode->n_y->_value,
  75                         mode->n_z->_value,
  76                 }
  77         };
  78
  79         /* first check the parameters */
  80         if (hkl_vector_is_null(&n)){
  81                 g_set_error(error,
  82                             HKL_MODE_INCIDENCE_ERROR,
  83                             HKL_MODE_INCIDENCE_ERROR_GET,
  84                             "can not compute the incidence when the surface vector is null.");
  85                 return FALSE;
  86         }
  87
  88         /* compute the orientation of the surface */
  89         hkl_vector_rotated_quaternion(&n, &darray_item(geometry->holders, 0)->q);
  90
  91         hkl_source_compute_ki(&geometry->source, &ki);
  92         incidence = _incidence(&n, &ki);
  93
  94         hkl_vector_project_on_plan(&n, &ki);
  95         azimuth = hkl_vector_angle(&n, &Y);
  96
  97         engine_incidence->incidence->_value = incidence;
  98         engine_incidence->azimuth->_value = azimuth;
  99
 100         return TRUE;
 101 }
 102
 103 static int hkl_mode_readonly_set_real(HklMode *base,
 104                                       HklEngine *engine,
 105                                       HklGeometry *geometry,
 106                                       HklDetector *detector,
 107                                       HklSample *sample,
 108                                       GError **error)
 109 {
 110         g_set_error(error,
 111                     HKL_MODE_INCIDENCE_ERROR,
 112                     HKL_MODE_INCIDENCE_ERROR_SET,
 113                     "The \"%s\" engine is readonly", base->info->name);
 114         return FALSE;
 115 }
 116
 117 HklMode *hkl_mode_incidence_new(const HklModeInfo *info)
 118 {
 119         static const HklModeOperations operations = {
 120                 HKL_MODE_OPERATIONS_DEFAULTS,
 121                 .capabilities = HKL_ENGINE_CAPABILITIES_READABLE,
 122                 .get = hkl_mode_incidence_get_real,
 123                 .set = hkl_mode_readonly_set_real,
 124         };
 125         HklModeIncidence *self = HKL_MALLOC(HklModeIncidence);
 126
 127         /* the base constructor; */
 128         hkl_mode_init(&self->parent,
 129                       info,
 130                       &operations, TRUE);
 131
 132         self->n_x = register_mode_parameter(&self->parent, 0);
 133         self->n_y = register_mode_parameter(&self->parent, 1);
 134         self->n_z = register_mode_parameter(&self->parent, 2);
 135
 136         return &self->parent;
 137 }
 138
 139 HklEngine *hkl_engine_incidence_new(HklEngineList *engines)
 140 {
 141         HklEngineIncidence *self;
 142         static const HklParameter incidence = {
 143                 HKL_PARAMETER_DEFAULTS_ANGLE, .name = "incidence",
 144                 .description = "incidence of the incomming beam.",
 145         };
 146         static const HklParameter azimuth = {
 147                 HKL_PARAMETER_DEFAULTS_ANGLE, .name = "azimuth",
 148                 .description = "azimuth of the sample surface (projection of $\\vec{n}$ on the $yOz$ plan",
 149         };
 150         static const HklParameter *pseudo_axes[] = {&incidence, &azimuth};
 151         static HklEngineInfo info = {
 152                 HKL_ENGINE_INFO("incidence",
 153                                 pseudo_axes,
 154                                 HKL_ENGINE_DEPENDENCIES_AXES | HKL_ENGINE_DEPENDENCIES_SAMPLE),
 155         };
 156         static HklEngineOperations operations = {
 157                 HKL_ENGINE_OPERATIONS_DEFAULTS,
 158         };
 159
 160         self = HKL_MALLOC(HklEngineIncidence);
 161
 162         hkl_engine_init(&self->engine, &info, &operations, engines);
 163
 164         self->incidence = register_pseudo_axis(&self->engine, engines, &incidence);
 165         self->azimuth = register_pseudo_axis(&self->engine, engines, &azimuth);
 166
 167         return &self->engine;
 168 }
 169
 170 /* emergence */
 171
 172 typedef struct _HklEngineEmergence HklEngineEmergence;
 173
 174 struct _HklEngineEmergence
 175 {
 176         HklEngine engine;
 177         HklParameter *emergence;
 178         HklParameter *azimuth;
 179 };
 180
 181 #define HKL_MODE_EMERGENCE_ERROR hkl_mode_emergence_error_quark ()
 182
 183 static GQuark hkl_mode_emergence_error_quark (void)
 184 {
 185         return g_quark_from_static_string ("hkl-mode-emergence-error-quark");
 186 }
 187
 188 typedef enum {
 189         HKL_MODE_EMERGENCE_ERROR_GET, /* can not get the engine */
 190         HKL_MODE_EMERGENCE_ERROR_SET, /* can not set the engine */
 191 } HklModeEmergenceError;
 192
 193 static int hkl_mode_emergence_get_real(HklMode *base,
 194                                        HklEngine *engine_base,
 195                                        HklGeometry *geometry,
 196                                        HklDetector *detector,
 197                                        HklSample *sample,
 198                                        GError **error)
 199 {
 200         HklVector kf;
 201         double emergence;
 202         double azimuth;
 203         static const HklVector X = {
 204                 .data = {1, 0, 0},
 205         };
 206         static const HklVector Y = {
 207                 .data = {0, 1, 0},
 208         };
 209
 210         if (!base || !engine_base || !engine_base->mode || !geometry || !detector || !sample){
 211                 g_set_error(error,
 212                             HKL_MODE_EMERGENCE_ERROR,
 213                             HKL_MODE_EMERGENCE_ERROR_GET,
 214                             "internal error");
 215                 return FALSE;
 216         }
 217         HklEngineEmergence *engine = container_of(engine_base, HklEngineEmergence, engine);
 218         const HklModeIncidence *mode = container_of(base, HklModeIncidence, parent);
 219         HklVector n = {
 220                 .data = {
 221                         mode->n_x->_value,
 222                         mode->n_y->_value,
 223                         mode->n_z->_value,
 224                 }
 225         };
 226
 227         /* first check the parameters */
 228         if (hkl_vector_is_null(&n)){
 229                 g_set_error(error,
 230                             HKL_MODE_EMERGENCE_ERROR,
 231                             HKL_MODE_EMERGENCE_ERROR_GET,
 232                             "Can not compute the emergence when the surface vector is null.");
 233                 return FALSE;
 234         }
 235
 236         /* compute the orientation of the surface */
 237         hkl_vector_rotated_quaternion(&n, &darray_item(geometry->holders, 0)->q);
 238
 239         hkl_detector_compute_kf(detector, geometry, &kf);
 240         emergence = _emergence(&n, &kf);
 241
 242         hkl_vector_project_on_plan(&n, &X);
 243         azimuth = hkl_vector_angle(&n, &Y);
 244
 245         engine->emergence->_value = emergence;
 246         engine->azimuth->_value = azimuth;
 247
 248         return TRUE;
 249 }
 250
 251 HklMode *hkl_mode_emergence_new(const HklModeInfo *info)
 252 {
 253         static const HklModeOperations operations = {
 254                 HKL_MODE_OPERATIONS_DEFAULTS,
 255                 .capabilities = HKL_ENGINE_CAPABILITIES_READABLE,
 256                 .get = hkl_mode_emergence_get_real,
 257                 .set = hkl_mode_readonly_set_real,
 258         };
 259         HklModeIncidence *self = HKL_MALLOC(HklModeIncidence);
 260
 261         /* the base constructor; */
 262         hkl_mode_init(&self->parent,
 263                       info,
 264                       &operations, TRUE);
 265
 266         self->n_x = register_mode_parameter(&self->parent, 0);
 267         self->n_y = register_mode_parameter(&self->parent, 1);
 268         self->n_z = register_mode_parameter(&self->parent, 2);
 269
 270         return &self->parent;
 271 }
 272
 273 HklEngine *hkl_engine_emergence_new(HklEngineList *engines)
 274 {
 275         HklEngineEmergence *self;
 276         static const HklParameter emergence = {
 277                 HKL_PARAMETER_DEFAULTS_ANGLE, .name = "emergence",
 278                 .description = "incidence of the outgoing beam.",
 279         };
 280         static const HklParameter azimuth = {
 281                 HKL_PARAMETER_DEFAULTS_ANGLE, .name = "azimuth",
 282                 .description = "azimuth of the sample surface (projection of $\\vec{n}$ on the $yOz$ plan",
 283         };
 284         static const HklParameter *pseudo_axes[] = {&emergence, &azimuth};
 285         static HklEngineInfo info = {
 286                 HKL_ENGINE_INFO("emergence",
 287                                 pseudo_axes,
 288                                 HKL_ENGINE_DEPENDENCIES_AXES | HKL_ENGINE_DEPENDENCIES_SAMPLE),
 289         };
 290         static HklEngineOperations operations = {
 291                 HKL_ENGINE_OPERATIONS_DEFAULTS,
 292         };
 293
 294         self = HKL_MALLOC(HklEngineEmergence);
 295
 296         hkl_engine_init(&self->engine, &info, &operations, engines);
 297
 298         self->emergence = register_pseudo_axis(&self->engine, engines, &emergence);
 299         self->azimuth = register_pseudo_axis(&self->engine, engines, &azimuth);
 300
 301         return &self->engine;
 302 }