hkl/hkl-pseudoaxis-common-tth.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  *          Jens Krüger <Jens.Krueger@frm2.tum.de>
  22  */
  23 #include <gsl/gsl_errno.h>              // for ::GSL_SUCCESS
  24 #include <gsl/gsl_sf_trig.h>            // for gsl_sf_angle_restrict_symm
  25 #include <gsl/gsl_sys.h>                // for gsl_isnan
  26 #include <gsl/gsl_vector_double.h>      // for gsl_vector
  27 #include <math.h>                       // for sin, atan2, signbit
  28 #include <stdlib.h>                     // for free
  29 #include "hkl-detector-private.h"       // for hkl_detector_compute_kf
  30 #include "hkl-geometry-private.h"       // for _HklGeometry, HklHolder
  31 #include "hkl-macros-private.h"         // for HKL_MALLOC
  32 #include "hkl-parameter-private.h"      // for _HklParameter, etc
  33 #include "hkl-pseudoaxis-auto-private.h"  // for HklFunction, etc
  34 #include "hkl-pseudoaxis-common-tth-private.h"  // for HklEngineQ2, etc
  35 #include "hkl-pseudoaxis-private.h"     // for _HklEngine, etc
  36 #include "hkl-source-private.h"         // for hkl_source_compute_ki, etc
  37 #include "hkl-vector-private.h"         // for HklVector, hkl_vector_angle, etc
  38 #include "hkl.h"                        // for HklEngine, HklParameter, etc
  39 #include "hkl/ccan/array_size/array_size.h"  // for ARRAY_SIZE
  40 #include "hkl/ccan/container_of/container_of.h"  // for container_of
  41 #include "hkl/ccan/darray/darray.h"     // for darray_item
  42
  43
  44 /********/
  45 /* tth2 */
  46 /********/
  47
  48 struct _HklEngineTth2
  49 {
  50         HklEngine engine;
  51         HklParameter *tth;
  52         HklParameter *alpha;
  53 };
  54
  55 static void _tth2(HklGeometry *geometry, HklDetector *detector,
  56                   double *tth, double *alpha)
  57 {
  58         HklVector kf, ki;
  59         static HklVector x = {
  60                 .data = {1, 0, 0},
  61         };
  62
  63         hkl_source_compute_ki(&geometry->source, &ki);
  64         hkl_detector_compute_kf(detector, geometry, &kf);
  65         *tth = hkl_vector_angle(&ki, &kf);
  66
  67         /* project kf on the x plan to compute alpha */
  68         hkl_vector_project_on_plan(&kf, &x);
  69
  70         *alpha = atan2(kf.data[2], kf.data[1]);
  71
  72 }
  73
  74 static int _tth2_func(const gsl_vector *x, void *params, gsl_vector *f)
  75 {
  76         HklEngine *engine = params;
  77         const HklEngineTth2 *engine_tth2 = container_of(engine, HklEngineTth2, engine);
  78         double tth;
  79         double alpha;
  80
  81         CHECK_NAN(x->data, x->size);
  82
  83         /* update the workspace from x */
  84         set_geometry_axes(engine, x->data);
  85
  86         _tth2(engine->geometry, engine->detector, &tth, &alpha);
  87
  88         f->data[0] = engine_tth2->tth->_value - tth;
  89         f->data[1] = engine_tth2->alpha->_value - alpha;
  90
  91         return  GSL_SUCCESS;
  92 }
  93
  94 static const HklFunction tth2_func = {
  95         .function = _tth2_func,
  96         .size = 2,
  97 };
  98
  99 static int get_tth2_real(HklMode *self,
 100                          HklEngine *engine,
 101                          HklGeometry *geometry,
 102                          HklDetector *detector,
 103                          HklSample *sample,
 104                          GError **error)
 105 {
 106         HklEngineTth2 *engine_tth2 = container_of(engine, HklEngineTth2, engine);
 107
 108         _tth2(geometry, detector,
 109               &engine_tth2->tth->_value,
 110               &engine_tth2->alpha->_value);
 111
 112         return TRUE;
 113 }
 114
 115 static HklMode *mode_tth2(void)
 116 {
 117         static const char* axes[] = {"gamma", "delta"};
 118         static const HklFunction *functions[] = {&tth2_func};
 119         static const HklModeAutoInfo info = {
 120                 HKL_MODE_AUTO_INFO("tth2", axes, axes, functions),
 121         };
 122         static const HklModeOperations operations = {
 123                 HKL_MODE_OPERATIONS_AUTO_DEFAULTS,
 124                 .get = get_tth2_real,
 125         };
 126
 127         return hkl_mode_auto_new(&info, &operations, TRUE);
 128 }
 129
 130 static void hkl_engine_tth2_free_real(HklEngine *base)
 131 {
 132         HklEngineTth2 *self = container_of(base, HklEngineTth2, engine);
 133         hkl_engine_release(&self->engine);
 134         free(self);
 135 }
 136
 137 HklEngine *hkl_engine_tth2_new(HklEngineList *engines)
 138 {
 139         HklEngineTth2 *self;
 140         HklMode *mode;
 141
 142         static const HklParameter tth = {
 143                 HKL_PARAMETER_DEFAULTS_ANGLE, .name="tth",
 144                 .description = "the $2 \\theta$ angle",
 145         };
 146         static const HklParameter alpha = {
 147                 HKL_PARAMETER_DEFAULTS_ANGLE, .name = "alpha",
 148                 .description = "angle of the projection of $\\vec{q}$ on the $yOz$ plan and $\\vec{y}$",
 149         };
 150         static const HklParameter *pseudo_axes[] = {&tth, &alpha};
 151         static const HklEngineInfo info = {
 152                 HKL_ENGINE_INFO("tth2",
 153                                 pseudo_axes,
 154                                 HKL_ENGINE_DEPENDENCIES_AXES),
 155         };
 156         static const HklEngineOperations operations = {
 157                 HKL_ENGINE_OPERATIONS_DEFAULTS,
 158                 .free=hkl_engine_tth2_free_real,
 159         };
 160
 161         self = HKL_MALLOC(HklEngineTth2);
 162
 163         hkl_engine_init(&self->engine, &info, &operations, engines);
 164         self->tth = register_pseudo_axis(&self->engine, engines, &tth);
 165         self->alpha = register_pseudo_axis(&self->engine, engines, &alpha);
 166
 167         /* tth2 [default] */
 168         mode = mode_tth2();
 169         hkl_engine_add_mode(&self->engine, mode);
 170         hkl_engine_mode_set(&self->engine, mode);
 171
 172         return &self->engine;
 173 }