hkl/hkl-pseudoaxis-k4cv-hkl.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-2012 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  *          Maria-Teresa Nunez-Pardo-de-Verra <tnunez@mail.desy.de>
  22  *          Jens Krüger <Jens.Krueger@frm2.tum.de>
  23  */
  24 #include <gsl/gsl_math.h>
  25 #include <gsl/gsl_vector.h>
  26
  27 #include <ccan/array_size/array_size.h>
  28
  29 #include "hkl-pseudoaxis-auto-private.h"
  30 #include "hkl-pseudoaxis-common-hkl-private.h"
  31
  32 /***********************/
  33 /* numerical functions */
  34 /***********************/
  35
  36 static int _bissector_f1(const gsl_vector *x, void *params, gsl_vector *f)
  37 {
  38         const double komega = x->data[0];
  39         const double kappa = x->data[1];
  40         const double tth = x->data[3];
  41         double omega;
  42
  43         CHECK_NAN(x->data, x->size);
  44
  45         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
  46
  47         RUBh_minus_Q(x->data, params, f->data);
  48         f->data[3] = fmod(tth - 2 * fmod(omega, M_PI), 2*M_PI);
  49
  50         return  GSL_SUCCESS;
  51 }
  52
  53 static const HklFunction bissector_f1 = {
  54         .function = _bissector_f1,
  55         .size = 4,
  56 };
  57
  58 static int _bissector_f2(const gsl_vector *x, void *params, gsl_vector *f)
  59 {
  60         const double komega = x->data[0];
  61         const double kappa = x->data[1];
  62         const double tth = x->data[3];
  63         double omega;
  64
  65         CHECK_NAN(x->data, x->size);
  66
  67         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
  68
  69         RUBh_minus_Q(x->data, params, f->data);
  70         f->data[3] = fmod(tth - 2 * fmod(omega, M_PI), 2*M_PI);
  71
  72         return  GSL_SUCCESS;
  73 }
  74
  75 static const HklFunction bissector_f2 = {
  76         .function = _bissector_f2,
  77         .size = 4,
  78 };
  79
  80 static int _constant_omega_f1(const gsl_vector *x, void *params, gsl_vector *f)
  81 {
  82         double const komega = x->data[0];
  83         double const kappa = x->data[1];
  84         double omega;
  85         HklPseudoAxisEngine *engine = params;
  86         double omega0 = engine->mode->parameters[0].value;
  87
  88         CHECK_NAN(x->data, x->size);
  89
  90         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
  91
  92         RUBh_minus_Q(x->data, params, f->data);
  93         f->data[3] = omega0 - omega;
  94
  95         return  GSL_SUCCESS;
  96 }
  97
  98 static const HklFunction constant_omega_f1 = {
  99         .function = _constant_omega_f1,
 100         .size = 4,
 101 };
 102
 103 static int _constant_omega_f2(const gsl_vector *x, void *params, gsl_vector *f)
 104 {
 105         const double komega = x->data[0];
 106         const double kappa = x->data[1];
 107         double omega;
 108         HklPseudoAxisEngine *engine = params;
 109         double omega0 = engine->mode->parameters[0].value;
 110
 111         CHECK_NAN(x->data, x->size);
 112
 113         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
 114
 115         RUBh_minus_Q(x->data, params, f->data);
 116         f->data[3] = omega0 - omega;
 117
 118         return  GSL_SUCCESS;
 119 }
 120
 121 static const HklFunction constant_omega_f2 = {
 122         .function = _constant_omega_f2,
 123         .size = 4,
 124 };
 125
 126 static int _constant_chi_f1(const gsl_vector *x, void *params, gsl_vector *f)
 127 {
 128         const double kappa = x->data[1];
 129         double chi;
 130         HklPseudoAxisEngine *engine = params;
 131         double chi0 = engine->mode->parameters[0].value;
 132
 133         CHECK_NAN(x->data, x->size);
 134
 135         chi = 2 * asin(sin(kappa/2.) * sin(50 * HKL_DEGTORAD));
 136
 137         RUBh_minus_Q(x->data, params, f->data);
 138         f->data[3] = chi0 - chi;
 139
 140         return  GSL_SUCCESS;
 141 }
 142
 143 static const HklFunction constant_chi_f1 = {
 144         .function = _constant_chi_f1,
 145         .size = 4,
 146 };
 147
 148 static int _constant_chi_f2(const gsl_vector *x, void *params, gsl_vector *f)
 149 {
 150         const double kappa = x->data[1];
 151         double chi;
 152         HklPseudoAxisEngine *engine = params;
 153         double chi0 = engine->mode->parameters[0].value;
 154
 155         CHECK_NAN(x->data, x->size);
 156
 157         chi = -2 * asin(sin(kappa/2.) * sin(50 * HKL_DEGTORAD));
 158
 159         RUBh_minus_Q(x->data, params, f->data);
 160         f->data[3] = chi0 - chi;
 161
 162         return  GSL_SUCCESS;
 163 }
 164
 165 static const HklFunction constant_chi_f2 = {
 166         .function = _constant_chi_f2,
 167         .size = 4,
 168 };
 169
 170 static int _constant_phi_f1(const gsl_vector *x, void *params, gsl_vector *f)
 171 {
 172         const double kappa = x->data[1];
 173         const double kphi = x->data[2];
 174         double phi;
 175         HklPseudoAxisEngine *engine = params;
 176         double phi0 = engine->mode->parameters[0].value;
 177
 178         CHECK_NAN(x->data, x->size);
 179
 180         phi = kphi + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
 181
 182         RUBh_minus_Q(x->data, params, f->data);
 183         f->data[3] = phi0 - phi;
 184
 185         return  GSL_SUCCESS;
 186 }
 187
 188 static const HklFunction constant_phi_f1 = {
 189         .function = _constant_phi_f1,
 190         .size = 4,
 191 };
 192
 193 static int _constant_phi_f2(const gsl_vector *x, void *params, gsl_vector *f)
 194 {
 195         const double kappa = x->data[1];
 196         const double kphi = x->data[2];
 197         double phi;
 198         HklPseudoAxisEngine *engine = params;
 199         double phi0 = engine->mode->parameters[0].value;
 200
 201         CHECK_NAN(x->data, x->size);
 202
 203         phi = kphi + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
 204
 205         RUBh_minus_Q(x->data, params, f->data);
 206         f->data[3] = phi0 - phi;
 207
 208         return  GSL_SUCCESS;
 209 }
 210
 211 static const HklFunction constant_phi_f2 = {
 212         .function = _constant_phi_f2,
 213         .size = 4,
 214 };
 215
 216 /********/
 217 /* mode */
 218 /********/
 219
 220 static HklPseudoAxisEngineMode *bissector(void)
 221 {
 222         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 223         static const HklFunction *functions[] = {&bissector_f1, &bissector_f2};
 224         static const HklPseudoAxisEngineModeAutoInfo info = {
 225                 INFO_AUTO(__func__, axes, functions),
 226         };
 227
 228         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 229                                                     &hkl_mode_operations);
 230 }
 231
 232 static HklPseudoAxisEngineMode *constant_omega(void)
 233 {
 234         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 235         static const HklFunction *functions[] = {&constant_omega_f1, &constant_omega_f2};
 236         static const HklParameter parameters[] = {
 237                 {HKL_PARAMETER_DEFAULTS_ANGLE, .name = "omega"},
 238         };
 239         static const HklPseudoAxisEngineModeAutoInfo info = {
 240                 INFO_AUTO_WITH_PARAMS(__func__, axes, functions, parameters),
 241         };
 242
 243         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 244                                                     &hkl_mode_operations);
 245 }
 246
 247 static HklPseudoAxisEngineMode *constant_chi(void)
 248 {
 249         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 250         static const HklFunction *functions[] = {&constant_chi_f1, &constant_chi_f2};
 251         static const HklParameter parameters[] = {
 252                 {HKL_PARAMETER_DEFAULTS_ANGLE, .name = "chi"},
 253         };
 254         static const HklPseudoAxisEngineModeAutoInfo info = {
 255                 INFO_AUTO_WITH_PARAMS(__func__, axes, functions, parameters),
 256         };
 257
 258         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 259                                                     &hkl_mode_operations);
 260 }
 261
 262 static HklPseudoAxisEngineMode *constant_phi(void)
 263 {
 264         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 265         static const HklFunction *functions[] = {&constant_phi_f1, &constant_phi_f2};
 266         static const HklParameter parameters[] = {
 267                 {HKL_PARAMETER_DEFAULTS_ANGLE, .name = "phi"},
 268         };
 269         static const HklPseudoAxisEngineModeAutoInfo info = {
 270                 INFO_AUTO_WITH_PARAMS(__func__, axes, functions, parameters),
 271         };
 272
 273         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 274                                                     &hkl_mode_operations);
 275 }
 276
 277 static HklPseudoAxisEngineMode *double_diffraction(void)
 278 {
 279         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 280         static const HklFunction *functions[] = {&double_diffraction_func};
 281         static const HklParameter parameters[] = {
 282                 {HKL_PARAMETER_DEFAULTS, .name = "h2", .range = {.min=-1, .max=1}, .value = 1,},
 283                 {HKL_PARAMETER_DEFAULTS, .name = "k2", .range = {.min=-1, .max=1}, .value = 1,},
 284                 {HKL_PARAMETER_DEFAULTS, .name = "l2", .range = {.min=-1, .max=1}, .value = 1,},
 285         };
 286         static const HklPseudoAxisEngineModeAutoInfo info = {
 287                 INFO_AUTO_WITH_PARAMS(__func__, axes, functions, parameters),
 288         };
 289
 290         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 291                                                     &hkl_mode_operations);
 292 }
 293
 294 static HklPseudoAxisEngineMode *psi_constant(void)
 295 {
 296         static const char* axes[] = {"komega", "kappa", "kphi", "tth"};
 297         static const HklFunction *functions[] = {&psi_constant_vertical_func};
 298         static const HklParameter parameters[] = {
 299                 {HKL_PARAMETER_DEFAULTS, .name = "h2", .range = {.min=-1, .max=1}, .value = 1,},
 300                 {HKL_PARAMETER_DEFAULTS, .name = "k2", .range = {.min=-1, .max=1}, .value = 0,},
 301                 {HKL_PARAMETER_DEFAULTS, .name = "l2", .range = {.min=-1, .max=1}, .value = 0,},
 302                 {HKL_PARAMETER_DEFAULTS_ANGLE, .name = "psi"},
 303         };
 304         static const HklPseudoAxisEngineModeAutoInfo info = {
 305                 INFO_AUTO_WITH_PARAMS(__func__, axes, functions, parameters),
 306         };
 307
 308         return hkl_pseudo_axis_engine_mode_auto_new(&info,
 309                                                     &psi_constant_vertical_mode_operations);
 310 }
 311
 312 /**********************/
 313 /* pseudo axis engine */
 314 /**********************/
 315
 316 HklPseudoAxisEngine *hkl_pseudo_axis_engine_k4cv_hkl_new(void)
 317 {
 318         HklPseudoAxisEngine *self;
 319         HklPseudoAxisEngineMode *default_mode;
 320
 321         self = hkl_pseudo_axis_engine_hkl_new();
 322
 323         default_mode = bissector();
 324         hkl_pseudo_axis_engine_add_mode(self, default_mode);
 325         hkl_pseudo_axis_engine_select_mode(self, default_mode);
 326
 327         hkl_pseudo_axis_engine_add_mode(self, constant_omega());
 328         hkl_pseudo_axis_engine_add_mode(self, constant_chi());
 329         hkl_pseudo_axis_engine_add_mode(self, constant_phi());
 330         hkl_pseudo_axis_engine_add_mode(self, double_diffraction());
 331         hkl_pseudo_axis_engine_add_mode(self, psi_constant());
 332
 333         return self;
 334 }