hkl/hkl-trajectory.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-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
  23 #include "hkl-macros-private.h"
  24 #include "hkl-trajectory-private.h"
  25
  26 HklTrajectoryResult * hkl_trajectory_result_new(void)
  27 {
  28         HklTrajectoryResult *self = HKL_MALLOC(HklTrajectoryResult);
  29
  30         darray_init(self->geometries);
  31
  32         return self;
  33 }
  34
  35 void hkl_trajectory_result_free(HklTrajectoryResult *self)
  36 {
  37         HklGeometry **geometry;
  38
  39         darray_foreach(geometry, self->geometries){
  40                 hkl_geometry_free(*geometry);
  41         }
  42         darray_free(self->geometries);
  43 }
  44
  45 void hkl_trajectory_add_geometry(HklTrajectoryResult *self, const HklGeometry *geometry)
  46 {
  47         darray_append(self->geometries, hkl_geometry_new_copy(geometry));
  48 }
  49
  50 /* HklTrajectoryStats */
  51
  52 HklTrajectoryStats *hkl_trajectory_stats_new(int n)
  53 {
  54         HklTrajectoryStats *self = HKL_MALLOC(HklTrajectoryStats);
  55
  56         self->n = 0;
  57         darray_init(self->nb_solutions);
  58         darray_init(self->axes_min);
  59         darray_init(self->axes_max);
  60         darray_init(self->axes_range);
  61         darray_resize0(self->axes_range, n);
  62
  63         return self;
  64 }
  65
  66 void hkl_trajectory_stats_free(HklTrajectoryStats *self)
  67 {
  68         darray_free(self->axes_range);
  69         darray_free(self->axes_max);
  70         darray_free(self->axes_min);
  71         darray_free(self->nb_solutions);
  72         free(self);
  73 }
  74
  75 void hkl_trajectory_stats_add(HklTrajectoryStats *self, const HklGeometryList *geometries)
  76 {
  77         size_t i;
  78
  79         const HklGeometryListItem *item = hkl_geometry_list_items_first_get(geometries);
  80         const HklGeometry *geometry = hkl_geometry_list_item_geometry_get(item);
  81         size_t n = darray_size(*hkl_geometry_axis_names_get(geometry));
  82
  83         darray_append(self->nb_solutions, hkl_geometry_list_n_items_get(geometries));
  84
  85         if(self->n == 0){
  86                 darray_resize(self->axes_min, n);
  87                 darray_resize(self->axes_max, n);
  88                 darray_resize(self->axes_range, n);
  89
  90                 hkl_geometry_axis_values_get(geometry,
  91                                              &darray_item(self->axes_min, 0), n,
  92                                              HKL_UNIT_USER);
  93                 hkl_geometry_axis_values_get(geometry,
  94                                              &darray_item(self->axes_max, 0), n,
  95                                              HKL_UNIT_USER);
  96         }else{
  97                 double values[n];
  98
  99                 hkl_geometry_axis_values_get(geometry, values, n, HKL_UNIT_USER);
 100                 for(i=0; i<n; ++i){
 101                         if (values[i] < darray_item(self->axes_min, i))
 102                                 darray_item(self->axes_min, i) = values[i];
 103                         else if (values[i] > darray_item(self->axes_max, i))
 104                                 darray_item(self->axes_max, i) = values[i];
 105                 }
 106         }
 107         for(i=0;i<n;++i)
 108                 darray_item(self->axes_range, i) = darray_item(self->axes_max, i) - darray_item(self->axes_min, i);
 109
 110         self->n += 1;
 111 }
 112
 113 void hkl_trajectory_stats_fprintf(FILE *f, const HklTrajectoryStats *self)
 114 {
 115         size_t *p;
 116         double *v;
 117
 118         fprintf(f, "Number of points of the trajectory: %d\n", self->n);
 119         fprintf(f, "Solutions per points:");
 120         darray_foreach(p, self->nb_solutions){
 121                 fprintf(f, " %d", *p);
 122         }
 123         fprintf(f, "\n");
 124         fprintf(f, "Axes minium:");
 125         darray_foreach(v, self->axes_min){
 126                 fprintf(f, " %f", *v);
 127         }
 128         fprintf(f, "\n");
 129         fprintf(f, "Axes max:");
 130         darray_foreach(v, self->axes_max){
 131                 fprintf(f, " %f", *v);
 132         }
 133         fprintf(f, "\n");
 134         fprintf(f, "Axes range:");
 135         darray_foreach(v, self->axes_range){
 136                 fprintf(f, " %f", *v);
 137         }
 138         fprintf(f, "\n");
 139 }