hkl/hkl-binding.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) 2012-2019, 2022, 2023 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
  23 #include <stdlib.h>                     // for malloc
  24 #include <string.h>                     // for NULL, strdup
  25 #include <sys/types.h>                  // for uint
  26 #include "hkl.h"                        // for HklGeometry, HklEngine, etc
  27 #include "hkl-binding-private.h"
  28 #include "hkl-factory-private.h"        // for __start_xautodata_factories, etc
  29 #include "hkl-geometry-private.h"       // for _HklGeometry, etc
  30 #include "hkl-parameter-private.h"
  31 #include "hkl-pseudoaxis-private.h"     // for _HklEngine, HklEngineInfo
  32 #include "hkl-sample-private.h"         // for _HklSampleReflection, etc
  33 #include "hkl/ccan/autodata/autodata.h"  // for autodata_get
  34 #include "hkl/ccan/darray/darray.h"     // for darray_foreach, darray_size
  35 #include "hkl/ccan/list/list.h"             // for list_for_each, list_head
  36
  37 /*****************/
  38 /* HklQuaternion */
  39 /*****************/
  40
  41 /**
  42  * hkl_quaternion_to_matrix_binding: (rename-to hkl_quaternion_to_matrix)
  43  * @self: the #HklQuaternion use to compute the #HklMatrix
  44  *
  45  * Returns: (transfer full): the @HklQuaternion@ as a @HklMatrix@.
  46  */
  47 HklMatrix *hkl_quaternion_to_matrix_binding(const HklQuaternion *self)
  48 {
  49         HklMatrix *m = hkl_matrix_new();
  50
  51         hkl_quaternion_to_matrix(self, m);
  52
  53         return m;
  54 }
  55
  56
  57 /**************/
  58 /* HklFactory */
  59 /**************/
  60
  61 /**
  62  * hkl_factories:
  63  *
  64  * return all the Hkl factories objects as a dictionnary
  65  *
  66  * Returns: (element-type utf8 Hkl.Factory) (transfer container):
  67  **/
  68 GHashTable *hkl_factories(void)
  69 {
  70         GHashTable *table = NULL;
  71         size_t i, n;
  72         HklFactory **factories;
  73
  74         table = g_hash_table_new(g_str_hash, g_str_equal);
  75         factories = autodata_get(factories, &n);
  76         for(i=0; i<n; ++i){
  77                 g_hash_table_insert(table,
  78                                     (gpointer)hkl_factory_name_get(factories[i]),
  79                                     factories[i]);
  80         }
  81
  82         return table;
  83 }
  84
  85 /************/
  86 /* Geometry */
  87 /************/
  88
  89 /**
  90  * hkl_geometry_axis_names_get_binding: (rename-to hkl_geometry_axis_names_get)
  91  * @self: the this ptr
  92  * @length: (out caller-allocates): the length of the returned array
  93  *
  94  * get all the axes of the given geometry.
  95  *
  96  * Returns: (array length=length) (transfer none): array of the axes names.
  97  **/
  98 const char **hkl_geometry_axis_names_get_binding(const HklGeometry *self,
  99                                                  size_t *length)
 100 {
 101         const darray_string *axes = hkl_geometry_axis_names_get(self);
 102
 103         *length = darray_size(*axes);
 104
 105         return &darray_item(*axes, 0);
 106 }
 107
 108 /**
 109  * hkl_geometry_axis_values_get_binding: (rename-to hkl_geometry_axis_values_get)
 110  * @self: the this ptr
 111  * @len: (out caller-allocates): the length of the returned array
 112  * @unit_type: the unit type (default or user) of the returned value
 113  *
 114  * Return value: (array length=len) (transfer container): list of axes values,
 115  *          free the list with free when done.
 116  **/
 117 double *hkl_geometry_axis_values_get_binding(const HklGeometry *self, guint *len,
 118                                              HklUnitEnum unit_type)
 119 {
 120         double *values;
 121         uint i = 0;
 122         HklParameter **axis;
 123
 124         if(darray_size(self->axes) == 0)
 125                 return NULL;
 126
 127         *len = darray_size(self->axes);
 128         values = g_new(double, darray_size(self->axes));
 129
 130         darray_foreach(axis, self->axes){
 131                 values[i++] = hkl_parameter_value_get(*axis, unit_type);
 132         }
 133
 134         return values;
 135 }
 136
 137 /**
 138  * hkl_geometry_sample_rotation_get_binding: (rename-to hkl_geometry_sample_rotation_get)
 139  * @self: the self @HklGeometry@
 140  * @sample: the rotated sample.
 141  *
 142  * return the rotation part of the given sample in the laboratory basis.
 143  *
 144  * Returns: (transfer full): the rotation express as a quaternion.
 145  **/
 146 HklQuaternion *hkl_geometry_sample_rotation_get_binding(const HklGeometry *self,
 147                                                         const HklSample *sample)
 148 {
 149         HklQuaternion q = hkl_geometry_sample_rotation_get(self, sample);
 150
 151         return hkl_quaternion_dup(&q);
 152 }
 153
 154 /**
 155  * hkl_geometry_detector_rotation_get_binding: (rename-to hkl_geometry_detector_rotation_get)
 156  * @self: the self #HklGeometry
 157  *
 158  * return the rotation part of the given detector in the laboratory
 159  * basis.
 160  *
 161  * Returns: (transfer full): the rotation express as a quaternion.
 162  **/
 163 HklQuaternion *hkl_geometry_detector_rotation_get_binding(const HklGeometry *self,
 164                                                           const HklDetector *detector)
 165 {
 166         HklQuaternion q = hkl_geometry_detector_rotation_get(self, detector);
 167
 168         return hkl_quaternion_dup(&q);
 169 }
 170
 171 /**
 172  * hkl_geometry_ki_get_binding: (rename-to hkl_geometry_ki_get)
 173  * @self: the self #HklGeometry
 174  *
 175  * return the ki vector in the laboratory
 176  * basis.
 177  *
 178  * Returns: (transfer full): the ki vector.
 179  **/
 180 HklVector *hkl_geometry_ki_get_binding(const HklGeometry *self)
 181 {
 182         HklVector v = hkl_geometry_ki_get(self);
 183
 184         return hkl_vector_dup(&v);
 185 }
 186
 187 /**
 188  * hkl_geometry_ki_abc_get_binding: (rename-to hkl_geometry_ki_abc_get)
 189  * @self: the self #HklGeometry
 190  * @sample: the sample to project into #HklSample.
 191  *
 192  * return the ki vector in the sample lattice recipocal.
 193  * basis.
 194  *
 195  * Returns: (transfer full): the ki vector.
 196  **/
 197 HklVector *hkl_geometry_ki_abc_get_binding(const HklGeometry *self,
 198                                            const HklSample *sample)
 199 {
 200         HklVector v = hkl_geometry_ki_abc_get(self, sample);
 201
 202         return hkl_vector_dup(&v);
 203 }
 204
 205 /**
 206  * hkl_geometry_kf_get_binding: (rename-to hkl_geometry_kf_get)
 207  * @self: the self #HklGeometry
 208  * @detector: the self #HklDetector
 209  *
 210  * return the kf vector in the laboratory
 211  * basis.
 212  *
 213  * Returns: (transfer full): the kf vector.
 214  **/
 215 HklVector *hkl_geometry_kf_get_binding(const HklGeometry *self,
 216                                        const HklDetector *detector)
 217 {
 218         HklVector v = hkl_geometry_kf_get(self, detector);
 219
 220         return hkl_vector_dup(&v);
 221 }
 222
 223 /**
 224  * hkl_geometry_kf_abc_get_binding: (rename-to hkl_geometry_kf_abc_get)
 225  * @self: the self #HklGeometry
 226  * @detector: the self #HklDetector
 227  * @sample: the sample to project into #HklSample.
 228  *
 229  * return the kf vector in the laboratory
 230  * basis.
 231  *
 232  * Returns: (transfer full): the kf vector.
 233  **/
 234 HklVector *hkl_geometry_kf_abc_get_binding(const HklGeometry *self,
 235                                            const HklDetector *detector,
 236                                            const HklSample *sample)
 237 {
 238         HklVector v = hkl_geometry_kf_abc_get(self, detector, sample);
 239
 240         return hkl_vector_dup(&v);
 241 }
 242
 243 /*******************/
 244 /* HklGeometryList */
 245 /*******************/
 246
 247 /**
 248  * hkl_geometry_list_items:
 249  * @self: the #HklGeometryList
 250  *
 251  * Return value: (element-type HklGeometryListItem) (transfer container): list of items,
 252  *               free the list with g_slist_free when done.
 253  **/
 254 GSList* hkl_geometry_list_items(HklGeometryList *self)
 255 {
 256         GSList *list = NULL;
 257         HklGeometryListItem *item;
 258
 259         list_for_each(&self->items, item, list)
 260                 list = g_slist_append(list, item);
 261
 262         return list;
 263 }
 264
 265 /*************/
 266 /* HklEngine */
 267 /*************/
 268
 269 /**
 270  * hkl_engine_modes_names_get_binding: (rename-to hkl_engine_modes_names_get)
 271  * @self: the this ptr
 272  * @length: (out caller-allocates): return the length of the returned array.
 273  *
 274  * Return value: (array length=length) (transfer none): All the modes supported by the #HklEngine
 275  **/
 276 const char **hkl_engine_modes_names_get_binding(const HklEngine *self, size_t *length)
 277 {
 278         *length = darray_size(self->mode_names);
 279         return &darray_item(self->mode_names, 0);
 280 }
 281
 282 /**
 283  * hkl_engine_pseudo_axis_names_get_binding: (rename-to hkl_engine_pseudo_axis_names_get)
 284  * @self: the this ptr
 285  * @length: (out caller-allocates): return the length of the returned array.
 286  *
 287  * Return value: (array length=length) (transfer none): All the pseudo_axes names of the #HklEngine
 288  *
 289  **/
 290 const char **hkl_engine_pseudo_axis_names_get_binding(HklEngine *self, size_t *length)
 291 {
 292         *length = darray_size(self->pseudo_axis_names);
 293         return &darray_item(self->pseudo_axis_names, 0);
 294 }
 295
 296 /**
 297  * hkl_engine_parameters_names_get_binding: (rename-to hkl_engine_parameters_names_get)
 298  * @self: the this ptr
 299  * @length: (out caller-allocates): return the length of the returned array.
 300  *
 301  * Return value: (array length=length) (transfer none): All the parameters of #HklEngine.
 302  **/
 303 const char **hkl_engine_parameters_names_get_binding(const HklEngine *self, size_t *length)
 304 {
 305         *length = darray_size(self->mode->parameters_names);
 306         return &darray_item(self->mode->parameters_names, 0);
 307 }
 308
 309 /**
 310  * hkl_engine_axis_names_get_binding: (rename-to hkl_engine_axis_names_get)
 311  * @self: the this ptr
 312  * @mode: the #HklEngineAxesNamesGet
 313  * @length: (out caller-allocates): return the length of the returned array.
 314  *
 315  * Return value: (array length=length) (transfer none): axes of the #HklEngine for the given mode.
 316  **/
 317 const char **hkl_engine_axis_names_get_binding(const HklEngine *self,
 318                                                HklEngineAxisNamesGet mode,
 319                                                size_t *length)
 320 {
 321         const darray_string *axes = hkl_engine_axis_names_get(self, mode);
 322
 323         *length = darray_size(*axes);
 324
 325         return &darray_item(*axes, 0);
 326 }
 327
 328 /**
 329  * hkl_engine_parameters_values_get_binding: (rename-to hkl_engine_parameters_values_get)
 330  * @self: the this ptr
 331  * @len: (out caller-allocates): the length of the returned array
 332  * @unit_type: the unit type (default or user) of the returned value
 333  *
 334  * Return value: (array length=len) (transfer container): list of parameters values,
 335  *          free the list with free when done.
 336  **/
 337 double *hkl_engine_parameters_values_get_binding(const HklEngine *self, guint *len,
 338                                                  HklUnitEnum unit_type)
 339 {
 340         double *values;
 341         uint i = 0;
 342         HklParameter **parameter;
 343
 344         if(!self->mode || darray_size(self->mode->parameters) == 0)
 345                 return NULL;
 346
 347         *len = darray_size(self->mode->parameters);
 348         values = g_new(double, *len);
 349
 350         darray_foreach(parameter, self->mode->parameters){
 351                 values[i++] = hkl_parameter_value_get(*parameter, unit_type);
 352         }
 353
 354         return values;
 355 }
 356
 357 /**
 358  * hkl_engine_pseudo_axis_values_get_binding: (rename-to hkl_engine_pseudo_axis_values_get)
 359  * @self: the this ptr
 360  * @len: (out caller-allocates): the length of the returned array
 361  * @unit_type: the unit type (default or user) of the returned value
 362  *
 363  * Return value: (array length=len) (transfer container): list of pseudo axes values,
 364  *          free the list with free when done.
 365  **/
 366 double *hkl_engine_pseudo_axis_values_get_binding(const HklEngine *self, guint *len,
 367                                                   HklUnitEnum unit_type)
 368 {
 369         double *values;
 370         uint i = 0;
 371         HklParameter **axis;
 372
 373         if(!self || !len || darray_size(self->pseudo_axes) == 0)
 374                 return NULL;
 375
 376         *len = darray_size(self->pseudo_axes);
 377         values = g_new(double, *len);
 378
 379         darray_foreach(axis, self->pseudo_axes){
 380                 values[i++] = hkl_parameter_value_get(*axis, unit_type);
 381         }
 382
 383         return values;
 384 }
 385
 386 /**
 387  * hkl_engine_list_engines_get_as_gslist: (rename-to hkl_engine_list_engines_get)
 388  * @self: the this ptr
 389  *
 390  * Return value: (element-type HklEngine) (transfer container): list of engines,
 391  *               free the list with g_slist_free when done.
 392  **/
 393 GSList* hkl_engine_list_engines_get_as_gslist(HklEngineList *self)
 394 {
 395         GSList *list = NULL;
 396         HklEngine **engine;
 397
 398         darray_foreach(engine, *self){
 399                 list = g_slist_append(list, *engine);
 400         }
 401
 402         return list;
 403 }
 404
 405 /*****************/
 406 /* HklEngineList */
 407 /*****************/
 408
 409 /**
 410  * hkl_engine_list_parameters_names_get_binding: (rename-to hkl_engine_list_parameters_names_get)
 411  * @self: the this ptr
 412  * @length: (out caller-allocates): return the length of the returned array.
 413  *
 414  * Return value: (array length=length) (transfer none): All the modes supported by the #HklEngineList
 415  **/
 416 const char **hkl_engine_list_parameters_names_get_binding(const HklEngineList *self, size_t *length)
 417 {
 418         *length = darray_size(self->parameters_names);
 419         return &darray_item(self->parameters_names, 0);
 420 }
 421
 422 /**
 423  * hkl_engine_list_parameters_values_get_binding: (rename-to hkl_engine_list_parameters_values_get)
 424  * @self: the this ptr
 425  * @len: (out caller-allocates): the length of the returned array
 426  * @unit_type: the unit type (default or user) of the returned value
 427  *
 428  * Return value: (array length=len) (transfer container): list of parameters values,
 429  *          free the list with free when done.
 430  **/
 431 double *hkl_engine_list_parameters_values_get_binding(const HklEngineList *self, guint *len,
 432                                                       HklUnitEnum unit_type)
 433 {
 434         double *values;
 435         uint i = 0;
 436         HklParameter **parameter;
 437
 438         if(darray_size(self->parameters) == 0)
 439                 return NULL;
 440
 441         *len = darray_size(self->parameters);
 442         values = g_new(double, *len);
 443
 444         darray_foreach(parameter, self->parameters){
 445                 values[i++] = hkl_parameter_value_get(*parameter, unit_type);
 446         }
 447
 448         return values;
 449 }
 450
 451 /*************/
 452 /* HklSample */
 453 /*************/
 454
 455 /**
 456  * hkl_sample_reflections_get:
 457  * @self: the this ptr
 458  *
 459  * Return value: (element-type HklSampleReflection) (transfer container): list of reflections,
 460  *               free the list with g_slist_free when done.
 461  */
 462 GSList *hkl_sample_reflections_get(const HklSample *self)
 463 {
 464         GSList *list = NULL;
 465         HklSampleReflection *reflection;
 466
 467         list_for_each(&self->reflections, reflection, list){
 468                 list = g_slist_append(list, reflection);
 469         }
 470
 471         return list;
 472 }
 473
 474 /**
 475  * hkl_sample_add_reflection_binding: (rename-to hkl_sample_add_reflection)
 476  * @self: the this ptr
 477  * @geometry: the geometry of the HklSampleReflection
 478  * @detector: the detector of the HklSampleReflection
 479  * @h: the h coordinate
 480  * @k: the k coordinate
 481  * @l: the l coordinate
 482  * @error: return location for a GError, or NULL
 483  *
 484  * Return value: (transfer none): the newly created HklSampleReflection
 485  **/
 486 HklSampleReflection *hkl_sample_add_reflection_binding(HklSample *self,
 487                                                        const HklGeometry *geometry,
 488                                                        const HklDetector *detector,
 489                                                        double h, double k, double l,
 490                                                        GError **error)
 491 {
 492         HklSampleReflection *reflection;
 493
 494         hkl_error (error == NULL || *error == NULL);
 495
 496         reflection = hkl_sample_reflection_new(geometry, detector,
 497                                                h, k, l, error);
 498         if(!reflection){
 499                 hkl_assert (error == NULL || *error != NULL);
 500                 return NULL;
 501         }
 502         hkl_assert (error == NULL || *error == NULL);
 503
 504         hkl_sample_add_reflection(self, reflection);
 505
 506         return reflection;
 507 }