hkl/hkl-pseudoaxis.c

   1 /*
   2  * This file is part of the hkl library.
   3  *
   4  * The hkl library is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * The hkl library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Copyright (C) 2003-2014 Synchrotron SOLEIL
  18  *                         L'Orme des Merisiers Saint-Aubin
  19  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  20  *
  21  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  22  */
  23 #include <stdio.h>                      // for fprintf, FILE
  24 #include <stdlib.h>                     // for free
  25 #include <string.h>                     // for NULL, strcmp
  26 #include <sys/types.h>                  // for uint
  27 #include "hkl-detector-private.h"       // for hkl_detector_new_copy
  28 #include "hkl-geometry-private.h"       // for _HklGeometryList, etc
  29 #include "hkl-macros-private.h"         // for hkl_assert, HKL_MALLOC, etc
  30 #include "hkl-parameter-private.h"      // for hkl_parameter_list_fprintf, etc
  31 #include "hkl-pseudoaxis-private.h"     // for _HklEngine, _HklEngineList, etc
  32 #include "hkl.h"                        // for HklEngine, HklEngineList, etc
  33 #include "hkl/ccan/container_of/container_of.h"  // for container_of
  34 #include "hkl/ccan/darray/darray.h"     // for darray_foreach, darray_init, etc
  35
  36 /*****************/
  37 /* HklPseudoAxis */
  38 /*****************/
  39
  40 static inline HklParameter *hkl_pseudo_axis_copy_real(const HklParameter *base)
  41 {
  42         HklPseudoAxis *self = container_of(base, HklPseudoAxis, parameter);
  43         HklPseudoAxis *dup = HKL_MALLOC(HklPseudoAxis);
  44
  45         *dup = *self;
  46
  47         return &dup->parameter;
  48 }
  49
  50 static inline void hkl_pseudo_axis_free_real(HklParameter *self)
  51 {
  52         HklPseudoAxis *pseudo_axis = container_of(self, HklPseudoAxis, parameter);
  53
  54         free(pseudo_axis);
  55 }
  56
  57 static inline void hkl_pseudo_axis_fprintf_real(FILE *f, const HklParameter *self)
  58 {
  59         HklPseudoAxis *pseudo_axis = container_of(self, HklPseudoAxis, parameter);
  60
  61         hkl_parameter_fprintf_real(f, self);
  62         fprintf(f, " %p", pseudo_axis->engine);
  63 }
  64
  65 static HklParameterOperations hkl_parameter_operations_pseudo_axis = {
  66         HKL_PARAMETER_OPERATIONS_DEFAULTS,
  67         .copy = hkl_pseudo_axis_copy_real,
  68         .free = hkl_pseudo_axis_free_real,
  69         .fprintf = hkl_pseudo_axis_fprintf_real,
  70 };
  71
  72 HklParameter *hkl_parameter_new_pseudo_axis(
  73         const HklParameter *parameter,
  74         HklEngine *engine)
  75 {
  76         HklPseudoAxis *self;
  77
  78         self = HKL_MALLOC(HklPseudoAxis);
  79
  80         self->parameter = *parameter;
  81         self->parameter.ops = &hkl_parameter_operations_pseudo_axis;
  82         self->engine = engine;
  83
  84         return &self->parameter;
  85 }
  86
  87 /***********/
  88 /* HklMode */
  89 /***********/
  90
  91 /**
  92  * hkl_mode_fprintf: (skip)
  93  * @f:
  94  * @self:
  95  *
  96  * print to a FILE the HklPSeudoAxisEngineMode members
  97  **/
  98 void hkl_mode_fprintf(FILE *f, const HklMode *self)
  99 {
 100         unsigned int i;
 101         HklParameter **parameter;
 102
 103         fprintf(f, "mode: \"%s\"\n", self->info->name);
 104         fprintf(f, "initialize: %p\n", self->ops->init);
 105         fprintf(f, "get: %p\n", self->ops->get);
 106         fprintf(f, "set: %p\n", self->ops->set);
 107
 108         darray_foreach(parameter, self->parameters){
 109                 fprintf(f, "\n     ");
 110                 hkl_parameter_fprintf(f, *parameter);
 111         }
 112
 113         if(self->info->axes){
 114                 fprintf(f, "axes names:");
 115                 for(i=0; i<self->info->n_axes; ++i)
 116                         fprintf(f, " %s", self->info->axes[i]);
 117                 fprintf(f, "\n");
 118         }
 119 }
 120
 121 /*************/
 122 /* HklEngine */
 123 /*************/
 124
 125 void hkl_engine_init(HklEngine *self,
 126                      const HklEngineInfo *info,
 127                      const HklEngineOperations *ops)
 128 {
 129         self->info = info;
 130         self->ops = ops;
 131         darray_init(self->modes);
 132         darray_init(self->pseudo_axes);
 133         darray_init(self->pseudo_axes_names);
 134         darray_init(self->mode_names);
 135         self->geometry = NULL;
 136         self->detector = NULL;
 137         self->sample = NULL;
 138 }
 139
 140 void unregister_pseudo_axis(HklParameter *pseudo_axis)
 141 {
 142         hkl_parameter_free(pseudo_axis);
 143 }
 144
 145 HklParameter *register_pseudo_axis(HklEngine *self,
 146                                    const HklParameter *conf)
 147 {
 148         HklParameter *parameter;
 149
 150         parameter = hkl_parameter_new_pseudo_axis(conf, self);
 151         darray_append(self->pseudo_axes, parameter);
 152         darray_append(self->pseudo_axes_names, parameter->name);
 153
 154         return parameter;
 155 }
 156
 157 static void hkl_engine_prepare_internal(HklEngine *self)
 158 {
 159         uint i;
 160
 161         if(!self || !self->engines)
 162                 return;
 163
 164         /* set */
 165         if(self->geometry)
 166                 hkl_geometry_free(self->geometry);
 167         self->geometry = hkl_geometry_new_copy(self->engines->geometry);
 168
 169         if(self->detector)
 170                 hkl_detector_free(self->detector);
 171         self->detector = hkl_detector_new_copy(self->engines->detector);
 172
 173         if(self->sample)
 174                 hkl_sample_free(self->sample);
 175         self->sample = hkl_sample_new_copy(self->engines->sample);
 176
 177         /* fill the axes member from the function */
 178         if(self->mode){
 179                 darray_free(self->axes);
 180                 darray_init(self->axes);
 181                 for(i=0; i<self->mode->info->n_axes; ++i){
 182                         HklParameter *axis;
 183
 184                         axis = hkl_geometry_get_axis_by_name(self->geometry,
 185                                                              self->mode->info->axes[i]);
 186
 187                         darray_append(self->axes, axis);
 188                 }
 189         }
 190
 191         /* reset the geometries len */
 192         hkl_geometry_list_reset(self->engines->geometries);
 193 }
 194
 195 /**
 196  * hkl_engine_name_get:
 197  * @self: the this ptr
 198  *
 199  * Return value: the name of the HklEngine
 200  **/
 201 const char *hkl_engine_name_get(const HklEngine *self)
 202 {
 203         return self->info->name;
 204 }
 205
 206 /**
 207  * hkl_engine_len: (skip)
 208  * @self: the this ptr
 209  *
 210  * Return value: the len of the pseudo axes of the HklEngine
 211  **/
 212 unsigned int hkl_engine_len(const HklEngine *self)
 213 {
 214         return self->info->n_pseudo_axes;
 215 }
 216
 217 /**
 218  * hkl_engine_pseudo_axes_names_get:
 219  * @self: the this ptr
 220  *
 221  * Return value: (transfer none): the pseudo_axes managed by this HklEngine
 222  **/
 223 const darray_string *hkl_engine_pseudo_axes_names_get(HklEngine *self)
 224 {
 225         return &self->pseudo_axes_names;
 226 }
 227
 228 /**
 229  * hkl_engine_pseudo_axes_values_get:
 230  * @self: the this ptr
 231  * @values: (array length=n_values): the values to get
 232  * @n_values: the size of the values array.
 233  * @unit_type: the unit type (default or user) of the returned value
 234  *
 235  * Get the engine pseudo axes values
 236  **/
 237 void hkl_engine_pseudo_axes_values_get(HklEngine *self,
 238                                        double values[], size_t n_values,
 239                                        HklUnitEnum unit_type)
 240 {
 241         hkl_assert(n_values == self->info->n_pseudo_axes);
 242
 243         for(size_t i=0; i<n_values; ++i)
 244                 values[i] = hkl_parameter_value_get(darray_item(self->pseudo_axes, i),
 245                                                     unit_type);
 246 }
 247
 248 /**
 249  * hkl_engine_pseudo_axes_values_set: (skip)
 250  * @self: the this ptr
 251  * @values: (array length=n_values): the values to set
 252  * @n_values: the size of the values array.
 253  * @unit_type: the unit type (default or user) of the returned value
 254  * @error: return location for a GError, or NULL
 255  *
 256  * Set the engine pseudo axes values
 257  * @todo tests
 258  *
 259  * Returns: TRUE on success, FALSE if an error occurred
 260  **/
 261 int hkl_engine_pseudo_axes_values_set(HklEngine *self,
 262                                       double values[], size_t n_values,
 263                                       HklUnitEnum unit_type, GError **error)
 264 {
 265         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 266
 267         if(n_values != self->info->n_pseudo_axes){
 268                 g_set_error(error,
 269                             HKL_ENGINE_ERROR,
 270                             HKL_ENGINE_ERROR_PSEUDO_AXES_VALUES_SET,
 271                             "cannot set engine pseudo axes, wrong number of parameter (%d) given, (%d) expected\n",
 272                             n_values, self->info->n_pseudo_axes);
 273                 return FALSE;
 274         } else {
 275                 for(size_t i=0; i<n_values; ++i){
 276                         if(!hkl_parameter_value_set(darray_item(self->pseudo_axes, i),
 277                                                     values[i], unit_type, error)){
 278                                 g_assert (error == NULL || *error != NULL);
 279                                 return FALSE;
 280                         }
 281                 }
 282                 g_assert (error == NULL || *error == NULL);
 283         }
 284
 285         return TRUE;
 286 }
 287
 288 /**
 289  * hkl_engine_pseudo_axes_randomize: (skip)
 290  * @self: the this ptr
 291  *
 292  * randomize all the parameters of the #HklEngine
 293  **/
 294 void hkl_engine_pseudo_axes_randomize(HklEngine *self)
 295 {
 296         HklParameter **parameter;
 297
 298         darray_foreach(parameter, self->pseudo_axes){
 299                 hkl_parameter_randomize(*parameter);
 300         }
 301 }
 302
 303 /**
 304  * hkl_engine_pseudo_axis_get: (skip)
 305  * @self: the this ptr
 306  * @name: the name of the expected psudo_axis
 307  * @error: return location for a GError, or NULL
 308  *
 309  * get the #HklParameter with the given @name.
 310  *
 311  * Returns: (allow-none): retun the parameter or NULL if the engine
 312  *                        does not contain this pseudo_axis.
 313  * TODO: unit test
 314  **/
 315 const HklParameter *hkl_engine_pseudo_axis_get(const HklEngine *self,
 316                                                const char *name,
 317                                                GError **error)
 318 {
 319         HklParameter **parameter;
 320
 321         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 322
 323         darray_foreach(parameter, self->pseudo_axes)
 324                 if(!strcmp((*parameter)->name, name))
 325                         return *parameter;
 326
 327         g_set_error(error,
 328                     HKL_ENGINE_ERROR,
 329                     HKL_ENGINE_ERROR_PSEUDO_AXIS_SET,
 330                     "This pseudo axis doesn not contain this pseudo axis \"%s\"\n",
 331                     name);
 332
 333         return NULL;
 334 }
 335
 336 /**
 337  * hkl_engine_pseudo_axis_set: (skip)
 338  * @self: the this ptr
 339  * @name: the name of the pseudo_axis to set
 340  * @parameter: the parameter to set.
 341  * @error: return location for a GError, or NULL
 342  *
 343  * set a parameter of the #HklEngine
 344  * @todo: tests
 345  *
 346  * return value: TRUE if succeded or FALSE otherwise.
 347  **/
 348 int hkl_engine_pseudo_axis_set(HklEngine *self,
 349                                const char *name,
 350                                const HklParameter *parameter,
 351                                GError **error)
 352 {
 353         HklParameter **p;
 354
 355         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 356         g_return_val_if_fail (strcmp(name, parameter->name) == 0, FALSE);
 357
 358
 359         darray_foreach(p, self->pseudo_axes)
 360                 if(!strcmp((*p)->name, parameter->name)){
 361                         hkl_parameter_init_copy(*p, parameter, NULL);
 362                         return TRUE;
 363                 }
 364
 365         g_set_error(error,
 366                     HKL_ENGINE_ERROR,
 367                     HKL_ENGINE_ERROR_PSEUDO_AXIS_SET,
 368                     "Can not find the pseudo axis \"%s\" in the \"%s\" engine\n",
 369                     parameter->name, self->info->name);
 370
 371         return FALSE;
 372 }
 373
 374 /**
 375  * hkl_engine_mode_set: (skip)
 376  * @self: the HklEngine
 377  * @name: the mode to select
 378  *
 379  * This method also populate the self->axes from the mode->axes_names.
 380  * this is to speed the computation of the numerical axes.
 381  **/
 382 void hkl_engine_mode_set(HklEngine *self, HklMode *mode)
 383 {
 384         self->mode = mode;
 385         hkl_engine_prepare_internal(self);
 386 }
 387
 388 /**
 389  * hkl_engine_modes_names_get:
 390  * @self: the this ptr
 391  *
 392  * Return value: (type gpointer): All the modes supported by the #HklEngine
 393  **/
 394 const darray_string *hkl_engine_modes_names_get(const HklEngine *self)
 395 {
 396         return &self->mode_names;
 397 }
 398
 399 /**
 400  * hkl_engine_parameters_names_get:
 401  * @self: the this ptr
 402  *
 403  * Return value: (type gpointer): All the parameters of #HklEngine.
 404  **/
 405 const darray_string *hkl_engine_parameters_names_get(const HklEngine *self)
 406 {
 407         return &self->mode->parameters_names;
 408 }
 409
 410 /**
 411  * hkl_engine_parameters_values_set: (skip)
 412  * @self: the this ptr
 413  * @values: (array length=n_values): the values to set
 414  * @n_values: the size of the values array.
 415  * @unit_type: the unit type (default or user) of the returned value
 416  * @error: return location for a GError, or NULL
 417  *
 418  * Set the engine parameters values
 419  *
 420  * return value: TRUE if succeded or FALSE otherwise.
 421  **/
 422 int hkl_engine_parameters_values_set(HklEngine *self,
 423                                      double values[], size_t n_values,
 424                                      HklUnitEnum unit_type, GError **error)
 425 {
 426         g_return_val_if_fail (error == NULL || *error == NULL && n_values == darray_size(self->mode->parameters), FALSE);
 427
 428         for(size_t i=0; i<n_values; ++i){
 429                 if(!hkl_parameter_value_set(darray_item(self->mode->parameters, i),
 430                                             values[i], unit_type, error)){
 431                         g_assert (error == NULL || *error != NULL);
 432                         return FALSE;
 433                 }
 434         }
 435         g_assert (error == NULL || *error == NULL);
 436
 437         return TRUE;
 438 }
 439
 440 /**
 441  * hkl_engine_parameters_randomize: (skip)
 442  * @self: the this ptr
 443  *
 444  * randomize all the parameters of the #HklEngine
 445  **/
 446 void hkl_engine_parameters_randomize(HklEngine *self)
 447 {
 448         HklParameter **parameter;
 449
 450         darray_foreach(parameter, self->mode->parameters){
 451                 hkl_parameter_randomize(*parameter);
 452         }
 453 }
 454
 455 /**
 456  * hkl_engine_parameter_get: (skip)
 457  * @self: the this ptr
 458  * @name: the name of the expected parameter
 459  * @error: return location for a GError, or NULL
 460  *
 461  * get the #HklParameter with the given @name.
 462  *
 463  * Returns: (allow-none): return the parameter or NULL if the engine
 464  *                        does not contain this parameter.
 465  **/
 466 const HklParameter *hkl_engine_parameter_get(const HklEngine *self,
 467                                              const char *name,
 468                                              GError **error)
 469 {
 470         HklParameter **parameter;
 471
 472         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 473
 474         darray_foreach(parameter, self->mode->parameters)
 475                 if(!strcmp((*parameter)->name, name))
 476                         return *parameter;
 477
 478         g_set_error(error,
 479                     HKL_ENGINE_ERROR,
 480                     HKL_ENGINE_ERROR_PARAMETER_GET,
 481                     "this engine does not contain this parameter \"%s\"\n",
 482                     name);
 483
 484         return NULL;
 485 }
 486
 487 /**
 488  * hkl_engine_parameter_set: (skip)
 489  * @self: the this ptr
 490  * @name: the name of the parameter to set.
 491  * @parameter: the parameter to set.
 492  * @error: return location for a GError, or NULL
 493  *
 494  * set a parameter of the #HklEngine
 495  * TODO add an error
 496  *
 497  * return value: TRUE if succeded or FALSE otherwise.
 498  **/
 499 int hkl_engine_parameter_set(HklEngine *self,
 500                              const char *name,
 501                              const HklParameter *parameter,
 502                              GError **error)
 503 {
 504         HklParameter **p;
 505
 506         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 507         g_return_val_if_fail (strcmp(name, parameter->name) == 0, FALSE);
 508
 509         darray_foreach(p, self->mode->parameters)
 510                 if(!strcmp((*p)->name, parameter->name)){
 511                         hkl_parameter_init_copy(*p, parameter, NULL);
 512                         return TRUE;
 513                 }
 514
 515         g_set_error(error,
 516                     HKL_ENGINE_ERROR,
 517                     HKL_ENGINE_ERROR_PARAMETER_SET,
 518                     "this engine does not contain this parameter \"%s\"\n",
 519                     parameter->name);
 520
 521         return FALSE;
 522 }
 523
 524 /**
 525  * hkl_engine_engines_get:
 526  * @self: the this ptr
 527  *
 528  * Return value: (transfer none): the HklEngineList which contain this HklEngine
 529  **/
 530 HklEngineList *hkl_engine_engines_get(HklEngine *self)
 531 {
 532         return self->engines;
 533 }
 534
 535 /**
 536  * hkl_engine_select_mode:
 537  * @self: the HklEngine
 538  * @name: the mode to select
 539  * @error: return location for a GError, or NULL
 540  *
 541  * This method also populate the self->axes from the mode->axes_names.
 542  * this is to speed the computation of the numerical axes.
 543  *
 544  * return value: TRUE if succeded or FALSE otherwise.
 545  **/
 546 int hkl_engine_select_mode(HklEngine *self, const char *name,
 547                            GError **error)
 548 {
 549         HklMode **mode;
 550
 551         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 552
 553         darray_foreach(mode, self->modes)
 554                 if(!strcmp((*mode)->info->name, name)){
 555                         hkl_engine_mode_set(self, *mode);
 556                         return TRUE;
 557                 }
 558
 559         g_set_error(error,
 560                     HKL_ENGINE_ERROR,
 561                     HKL_ENGINE_ERROR_SELECT_MODE,
 562                     "this engine does not contain this mode \"%s\"\n",
 563                     name);
 564
 565         return FALSE;
 566 }
 567
 568 /**
 569  * hkl_engine_initialize: (skip)
 570  * @self: the HklEngine
 571  * @error: return location for a GError, or NULL
 572  *
 573  * initialize the HklEngine
 574  *
 575  * return value: TRUE if succeded or FALSE otherwise.
 576  **/
 577 int hkl_engine_initialize(HklEngine *self, GError **error)
 578 {
 579         hkl_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 580
 581         if(!self->geometry || !self->detector || !self->sample
 582            || !self->mode) {
 583                 g_set_error(error,
 584                             HKL_ENGINE_ERROR,
 585                             HKL_ENGINE_ERROR_INITIALIZE,
 586                             "Internal error");
 587                 return FALSE;
 588         }
 589
 590         /* a NULL initialize method is valid */
 591         if(self->mode->ops->init
 592            && !self->mode->ops->init(self->mode,
 593                                      self,
 594                                      self->engines->geometry,
 595                                      self->engines->detector,
 596                                      self->engines->sample,
 597                                      error)){
 598                 hkl_assert(error == NULL || *error != NULL);
 599                 return FALSE;
 600         }
 601
 602         hkl_assert(error == NULL || *error == NULL);
 603
 604         return TRUE;
 605 }
 606
 607 /**
 608  * hkl_engine_set: (skip)
 609  * @self: the HklEngine
 610  * @error: return location for a GError, or NULL
 611  *
 612  * use the HklPseudoaxisEngine values to compute the real axes values.
 613  *
 614  * return value: TRUE if succeded or FALSE otherwise.
 615  **/
 616 int hkl_engine_set(HklEngine *self, GError **error)
 617 {
 618         hkl_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 619
 620         if(!self->geometry || !self->detector || !self->sample
 621            || !self->mode || !self->mode->ops->set){
 622                 g_set_error(error,
 623                             HKL_ENGINE_ERROR,
 624                             HKL_ENGINE_ERROR_SET,
 625                             "Internal error");
 626                 return FALSE;
 627         }
 628
 629         hkl_engine_prepare_internal(self);
 630
 631         if (!self->mode->ops->set(self->mode, self,
 632                                   self->geometry,
 633                                   self->detector,
 634                                   self->sample,
 635                                   error)){
 636                 hkl_assert(error == NULL || *error != NULL);
 637                 return FALSE;
 638         }
 639         hkl_assert(error == NULL || *error == NULL);
 640
 641         hkl_geometry_list_multiply(self->engines->geometries);
 642         hkl_geometry_list_multiply_from_range(self->engines->geometries);
 643         hkl_geometry_list_remove_invalid(self->engines->geometries);
 644         hkl_geometry_list_sort(self->engines->geometries, self->engines->geometry);
 645
 646         if(self->engines->geometries->n_items == 0){
 647                 g_set_error(error,
 648                             HKL_ENGINE_ERROR,
 649                             HKL_ENGINE_ERROR_SET,
 650                             "no remaining solutions");
 651                 return FALSE;
 652         }
 653
 654         return TRUE;
 655 }
 656
 657 /**
 658  * hkl_engine_get: (skip)
 659  * @self: The HklEngine
 660  * @error: return location for a GError, or NULL
 661  *
 662  * get the values of the pseudo-axes from the real-axes values
 663  *
 664  * return value: TRUE if succeded or FALSE otherwise.
 665  **/
 666 int hkl_engine_get(HklEngine *self, GError **error)
 667 {
 668         hkl_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 669
 670         if(!self->engines || !self->engines->geometry || !self->engines->detector
 671            || !self->engines->sample || !self->mode || !self->mode->ops->get){
 672                 g_set_error(error,
 673                             HKL_ENGINE_ERROR,
 674                             HKL_ENGINE_ERROR_GET,
 675                             "Internal error");
 676                 return FALSE;
 677         }
 678
 679         if (!self->mode->ops->get(self->mode,
 680                                   self,
 681                                   self->engines->geometry,
 682                                   self->engines->detector,
 683                                   self->engines->sample,
 684                                   error)){
 685                 hkl_assert(error == NULL || *error != NULL);
 686                 return FALSE;
 687         }
 688         hkl_assert(error == NULL || *error == NULL);
 689
 690         return TRUE;
 691 }
 692
 693 /**
 694  * hkl_engine_fprintf: (skip)
 695  * @f: the FILE
 696  * @self: the HklEngine
 697  *
 698  * print to a FILE the HklEngine
 699  **/
 700 void hkl_engine_fprintf(FILE *f, const HklEngine *self)
 701 {
 702         HklParameter **pseudo_axis;
 703
 704         fprintf(f, "\nPseudoAxesEngine : \"%s\"", self->info->name);
 705
 706         /* mode */
 707         if (self->mode) {
 708                 fprintf(f, " %s", self->mode->info->name);
 709                 for(uint i=0; i<darray_size(self->mode->parameters); ++i){
 710                         fprintf(f, "\n     ");
 711                         hkl_parameter_fprintf(
 712                                 f,
 713                                 darray_item(self->mode->parameters, i));
 714                 }
 715                 fprintf(f, "\n");
 716         }
 717
 718         /* the pseudoAxes part */
 719         darray_foreach(pseudo_axis, self->pseudo_axes){
 720                 fprintf(f, "\n     ");
 721                 hkl_parameter_fprintf(f, *pseudo_axis);
 722         }
 723
 724         if(self->engines->geometries->n_items != 0){
 725                 fprintf(f, "\n   ");
 726                 hkl_geometry_list_fprintf(f, self->engines->geometries);
 727         }
 728         fprintf(f, "\n");
 729 }
 730
 731 /*****************/
 732 /* HklEngineList */
 733 /*****************/
 734
 735 /**
 736  * hkl_engine_list_new: (skip)
 737  *
 738  * default constructor
 739  *
 740  * Returns:
 741  **/
 742 HklEngineList *hkl_engine_list_new(void)
 743 {
 744         HklEngineList *self = NULL;
 745
 746         self = HKL_MALLOC(HklEngineList);
 747
 748         darray_init(*self);
 749
 750         self->geometries = hkl_geometry_list_new();
 751
 752         self->geometry = NULL;
 753         self->detector = NULL;
 754         self->sample = NULL;
 755
 756         return self;
 757 }
 758
 759 /**
 760  * hkl_engine_list_new_copy: (skip)
 761  * @self:
 762  *
 763  * dummy copy constructor for the binding
 764  *
 765  * Returns: (transfer none): NULL all the time the structure is non-copyable
 766  **/
 767 const HklEngineList *hkl_engine_list_new_copy(const HklEngineList *self)
 768 {
 769         return NULL;
 770 }
 771
 772 /**
 773  * hkl_engine_list_free: (skip)
 774  * @self: the #HklEngineList to destroy
 775  *
 776  * destructor
 777  **/
 778 void hkl_engine_list_free(HklEngineList *self)
 779 {
 780         hkl_engine_list_clear(self);
 781         hkl_geometry_list_free(self->geometries);
 782         free(self);
 783 }
 784
 785 /**
 786  * hkl_engine_list_add: (skip)
 787  * @self: the engine list
 788  * @engine: the engine to add
 789  *
 790  * add an #HklEngine to the #HklEngineList
 791  *
 792  * Returns: HKL_SUCCESS or HKL_FAIL
 793  **/
 794 int hkl_engine_list_add(HklEngineList *self,
 795                         HklEngine *engine)
 796 {
 797         if (!engine)
 798                 return FALSE;
 799
 800         /* set the engines to access the Geometries list. */
 801         engine->engines = self;
 802
 803         darray_append(*self, engine);
 804
 805         return TRUE;
 806 }
 807
 808 /**
 809  * hkl_engine_list_engines_get: (skip)
 810  * @self: the this ptr
 811  *
 812  * Return: a pointer on the engine array
 813  **/
 814 darray_engine *hkl_engine_list_engines_get(HklEngineList *self)
 815 {
 816         return (darray_engine *)self;
 817 }
 818
 819 /**
 820  * hkl_engine_list_geometries_get:
 821  * @self: the this ptr
 822  *
 823  * Return: a pointer on the engine array
 824  **/
 825 const HklGeometryList *hkl_engine_list_geometries_get(const HklEngineList *self)
 826 {
 827         return self->geometries;
 828 }
 829
 830 /**
 831  * hkl_engine_list_geometry_get: (skip)
 832  * @self: the this ptr
 833  *
 834  * Return: a pointer on the geometry member
 835  **/
 836 HklGeometry *hkl_engine_list_geometry_get(HklEngineList *self)
 837 {
 838         return self->geometry;
 839 }
 840
 841 int hkl_engine_list_geometry_set(HklEngineList *self, const HklGeometry *geometry)
 842 {
 843         if(!hkl_geometry_set(self->geometry, geometry))
 844                 return FALSE;
 845
 846         hkl_engine_list_get(self);
 847
 848         return TRUE;
 849 }
 850
 851 /**
 852  * hkl_engine_list_select_solution:
 853  * @self: the this ptr
 854  * @item: the #HklGeoemtryListItem selected.
 855  *
 856  * this method set the geometry member with the selected solution.
 857  *
 858  * return value: TRUE if succeded or FALSE otherwise.
 859  **/
 860 int hkl_engine_list_select_solution(HklEngineList *self,
 861                                     const HklGeometryListItem *item)
 862 {
 863         return hkl_geometry_init_geometry(self->geometry, item->geometry);
 864 }
 865
 866 /**
 867  * hkl_engine_list_engine_get_by_name:
 868  * @self: the this ptr
 869  * @name: the name of the requested #HklPseudoAxisEngin
 870  * @error: return location for a GError, or NULL
 871  *
 872  * get the #HklEngine by its name from the list.
 873  *
 874  * Returns: (transfer none) (allow-none): the requested engine
 875  **/
 876 HklEngine *hkl_engine_list_engine_get_by_name(HklEngineList *self,
 877                                               const char *name,
 878                                               GError **error)
 879 {
 880         HklEngine **engine;
 881
 882         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 883
 884         darray_foreach(engine, *self){
 885                 if (!strcmp((*engine)->info->name, name))
 886                         return *engine;
 887         }
 888
 889         g_set_error(error,
 890                     HKL_ENGINE_LIST_ERROR,
 891                     HKL_ENGINE_LIST_ERROR_ENGINE_GET_BY_NAME,
 892                     "this engine list does not contain this engine \"%s\"",
 893                     name);
 894
 895         return NULL;
 896 }
 897
 898 /**
 899  * hkl_engine_list_pseudo_axis_get_by_name:
 900  * @self: the engine list
 901  * @name: the name of the requested #HklPseudoAxis
 902  * @error: return location for a GError, or NULL
 903  *
 904  * Todo: test
 905  *
 906  * Returns: (transfer none) (allow-none): the requested #HklPseudoAxis
 907  **/
 908 HklParameter *hkl_engine_list_pseudo_axis_get_by_name(
 909         const HklEngineList *self, const char *name,
 910         GError **error)
 911 {
 912         HklEngine **engine;
 913         HklParameter **parameter;
 914
 915         g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 916
 917         darray_foreach(engine, *self){
 918                 darray_foreach(parameter, (*engine)->pseudo_axes){
 919                         if (!strcmp((*parameter)->name, name))
 920                                 return *parameter;
 921                 }
 922         }
 923
 924         g_set_error(error,
 925                     HKL_ENGINE_LIST_ERROR,
 926                     HKL_ENGINE_LIST_ERROR_ENGINE_GET_BY_NAME,
 927                     "this engine list does not contain this pseudo axis \"%s\"",
 928                     name);
 929
 930         return NULL;
 931 }
 932
 933 /**
 934  * hkl_engine_list_clear: (skip)
 935  * @self: the engine list to clear
 936  *
 937  * remove all engine from the engine list
 938  **/
 939 void hkl_engine_list_clear(HklEngineList *self)
 940 {
 941         HklEngine **engine;
 942
 943         darray_foreach(engine, *self){
 944                 hkl_engine_free(*engine);
 945         }
 946         darray_free(*self);
 947 }
 948
 949 /**
 950  * hkl_engine_list_init:
 951  * @self: the engine list
 952  * @geometry: the associated #HklGeometry
 953  * @detector: the associated #HklDetector
 954  * @sample: the associated #HklSample
 955  *
 956  * before using an engine list you must associate all engines to a
 957  * Geometry, a detector and a sample.
 958  **/
 959 void hkl_engine_list_init(HklEngineList *self,
 960                           HklGeometry *geometry,
 961                           HklDetector *detector,
 962                           HklSample *sample)
 963 {
 964         HklEngine **engine;
 965
 966         self->geometry = geometry;
 967         self->detector = detector;
 968         self->sample = sample;
 969
 970         darray_foreach(engine, *self){
 971                 hkl_engine_prepare_internal(*engine);
 972         }
 973 }
 974
 975 /**
 976  * hkl_engine_list_get:
 977  * @self: the list of #HklEngine
 978  *
 979  * apply the get method to all the #HklEngine of the list
 980  * after this it is possible to retrive all the #HklPseudoAxis values.
 981  *
 982  * Returns: HKL_SUCCESS or HKL_FAIL if one of the #HklEngine
 983  * get method failed.
 984  **/
 985 int hkl_engine_list_get(HklEngineList *self)
 986 {
 987         HklEngine **engine;
 988         int res = TRUE;
 989
 990         darray_foreach(engine, *self){
 991                 res &= hkl_engine_get(*engine, NULL);
 992         }
 993
 994         return res;
 995 }
 996
 997 /**
 998  * hkl_engine_list_fprintf: (skip)
 999  * @f: the File
1000  * @self: the list
1001  *
1002  * print to a FILE the #HklEngineList
1003  **/
1004 void hkl_engine_list_fprintf(FILE *f,
1005                              const HklEngineList *self)
1006 {
1007         HklEngine **engine;
1008
1009         darray_foreach(engine, *self){
1010                 hkl_engine_fprintf(f, *engine);
1011         }
1012 }