hkl/hkl-engine-k6c.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-2015 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 #include <gsl/gsl_sys.h>                // for gsl_isnan
  23 #include "hkl-factory-private.h"        // for autodata_factories_, etc
  24 #include "hkl-pseudoaxis-common-eulerians-private.h"
  25 #include "hkl-pseudoaxis-common-hkl-private.h"  // for RUBh_minus_Q, etc
  26 #include "hkl-pseudoaxis-common-psi-private.h"  // for hkl_engine_psi_new, etc
  27 #include "hkl-pseudoaxis-common-q-private.h"  // for hkl_engine_q2_new, etc
  28 #include "hkl-pseudoaxis-common-tth-private.h"  // for hkl_engine_tth2_new, etc
  29
  30 static void hkl_geometry_list_multiply_k6c_real(HklGeometryList *self,
  31                                                 HklGeometryListItem *item)
  32 {
  33         HklGeometry *geometry;
  34         HklGeometry *copy;
  35         double komega, komegap;
  36         double kappa, kappap;
  37         double kphi, kphip;
  38
  39         geometry = item->geometry;
  40         komega = hkl_parameter_value_get(darray_item(geometry->axes, 1), HKL_UNIT_DEFAULT);
  41         kappa = hkl_parameter_value_get(darray_item(geometry->axes, 2), HKL_UNIT_DEFAULT);
  42         kphi = hkl_parameter_value_get(darray_item(geometry->axes, 3), HKL_UNIT_DEFAULT);
  43
  44         kappa_2_kappap(komega, kappa, kphi, 50 * HKL_DEGTORAD, &komegap, &kappap, &kphip);
  45
  46         copy = hkl_geometry_new_copy(geometry);
  47         /* TODO parameter list for the geometry */
  48         hkl_parameter_value_set(darray_item(copy->axes, 1), komegap, HKL_UNIT_DEFAULT, NULL);
  49         hkl_parameter_value_set(darray_item(copy->axes, 2), kappap, HKL_UNIT_DEFAULT, NULL);
  50         hkl_parameter_value_set(darray_item(copy->axes, 3), kphip, HKL_UNIT_DEFAULT, NULL);
  51
  52         hkl_geometry_update(copy);
  53         hkl_geometry_list_add(self, copy);
  54         hkl_geometry_free(copy);
  55 }
  56
  57
  58 /***********************/
  59 /* numerical functions */
  60 /***********************/
  61
  62 static int _bissector_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
  63 {
  64         const double mu = x->data[0];
  65         const double komega = x->data[1];
  66         const double kappa = x->data[2];
  67         const double gamma = x->data[4];
  68         double omega;
  69
  70         CHECK_NAN(x->data, x->size);
  71
  72         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
  73
  74         RUBh_minus_Q(x->data, params, f->data);
  75         f->data[3] = fmod(omega, M_PI);
  76         f->data[4] = fmod(gamma - 2 * fmod(mu, M_PI), 2*M_PI);
  77
  78         return  GSL_SUCCESS;
  79 }
  80
  81 static const HklFunction bissector_h_f1 = {
  82         .function = _bissector_h_f1,
  83         .size = 5,
  84 };
  85
  86 static int _bissector_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
  87 {
  88         const double mu = x->data[0];
  89         const double komega = x->data[1];
  90         const double kappa = x->data[2];
  91         const double gamma = x->data[4];
  92         double omega;
  93
  94         CHECK_NAN(x->data, x->size);
  95
  96         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
  97
  98         RUBh_minus_Q(x->data, params, f->data);
  99         f->data[3] = fmod(omega, M_PI);
 100         f->data[4] = fmod(gamma - 2 * fmod(mu, M_PI), 2*M_PI);
 101
 102
 103         return  GSL_SUCCESS;
 104 }
 105
 106 static const HklFunction bissector_h_f2 = {
 107         .function = _bissector_h_f2,
 108         .size = 5,
 109 };
 110
 111 static int _constant_kphi_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
 112 {
 113         const double komega = x->data[1];
 114         const double kappa = x->data[2];
 115         double omega;
 116
 117         CHECK_NAN(x->data, x->size);
 118
 119         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
 120
 121         RUBh_minus_Q(x->data, params, f->data);
 122         f->data[3] = fmod(omega, M_PI);
 123
 124         return  GSL_SUCCESS;
 125 }
 126
 127 static const HklFunction constant_kphi_h_f1 = {
 128         .function = _constant_kphi_h_f1,
 129         .size = 4,
 130 };
 131
 132 static int _constant_kphi_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
 133 {
 134         const double komega = x->data[1];
 135         const double kappa = x->data[2];
 136         double omega;
 137
 138         CHECK_NAN(x->data, x->size);
 139
 140         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
 141
 142         RUBh_minus_Q(x->data, params, f->data);
 143         f->data[3] = fmod(omega, M_PI);
 144
 145         return  GSL_SUCCESS;
 146 }
 147
 148 static const HklFunction constant_kphi_h_f2 = {
 149         .function = _constant_kphi_h_f2,
 150         .size = 4,
 151 };
 152
 153 static int _constant_phi_h_f1(const gsl_vector *x, void *params, gsl_vector *f)
 154 {
 155         const double komega = x->data[1];
 156         const double kappa = x->data[2];
 157         const double kphi = x->data[3];
 158         double omega, phi, p;
 159
 160         CHECK_NAN(x->data, x->size);
 161
 162         p = atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD));
 163         omega = komega + p - M_PI_2;
 164         phi = kphi + p + M_PI_2;
 165
 166         RUBh_minus_Q(x->data, params, f->data);
 167         f->data[3] = fmod(omega, M_PI);
 168         f->data[4] = phi;
 169
 170         return  GSL_SUCCESS;
 171 }
 172
 173 static const HklFunction constant_phi_h_f1 = {
 174         .function = _constant_phi_h_f1,
 175         .size = 5,
 176 };
 177
 178 static int _constant_phi_h_f2(const gsl_vector *x, void *params, gsl_vector *f)
 179 {
 180         const double komega = x->data[1];
 181         const double kappa = x->data[2];
 182         const double kphi = x->data[3];
 183         double omega, phi, p;
 184
 185         CHECK_NAN(x->data, x->size);
 186
 187         p = atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD));
 188         omega = komega + p + M_PI_2;
 189         phi = kphi + p - M_PI_2;
 190
 191         RUBh_minus_Q(x->data, params, f->data);
 192         f->data[3] = fmod(omega, M_PI);
 193         f->data[4] = phi;
 194
 195         return  GSL_SUCCESS;
 196 }
 197
 198 static const HklFunction constant_phi_h_f2 = {
 199         .function = _constant_phi_h_f2,
 200         .size = 5,
 201 };
 202
 203 static int _bissector_v(const gsl_vector *x, void *params, gsl_vector *f)
 204 {
 205         const double komega = x->data[0];
 206         const double kappa = x->data[1];
 207         const double delta = x->data[3];
 208         double omega;
 209
 210         CHECK_NAN(x->data, x->size);
 211
 212         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
 213
 214         RUBh_minus_Q(x->data, params, f->data);
 215         f->data[3] = fmod(delta - 2 * fmod(omega, M_PI), 2*M_PI);
 216
 217         return  GSL_SUCCESS;
 218 }
 219
 220 static const HklFunction bissector_v = {
 221         .function = _bissector_v,
 222         .size = 4,
 223 };
 224
 225 static int _constant_omega_v(const gsl_vector *x, void *params, gsl_vector *f)
 226 {
 227         const double komega = x->data[0];
 228         const double kappa = x->data[1];
 229         double omega;
 230         HklEngine *engine = params;
 231         double omega0 = darray_item(engine->mode->parameters, 0)->_value;
 232
 233         CHECK_NAN(x->data, x->size);
 234
 235         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
 236
 237         RUBh_minus_Q(x->data, params, f->data);
 238         f->data[3] = omega0 - omega;
 239
 240         return  GSL_SUCCESS;
 241 }
 242
 243 static const HklFunction constant_omega_v = {
 244         .function = _constant_omega_v,
 245         .size = 4,
 246 };
 247
 248 static int _constant_chi_v(const gsl_vector *x, void *params, gsl_vector *f)
 249 {
 250         const double kappa = x->data[1];
 251         double chi;
 252         HklEngine *engine = params;
 253         double chi0 = darray_item(engine->mode->parameters, 0)->_value;
 254
 255         CHECK_NAN(x->data, x->size);
 256
 257         chi = 2 * asin(sin(kappa/2.) * sin(50 * HKL_DEGTORAD));
 258
 259         RUBh_minus_Q(x->data, params, f->data);
 260         f->data[3] = chi0 - chi;
 261
 262         return  GSL_SUCCESS;
 263 }
 264
 265 static const HklFunction constant_chi_v = {
 266         .function = _constant_chi_v,
 267         .size = 4,
 268 };
 269
 270 static int _constant_phi_v(const gsl_vector *x, void *params, gsl_vector *f)
 271 {
 272         const double kappa = x->data[1];
 273         const double kphi = x->data[2];
 274         double phi;
 275         HklEngine *engine = params;
 276         double phi0 = darray_item(engine->mode->parameters, 0)->_value;
 277
 278         CHECK_NAN(x->data, x->size);
 279
 280         phi = kphi + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) + M_PI_2;
 281
 282         RUBh_minus_Q(x->data, params, f->data);
 283         f->data[3] = phi0 - phi;
 284
 285         return  GSL_SUCCESS;
 286 }
 287
 288 static const HklFunction constant_phi_v = {
 289         .function = _constant_phi_v,
 290         .size = 4,
 291 };
 292
 293 static int _double_diffraction_h(const gsl_vector *x, void *params, gsl_vector *f)
 294 {
 295         const double komega = x->data[1];
 296         const double kappa = x->data[2];
 297         double omega;
 298
 299         CHECK_NAN(x->data, x->size);
 300
 301         omega = komega + atan(tan(kappa/2.)*cos(50 * HKL_DEGTORAD)) - M_PI_2;
 302
 303         _double_diffraction(x->data, params, f->data);
 304         f->data[4] = fmod(omega, M_PI);
 305
 306         return  GSL_SUCCESS;
 307 }
 308
 309 static const HklFunction double_diffraction_h = {
 310         .function = _double_diffraction_h,
 311         .size = 5,
 312 };
 313
 314 static int _constant_incidence_func(const gsl_vector *x, void *params, gsl_vector *f)
 315 {
 316         static const HklVector Y = {
 317                 .data = {0, 1, 0},
 318         };
 319         double incidence;
 320         double azimuth;
 321         HklEngine *engine = params;
 322         HklModeAutoWithInit *mode = container_of(engine->mode, HklModeAutoWithInit, mode);
 323         HklVector n;
 324         double incidence0;
 325         double azimuth0;
 326         HklVector ki;
 327
 328         CHECK_NAN(x->data, x->size);
 329
 330         RUBh_minus_Q(x->data, params, f->data);
 331
 332         /* get the mode parameters */
 333         n.data[0] = darray_item(engine->mode->parameters, 0)->_value;
 334         n.data[1] = darray_item(engine->mode->parameters, 1)->_value;
 335         n.data[2] = darray_item(engine->mode->parameters, 2)->_value;
 336         incidence0 = darray_item(engine->mode->parameters, 3)->_value;
 337         azimuth0 = darray_item(engine->mode->parameters, 4)->_value;
 338
 339         /* compute the two angles */
 340
 341
 342         /* first check that the mode was already initialized if not
 343          * the surface is oriented along the nx, ny, nz axis for all
 344          * diffractometer angles equal to zero */
 345         if(mode->geometry){
 346                 HklQuaternion q0 = darray_item(mode->geometry->holders, 0)->q;
 347
 348                 hkl_quaternion_conjugate(&q0);
 349                 hkl_vector_rotated_quaternion(&n, &q0);
 350         }
 351
 352         hkl_vector_rotated_quaternion(&n, &darray_item(engine->geometry->holders, 0)->q);
 353
 354         hkl_source_compute_ki(&engine->geometry->source, &ki);
 355         incidence = M_PI_2 - hkl_vector_angle(&n, &ki);
 356
 357         hkl_vector_project_on_plan(&n, &ki);
 358         azimuth = hkl_vector_angle(&n, &Y);
 359
 360         f->data[3] = incidence0 - incidence;
 361         f->data[4] = azimuth0 - azimuth;
 362
 363         return  GSL_SUCCESS;
 364 }
 365
 366 static const HklFunction constant_incidence_func = {
 367         .function = _constant_incidence_func,
 368         .size = 5,
 369 };
 370
 371 /********/
 372 /* mode */
 373 /********/
 374
 375 static HklMode *bissector_vertical(void)
 376 {
 377         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 378         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 379         static const HklFunction *functions[] = {&bissector_v};
 380         static const HklModeAutoInfo info = {
 381                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 382         };
 383
 384         return hkl_mode_auto_new(&info,
 385                                  &hkl_mode_operations,
 386                                  TRUE);
 387 }
 388
 389 static HklMode *constant_omega_vertical(void)
 390 {
 391         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 392         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 393         static const HklFunction *functions[] = {&constant_omega_v};
 394         static const HklModeAutoInfo info = {
 395                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 396                                                functions, constant_omega_parameters),
 397         };
 398
 399         return hkl_mode_auto_new(&info,
 400                                  &hkl_mode_operations,
 401                                  TRUE);
 402 }
 403
 404 static HklMode *constant_chi_vertical(void)
 405 {
 406         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 407         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 408         static const HklFunction *functions[] = {&constant_chi_v};
 409         static const HklModeAutoInfo info = {
 410                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 411                                                functions, constant_chi_parameters),
 412         };
 413
 414         return hkl_mode_auto_new(&info,
 415                                  &hkl_mode_operations,
 416                                  TRUE);
 417 }
 418
 419 static HklMode *constant_phi_vertical(void)
 420 {
 421         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 422         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 423         static const HklFunction *functions[] = {&constant_phi_v};
 424         static const HklModeAutoInfo info = {
 425                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 426                                                functions, constant_phi_parameters),
 427         };
 428
 429         return hkl_mode_auto_new(&info,
 430                                  &hkl_mode_operations,
 431                                  TRUE);
 432 }
 433
 434 static HklMode *lifting_detector_kphi(void)
 435 {
 436         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 437         static const char* axes_w[] = {"kphi", "gamma", "delta"};
 438         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 439         static const HklModeAutoInfo info = {
 440                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 441         };
 442
 443         return hkl_mode_auto_new(&info,
 444                                  &hkl_mode_operations,
 445                                  TRUE);
 446 }
 447
 448 static HklMode *lifting_detector_komega(void)
 449 {
 450         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 451         static const char* axes_w[] = {"komega", "gamma", "delta"};
 452         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 453         static const HklModeAutoInfo info = {
 454                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 455         };
 456
 457         return hkl_mode_auto_new(&info,
 458                                  &hkl_mode_operations,
 459                                  TRUE);
 460 }
 461
 462 static HklMode *lifting_detector_mu(void)
 463 {
 464         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 465         static const char* axes_w[] = {"mu", "gamma", "delta"};
 466         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 467         static const HklModeAutoInfo info = {
 468                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 469         };
 470
 471         return hkl_mode_auto_new(&info,
 472                                  &hkl_mode_operations,
 473                                  TRUE);
 474 }
 475
 476 static HklMode *double_diffraction_vertical(void)
 477 {
 478         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 479         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 480         static const HklFunction *functions[] = {&double_diffraction_func};
 481         static const HklModeAutoInfo info = {
 482                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 483                                                functions, double_diffraction_parameters),
 484         };
 485
 486         return hkl_mode_auto_new(&info,
 487                                  &hkl_mode_operations,
 488                                  TRUE);
 489 }
 490
 491 static HklMode *bissector_horizontal(void)
 492 {
 493         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 494         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "gamma"};
 495         static const HklFunction *functions[] = {&bissector_h_f1, &bissector_h_f2};
 496         static const HklModeAutoInfo info = {
 497                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 498         };
 499
 500         return hkl_mode_auto_new(&info,
 501                                  &hkl_mode_operations,
 502                                  TRUE);
 503 }
 504
 505 static HklMode *constant_phi_horizontal(void)
 506 {
 507         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 508         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "gamma"};
 509         static const HklFunction *functions[] = {&constant_phi_h_f1, &constant_phi_h_f2};
 510         static const HklModeAutoInfo info = {
 511                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 512                                                functions, constant_phi_parameters),
 513         };
 514
 515         return hkl_mode_auto_new(&info,
 516                                  &hkl_mode_operations,
 517                                  TRUE);
 518 }
 519
 520 static HklMode *constant_kphi_horizontal(void)
 521 {
 522         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 523         static const char* axes_w[] = {"mu", "komega", "kappa", "gamma"};
 524         static const HklFunction *functions[] = {&constant_kphi_h_f1, &constant_kphi_h_f2};
 525         static const HklModeAutoInfo info = {
 526                 HKL_MODE_AUTO_INFO(__func__, axes_r, axes_w, functions),
 527         };
 528
 529         return hkl_mode_auto_new(&info,
 530                                  &hkl_mode_operations,
 531                                  TRUE);
 532 }
 533
 534 static HklMode *double_diffraction_horizontal(void)
 535 {
 536         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 537         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "gamma"};
 538         static const HklFunction *functions[] = {&double_diffraction_h};
 539         static const HklModeAutoInfo info = {
 540                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 541                                                functions, double_diffraction_parameters),
 542         };
 543
 544         return hkl_mode_auto_new(&info,
 545                                  &hkl_mode_operations,
 546                                  TRUE);
 547 }
 548
 549 static HklMode *psi_constant_vertical(void)
 550 {
 551         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 552         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta"};
 553         static const HklFunction *functions[] = {&psi_constant_vertical_func};
 554         static const HklModeAutoInfo info = {
 555                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 556                                                functions, psi_constant_parameters),
 557         };
 558
 559         return hkl_mode_auto_new(&info,
 560                                  &psi_constant_vertical_mode_operations,
 561                                  TRUE);
 562 }
 563
 564 static HklMode *constant_incidence(void)
 565 {
 566         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 567         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma", "delta"};
 568         static const HklFunction *functions[] = {&constant_incidence_func};
 569         static const HklModeAutoInfo info = {
 570                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 571                                                functions, constant_incidence_parameters),
 572         };
 573
 574         return hkl_mode_auto_with_init_new(&info,
 575                                            &constant_incidence_mode_operations,
 576                                            TRUE);
 577 }
 578
 579 /**********************/
 580 /* pseudo axis engine */
 581 /**********************/
 582
 583 static HklEngine *hkl_engine_k6c_hkl_new(HklEngineList *engines)
 584 {
 585         HklEngine *self;
 586         HklMode *default_mode;
 587
 588         self = hkl_engine_hkl_new(engines);
 589
 590         default_mode = bissector_vertical();
 591         hkl_engine_add_mode(self, default_mode);
 592         hkl_engine_mode_set(self, default_mode);
 593
 594         hkl_engine_add_mode(self, constant_omega_vertical());
 595         hkl_engine_add_mode(self, constant_chi_vertical());
 596         hkl_engine_add_mode(self, constant_phi_vertical());
 597         hkl_engine_add_mode(self, lifting_detector_kphi());
 598         hkl_engine_add_mode(self, lifting_detector_komega());
 599         hkl_engine_add_mode(self, lifting_detector_mu());
 600         hkl_engine_add_mode(self, double_diffraction_vertical());
 601         hkl_engine_add_mode(self, bissector_horizontal());
 602         hkl_engine_add_mode(self, constant_phi_horizontal());
 603         hkl_engine_add_mode(self, constant_kphi_horizontal());
 604         hkl_engine_add_mode(self, double_diffraction_horizontal());
 605         hkl_engine_add_mode(self, psi_constant_vertical());
 606         hkl_engine_add_mode(self, constant_incidence());
 607
 608         return self;
 609 }
 610
 611 /***********************/
 612 /* SOLEIL sirius kappa */
 613 /***********************/
 614
 615 /* mode */
 616
 617 static HklMode *bissector_vertical_soleil_sirius_kappa(void)
 618 {
 619         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 620         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 621         static const HklFunction *functions[] = {&bissector_v};
 622         static const HklModeAutoInfo info = {
 623                 HKL_MODE_AUTO_INFO("bissector_vertical", axes_r, axes_w, functions),
 624         };
 625
 626         return hkl_mode_auto_new(&info,
 627                                  &hkl_mode_operations,
 628                                  TRUE);
 629 }
 630
 631 static HklMode *constant_omega_vertical_soleil_sirius_kappa(void)
 632 {
 633         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 634         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 635         static const HklFunction *functions[] = {&constant_omega_v};
 636         static const HklModeAutoInfo info = {
 637                 HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_omega_vertical", axes_r, axes_w,
 638                                                functions, constant_omega_parameters),
 639         };
 640
 641         return hkl_mode_auto_new(&info,
 642                                  &hkl_mode_operations,
 643                                  TRUE);
 644 }
 645
 646 static HklMode *constant_chi_vertical_soleil_sirius_kappa(void)
 647 {
 648         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 649         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 650         static const HklFunction *functions[] = {&constant_chi_v};
 651         static const HklModeAutoInfo info = {
 652                 HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_chi_vertical", axes_r, axes_w,
 653                                                functions, constant_chi_parameters),
 654         };
 655
 656         return hkl_mode_auto_new(&info,
 657                                  &hkl_mode_operations,
 658                                  TRUE);
 659 }
 660
 661 static HklMode *constant_phi_vertical_soleil_sirius_kappa(void)
 662 {
 663         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 664         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 665         static const HklFunction *functions[] = {&constant_phi_v};
 666         static const HklModeAutoInfo info = {
 667                 HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_phi_vertical", axes_r, axes_w,
 668                                                functions, constant_phi_parameters),
 669         };
 670
 671         return hkl_mode_auto_new(&info,
 672                                  &hkl_mode_operations,
 673                                  TRUE);
 674 }
 675
 676 static HklMode *lifting_detector_kphi_soleil_sirius_kappa(void)
 677 {
 678         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 679         static const char* axes_w[] = {"kphi", "delta", "gamma"};
 680         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 681         static const HklModeAutoInfo info = {
 682                 HKL_MODE_AUTO_INFO("lifting_detector_kphi", axes_r, axes_w, functions),
 683         };
 684
 685         return hkl_mode_auto_new(&info,
 686                                  &hkl_mode_operations,
 687                                  TRUE);
 688 }
 689
 690 static HklMode *lifting_detector_komega_soleil_sirius_kappa(void)
 691 {
 692         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 693         static const char* axes_w[] = {"komega", "delta", "gamma"};
 694         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 695         static const HklModeAutoInfo info = {
 696                 HKL_MODE_AUTO_INFO("lifting_detector_komega", axes_r, axes_w, functions),
 697         };
 698
 699         return hkl_mode_auto_new(&info,
 700                                  &hkl_mode_operations,
 701                                  TRUE);
 702 }
 703
 704 static HklMode *lifting_detector_mu_soleil_sirius_kappa(void)
 705 {
 706         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 707         static const char* axes_w[] = {"mu", "delta", "gamma"};
 708         static const HklFunction *functions[] = {&RUBh_minus_Q_func};
 709         static const HklModeAutoInfo info = {
 710                 HKL_MODE_AUTO_INFO("lifting_detector_mu", axes_r, axes_w, functions),
 711         };
 712
 713         return hkl_mode_auto_new(&info,
 714                                  &hkl_mode_operations,
 715                                  TRUE);
 716 }
 717
 718 static HklMode *double_diffraction_vertical_soleil_sirius_kappa(void)
 719 {
 720         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 721         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 722         static const HklFunction *functions[] = {&double_diffraction_func};
 723         static const HklModeAutoInfo info = {
 724                 HKL_MODE_AUTO_INFO_WITH_PARAMS("double_diffraction_vertical", axes_r, axes_w,
 725                                                functions, double_diffraction_parameters),
 726         };
 727
 728         return hkl_mode_auto_new(&info,
 729                                  &hkl_mode_operations,
 730                                  TRUE);
 731 }
 732
 733 static HklMode *bissector_horizontal_soleil_sirius_kappa(void)
 734 {
 735         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 736         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "delta"};
 737         static const HklFunction *functions[] = {&bissector_h_f1, &bissector_h_f2};
 738         static const HklModeAutoInfo info = {
 739                 HKL_MODE_AUTO_INFO("bissector_horizontal", axes_r, axes_w, functions),
 740         };
 741
 742         return hkl_mode_auto_new(&info,
 743                                  &hkl_mode_operations,
 744                                  TRUE);
 745 }
 746
 747 static HklMode *constant_phi_horizontal_soleil_sirius_kappa(void)
 748 {
 749         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 750         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "delta"};
 751         static const HklFunction *functions[] = {&constant_phi_h_f1, &constant_phi_h_f2};
 752         static const HklModeAutoInfo info = {
 753                 HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_phi_horizontal", axes_r, axes_w,
 754                                                functions, constant_phi_parameters),
 755         };
 756
 757         return hkl_mode_auto_new(&info,
 758                                  &hkl_mode_operations,
 759                                  TRUE);
 760 }
 761
 762 static HklMode *constant_kphi_horizontal_soleil_sirius_kappa(void)
 763 {
 764         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 765         static const char* axes_w[] = {"mu", "komega", "kappa", "delta"};
 766         static const HklFunction *functions[] = {&constant_kphi_h_f1, &constant_kphi_h_f2};
 767         static const HklModeAutoInfo info = {
 768                 HKL_MODE_AUTO_INFO("constant_kphi_horizontal", axes_r, axes_w, functions),
 769         };
 770
 771         return hkl_mode_auto_new(&info,
 772                                  &hkl_mode_operations,
 773                                  TRUE);
 774 }
 775
 776 static HklMode *double_diffraction_horizontal_soleil_sirius_kappa(void)
 777 {
 778         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 779         static const char* axes_w[] = {"mu", "komega", "kappa", "kphi", "delta"};
 780         static const HklFunction *functions[] = {&double_diffraction_h};
 781         static const HklModeAutoInfo info = {
 782                 HKL_MODE_AUTO_INFO_WITH_PARAMS("double_diffraction_horizontal", axes_r, axes_w,
 783                                                functions, double_diffraction_parameters),
 784         };
 785
 786         return hkl_mode_auto_new(&info,
 787                                  &hkl_mode_operations,
 788                                  TRUE);
 789 }
 790
 791 static HklMode *psi_constant_vertical_soleil_sirius_kappa(void)
 792 {
 793         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 794         static const char* axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 795         static const HklFunction *functions[] = {&psi_constant_vertical_func};
 796         static const HklModeAutoInfo info = {
 797                 HKL_MODE_AUTO_INFO_WITH_PARAMS("psi_constant_vertical", axes_r, axes_w,
 798                                                functions, psi_constant_parameters),
 799         };
 800
 801         return hkl_mode_auto_new(&info,
 802                                  &psi_constant_vertical_mode_operations,
 803                                  TRUE);
 804 }
 805
 806 static HklMode *constant_incidence_soleil_sirius_kappa(void)
 807 {
 808         static const char* axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 809         static const char* axes_w[] = {"komega", "kappa", "kphi", "delta", "gamma"};
 810         static const HklFunction *functions[] = {&constant_incidence_func};
 811         static const HklModeAutoInfo info = {
 812                 HKL_MODE_AUTO_INFO_WITH_PARAMS("constant_incidence", axes_r, axes_w,
 813                                                functions, constant_incidence_parameters),
 814         };
 815
 816         return hkl_mode_auto_with_init_new(&info,
 817                                            &constant_incidence_mode_operations,
 818                                            TRUE);
 819 }
 820
 821 static HklEngine *hkl_engine_soleil_sirius_kappa_hkl_new(HklEngineList *engines)
 822 {
 823         HklEngine *self;
 824         HklMode *default_mode;
 825
 826         self = hkl_engine_hkl_new(engines);
 827
 828         default_mode = bissector_vertical_soleil_sirius_kappa();
 829         hkl_engine_add_mode(self, default_mode);
 830         hkl_engine_mode_set(self, default_mode);
 831
 832         hkl_engine_add_mode(self, constant_omega_vertical_soleil_sirius_kappa());
 833         hkl_engine_add_mode(self, constant_chi_vertical_soleil_sirius_kappa());
 834         hkl_engine_add_mode(self, constant_phi_vertical_soleil_sirius_kappa());
 835         hkl_engine_add_mode(self, lifting_detector_kphi_soleil_sirius_kappa());
 836         hkl_engine_add_mode(self, lifting_detector_komega_soleil_sirius_kappa());
 837         hkl_engine_add_mode(self, lifting_detector_mu_soleil_sirius_kappa());
 838         hkl_engine_add_mode(self, double_diffraction_vertical_soleil_sirius_kappa());
 839         hkl_engine_add_mode(self, bissector_horizontal_soleil_sirius_kappa());
 840         hkl_engine_add_mode(self, constant_phi_horizontal_soleil_sirius_kappa());
 841         hkl_engine_add_mode(self, constant_kphi_horizontal_soleil_sirius_kappa());
 842         hkl_engine_add_mode(self, double_diffraction_horizontal_soleil_sirius_kappa());
 843         hkl_engine_add_mode(self, psi_constant_vertical_soleil_sirius_kappa());
 844         hkl_engine_add_mode(self, constant_incidence_soleil_sirius_kappa());
 845
 846         return self;
 847 }
 848
 849 static HklMode *psi_vertical()
 850 {
 851         static const char *axes_r[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 852         static const char *axes_w[] = {"komega", "kappa", "kphi", "delta"};
 853         static const HklFunction *functions[] = {&psi_func};
 854         static const HklModeAutoInfo info = {
 855                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 856                                                functions, psi_parameters),
 857         };
 858
 859         return hkl_mode_psi_new(&info);
 860 }
 861
 862 static HklEngine *hkl_engine_k6c_psi_new(HklEngineList *engines)
 863 {
 864         HklEngine *self;
 865         HklMode *default_mode;
 866
 867         self = hkl_engine_psi_new(engines);
 868
 869         default_mode = psi_vertical();
 870         hkl_engine_add_mode(self, default_mode);
 871         hkl_engine_mode_set(self, default_mode);
 872
 873         return self;
 874 }
 875
 876 /***********************/
 877 /* SOLEIL SIRIUS KAPPA */
 878 /***********************/
 879
 880 static HklMode *psi_vertical_soleil_sirius_kappa()
 881 {
 882         static const char *axes_r[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 883         static const char *axes_w[] = {"komega", "kappa", "kphi", "gamma"};
 884         static const HklFunction *functions[] = {&psi_func};
 885         static const HklModeAutoInfo info = {
 886                 HKL_MODE_AUTO_INFO_WITH_PARAMS(__func__, axes_r, axes_w,
 887                                                functions, psi_parameters),
 888         };
 889
 890         return hkl_mode_psi_new(&info);
 891 }
 892
 893 static HklEngine *hkl_engine_soleil_sirius_kappa_psi_new(HklEngineList *engines)
 894 {
 895         HklEngine *self;
 896         HklMode *default_mode;
 897
 898         self = hkl_engine_psi_new(engines);
 899
 900         default_mode = psi_vertical_soleil_sirius_kappa();
 901         hkl_engine_add_mode(self, default_mode);
 902         hkl_engine_mode_set(self, default_mode);
 903
 904         return self;
 905 }
 906
 907 /*******/
 908 /* K6C */
 909 /*******/
 910
 911 #define HKL_GEOMETRY_KAPPA6C_DESCRIPTION                                \
 912         "For this geometry there is a special parameters called :math:`\\alpha` which is the\n" \
 913         "angle between the kappa rotation axis and the  :math:`\\vec{y}` direction.\n" \
 914         "\n"                                                            \
 915         "+ xrays source fix allong the :math:`\\vec{x}` direction (1, 0, 0)\n" \
 916         "+ 4 axes for the sample\n"                                     \
 917         "\n"                                                            \
 918         "  + **mu** : rotating around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
 919         "  + **komega** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
 920         "  + **kappa** : rotating around the :math:`\\vec{x}` direction (0, :math:`-\\cos\\alpha`, :math:`-\\sin\\alpha`)\n" \
 921         "  + **kphi** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
 922         "\n"                                                            \
 923         "+ 2 axes for the detector\n"                                   \
 924         "\n"                                                            \
 925         "  + **gamma** : rotation around the :math:`\\vec{z}` direction (0, 0, 1)\n" \
 926         "  + **delta** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
 927
 928 static const char* hkl_geometry_kappa6C_axes[] = {"mu", "komega", "kappa", "kphi", "gamma", "delta"};
 929
 930 static HklGeometry *hkl_geometry_new_kappa6C(const HklFactory *factory)
 931 {
 932         HklGeometry *self = hkl_geometry_new(factory);
 933         double alpha = 50 * HKL_DEGTORAD;
 934         HklHolder *h;
 935
 936         h = hkl_geometry_add_holder(self);
 937         hkl_holder_add_rotation_axis(h, "mu", 0, 0, 1);
 938         hkl_holder_add_rotation_axis(h, "komega", 0, -1, 0);
 939         hkl_holder_add_rotation_axis(h, "kappa", 0, -cos(alpha), -sin(alpha));
 940         hkl_holder_add_rotation_axis(h, "kphi", 0, -1, 0);
 941
 942         h = hkl_geometry_add_holder(self);
 943         hkl_holder_add_rotation_axis(h, "gamma", 0, 0, 1);
 944         hkl_holder_add_rotation_axis(h, "delta", 0, -1, 0);
 945
 946         return self;
 947 }
 948
 949 static HklEngineList *hkl_engine_list_new_kappa6C(const HklFactory *factory)
 950 {
 951         HklEngineList *self = hkl_engine_list_new();
 952
 953         self->geometries->multiply = hkl_geometry_list_multiply_k6c_real;
 954         hkl_engine_k6c_hkl_new(self);
 955         hkl_engine_eulerians_new(self);
 956         hkl_engine_k6c_psi_new(self);
 957         hkl_engine_q2_new(self);
 958         hkl_engine_qper_qpar_new(self);
 959         hkl_engine_tth2_new(self);
 960
 961         return self;
 962 }
 963
 964 REGISTER_DIFFRACTOMETER(kappa6C, "K6C", HKL_GEOMETRY_KAPPA6C_DESCRIPTION);
 965
 966 /***********************/
 967 /* SOLEIL SIRIUS KAPPA */
 968 /***********************/
 969
 970 #define HKL_GEOMETRY_TYPE_SOLEIL_SIRIUS_KAPPA_DESCRIPTION               \
 971         "+ xrays source fix along the :math:`\\vec{x}` direction (1, 0, 0)\n" \
 972         "+ 4 axes for the sample\n"                                     \
 973         "\n"                                                            \
 974         "  + **mu** : rotating around the :math:`-\\vec{z}` direction (0, 0, -1)\n" \
 975         "  + **komega** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
 976         "  + **kappa** : rotating around the :math:`\\vec{x}` direction (0, :math:`-\\cos\\alpha`, :math:`-\\sin\\alpha`)\n" \
 977         "  + **kphi** : rotating around the :math:`-\\vec{y}` direction (0, -1, 0)\n" \
 978         "\n"                                                            \
 979         "+ 2 axes for the detector\n"                                   \
 980         "\n"                                                            \
 981         "  + **delta** : rotation around the :math:`-\\vec{z}` direction (0, 0, -1)\n" \
 982         "  + **gamma** : rotation around the :math:`-\\vec{y}` direction (0, -1, 0)\n"
 983
 984 static const char* hkl_geometry_soleil_sirius_kappa_axes[] = {"mu", "komega", "kappa", "kphi", "delta", "gamma"};
 985
 986 static HklGeometry *hkl_geometry_new_soleil_sirius_kappa(const HklFactory *factory)
 987 {
 988         HklGeometry *self = hkl_geometry_new(factory);
 989         double alpha = 50 * HKL_DEGTORAD;
 990         HklHolder *h;
 991
 992         h = hkl_geometry_add_holder(self);
 993         hkl_holder_add_rotation_axis(h, "mu", 0, 0, -1);
 994         hkl_holder_add_rotation_axis(h, "komega", 0, -1, 0);
 995         hkl_holder_add_rotation_axis(h, "kappa", 0, -cos(alpha), -sin(alpha));
 996         hkl_holder_add_rotation_axis(h, "kphi", 0, -1, 0);
 997
 998         h = hkl_geometry_add_holder(self);
 999         hkl_holder_add_rotation_axis(h, "delta", 0, 0, -1);
1000         hkl_holder_add_rotation_axis(h, "gamma", 0, -1, 0);
1001
1002         return self;
1003 }
1004
1005 static HklEngineList *hkl_engine_list_new_soleil_sirius_kappa(const HklFactory *factory)
1006 {
1007         HklEngineList *self = hkl_engine_list_new();
1008
1009         self->geometries->multiply = hkl_geometry_list_multiply_k6c_real;
1010         hkl_engine_soleil_sirius_kappa_hkl_new(self);
1011         hkl_engine_eulerians_new(self);
1012         hkl_engine_soleil_sirius_kappa_psi_new(self);
1013         hkl_engine_q2_new(self);
1014         hkl_engine_qper_qpar_new(self);
1015         hkl_engine_tth2_new(self);
1016
1017         return self;
1018 }
1019
1020 REGISTER_DIFFRACTOMETER(soleil_sirius_kappa, "SOLEIL SIRIUS KAPPA", HKL_GEOMETRY_TYPE_SOLEIL_SIRIUS_KAPPA_DESCRIPTION);