test/hkl-test-pseudoaxis-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-2010 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 <hkl.h>
  23
  24 #include "hkl-test.h"
  25
  26 #ifdef HKL_TEST_SUITE_NAME
  27 # undef HKL_TEST_SUITE_NAME
  28 #endif
  29 #define HKL_TEST_SUITE_NAME pseudoaxis_K6C
  30
  31 #define SET_AXES(geometry, mu, komega, kappa, kphi, gamma, delta) do{   \
  32                 hkl_geometry_set_values_v(geometry, 6,                  \
  33                                           mu * HKL_DEGTORAD,            \
  34                                           komega * HKL_DEGTORAD,        \
  35                                           kappa * HKL_DEGTORAD,         \
  36                                           kphi * HKL_DEGTORAD,          \
  37                                           gamma * HKL_DEGTORAD,         \
  38                                           delta * HKL_DEGTORAD);        \
  39         } while(0)
  40
  41 HKL_TEST_SUITE_FUNC(new)
  42 {
  43         HklPseudoAxisEngine *engine = hkl_pseudo_axis_engine_k6c_hkl_new();
  44         hkl_pseudo_axis_engine_free(engine);
  45
  46         return HKL_TEST_PASS;
  47 }
  48
  49 HKL_TEST_SUITE_FUNC(degenerated)
  50 {
  51         HklPseudoAxisEngineList *engines;
  52         HklPseudoAxisEngine *engine;
  53         const HklGeometryConfig *config;
  54         HklGeometry *geom;
  55         HklDetector *detector;
  56         HklSample *sample;
  57         size_t i, f_idx;
  58         double *H, *K, *L;
  59
  60         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
  61         geom = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
  62         sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
  63
  64         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  65         detector->idx = 1;
  66
  67         engines = hkl_pseudo_axis_engine_list_factory(config);
  68         hkl_pseudo_axis_engine_list_init(engines, geom, detector, sample);
  69
  70         engine = hkl_pseudo_axis_engine_list_get_by_name(engines, "hkl");
  71
  72         H = &(((HklParameter *)engine->pseudoAxes[0])->value);
  73         K = &(((HklParameter *)engine->pseudoAxes[1])->value);
  74         L = &(((HklParameter *)engine->pseudoAxes[2])->value);
  75
  76         for(f_idx=0; f_idx<HKL_LIST_LEN(engine->modes); ++f_idx) {
  77                 double h, k, l;
  78                 int res;
  79
  80                 hkl_pseudo_axis_engine_select_mode(engine, f_idx);
  81                 if (HKL_LIST_LEN(engine->mode->parameters))
  82                         engine->mode->parameters[0].value = 1.;
  83
  84                 /* studdy this degenerated case */
  85                 *H = h = 0;
  86                 *K = k = 1;
  87                 *L = l = 0;
  88
  89                 /* pseudo -> geometry */
  90                 res = hkl_pseudo_axis_engine_set(engine, NULL);
  91                 /* hkl_pseudo_axis_engine_fprintf(stdout, engine); */
  92
  93                 /* geometry -> pseudo */
  94                 if (res == HKL_SUCCESS) {
  95                         /* hkl_pseudo_axis_engine_fprintf(stdout, engine); */
  96                         for(i=0; i<hkl_geometry_list_len(engines->geometries); ++i) {
  97                                 *H = *K = *L = 0;
  98
  99                                 hkl_geometry_init_geometry(geom,
 100                                                            engines->geometries->items[i]->geometry);
 101                                 hkl_pseudo_axis_engine_get(engine, NULL);
 102
 103                                 HKL_ASSERT_DOUBLES_EQUAL(h, *H, HKL_EPSILON);
 104                                 HKL_ASSERT_DOUBLES_EQUAL(k, *K, HKL_EPSILON);
 105                                 HKL_ASSERT_DOUBLES_EQUAL(l, *L, HKL_EPSILON);
 106                         }
 107                 }
 108         }
 109
 110         hkl_pseudo_axis_engine_list_free(engines);
 111         hkl_detector_free(detector);
 112         hkl_sample_free(sample);
 113         hkl_geometry_free(geom);
 114
 115         return HKL_TEST_PASS;
 116 }
 117
 118 HKL_TEST_SUITE_FUNC(eulerians)
 119 {
 120         HklPseudoAxisEngineList *engines;
 121         HklPseudoAxisEngine *engine;
 122         const HklGeometryConfig *config;
 123         HklGeometry *geom;
 124         HklDetector *detector;
 125         HklSample *sample;
 126         size_t i, f_idx;
 127         double *Omega, *Chi, *Phi;
 128
 129         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
 130         geom = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 131         sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
 132
 133         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 134         detector->idx = 1;
 135
 136         engines = hkl_pseudo_axis_engine_list_factory(config);
 137         hkl_pseudo_axis_engine_list_init(engines, geom, detector, sample);
 138
 139         engine = hkl_pseudo_axis_engine_list_get_by_name(engines, "eulerians");
 140
 141         Omega = &(((HklParameter *)engine->pseudoAxes[0])->value);
 142         Chi   = &(((HklParameter *)engine->pseudoAxes[1])->value);
 143         Phi   = &(((HklParameter *)engine->pseudoAxes[2])->value);
 144
 145         for(f_idx=0; f_idx<HKL_LIST_LEN(engine->modes); ++f_idx) {
 146                 double omega, chi, phi;
 147                 int res;
 148
 149                 hkl_pseudo_axis_engine_select_mode(engine, f_idx);
 150                 if (f_idx>0)
 151                         engine->mode->parameters[0].value = 1.;
 152
 153                 /* studdy this degenerated case */
 154                 *Omega = omega = 0;
 155                 *Chi = chi = 90 * HKL_DEGTORAD;
 156                 *Phi = phi = 0;
 157
 158                 /* pseudo -> geometry */
 159                 res = hkl_pseudo_axis_engine_set(engine, NULL);
 160                 /* hkl_pseudo_axis_engine_fprintf(stdout, engine); */
 161
 162                 /* geometry -> pseudo */
 163                 if (res == HKL_SUCCESS) {
 164                         HKL_ASSERT_EQUAL(2, hkl_geometry_list_len(engines->geometries));
 165
 166                         /* first solution = 0, 90, 0 */
 167                         hkl_geometry_init_geometry(geom,
 168                                                    engines->geometries->items[1]->geometry);
 169                         hkl_pseudo_axis_engine_get(engine, NULL);
 170                         HKL_ASSERT_DOUBLES_EQUAL(0., *Omega, HKL_EPSILON);
 171                         HKL_ASSERT_DOUBLES_EQUAL(90. * HKL_DEGTORAD, *Chi, HKL_EPSILON);
 172                         HKL_ASSERT_DOUBLES_EQUAL(0. * HKL_DEGTORAD, *Phi, HKL_EPSILON);
 173
 174                         hkl_geometry_init_geometry(geom,
 175                                                    engines->geometries->items[0]->geometry);
 176                         hkl_pseudo_axis_engine_get(engine, NULL);
 177                         HKL_ASSERT_DOUBLES_EQUAL(-180.* HKL_DEGTORAD, *Omega, HKL_EPSILON);
 178                         HKL_ASSERT_DOUBLES_EQUAL(-90. * HKL_DEGTORAD, *Chi, HKL_EPSILON);
 179                         HKL_ASSERT_DOUBLES_EQUAL(180. * HKL_DEGTORAD, *Phi, HKL_EPSILON);
 180                 }
 181         }
 182
 183         hkl_pseudo_axis_engine_list_free(engines);
 184         hkl_detector_free(detector);
 185         hkl_sample_free(sample);
 186         hkl_geometry_free(geom);
 187
 188         return HKL_TEST_PASS;
 189 }
 190
 191 HKL_TEST_SUITE_FUNC(manip)
 192 {
 193         HklPseudoAxisEngineList *engines;
 194         HklPseudoAxisEngine *hkl;
 195         HklPseudoAxisEngine *psi;
 196         const HklGeometryConfig *config;
 197         HklGeometry *geom;
 198         HklDetector *detector;
 199         HklSample *sample;
 200         size_t i, f_idx;
 201         double *H, *K, *L;
 202         double H2, K2, L2;
 203
 204         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
 205         geom = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 206         hkl_source_init(&geom->source, 2.0837, 1., 0., 0.);
 207         hkl_source_fprintf(stdout, &geom->source);
 208
 209         sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
 210         /* hkl_matrix_init_from_euler(&sample->U, -90 * HKL_DEGTORAD, 0., 0.); */
 211         hkl_sample_set_lattice(sample,
 212                                2.88, 2.88, 2.88,
 213                                90*HKL_DEGTORAD, 90*HKL_DEGTORAD, 90*HKL_DEGTORAD);
 214         hkl_matrix_init_from_euler(&sample->U, -90 * HKL_DEGTORAD, 0., 0.);
 215         hkl_sample_fprintf(stdout, sample);
 216
 217         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 218         detector->idx = 1;
 219
 220         engines = hkl_pseudo_axis_engine_list_factory(config);
 221         hkl_pseudo_axis_engine_list_init(engines, geom, detector, sample);
 222
 223         hkl = hkl_pseudo_axis_engine_list_get_by_name(engines, "hkl");
 224         psi = hkl_pseudo_axis_engine_list_get_by_name(engines, "psi");
 225
 226         H = &(((HklParameter *)hkl->pseudoAxes[0])->value);
 227         K = &(((HklParameter *)hkl->pseudoAxes[1])->value);
 228         L = &(((HklParameter *)hkl->pseudoAxes[2])->value);
 229
 230         hkl_pseudo_axis_engine_select_mode(hkl, 9);
 231
 232         *H = 0;
 233         *K = 0;
 234         *L = 1. - 0.047;
 235         H2 = hkl->mode->parameters[0].value = 0;
 236         K2 = hkl->mode->parameters[1].value = 1.;
 237         L2 = hkl->mode->parameters[2].value = 1. - 2*0.047;
 238         if( HKL_SUCCESS == hkl_pseudo_axis_engine_set(hkl, NULL)){
 239                 for(i=0; i<hkl_geometry_list_len(engines->geometries); ++i) {
 240                         *H = *K = *L = 0;
 241
 242                         hkl_geometry_init_geometry(geom,
 243                                                    engines->geometries->items[i]->geometry);
 244                         hkl_pseudo_axis_engine_initialize(psi, NULL);
 245                         hkl_pseudo_axis_engine_list_get(engines);
 246                         hkl_pseudo_axis_engine_list_fprintf(stdout, engines);
 247                 }
 248         }
 249
 250         hkl_geometry_init_geometry(geom,
 251                                    engines->geometries->items[0]->geometry);
 252         hkl_pseudo_axis_engine_select_mode(hkl, 7);
 253         *H = H2;
 254         *K = K2;
 255         *L = L2;
 256         fprintf(stdout, "coucou\n");
 257         if (HKL_SUCCESS == hkl_pseudo_axis_engine_set(hkl, NULL)){
 258                 fprintf(stdout, "coucou\n");
 259                 for(i=0; i<hkl_geometry_list_len(engines->geometries); ++i){
 260                         *H = *K = *L = 0;
 261                         hkl_geometry_init_geometry(geom,
 262                                                    engines->geometries->items[i]->geometry);
 263                         hkl_pseudo_axis_engine_list_get(engines);
 264                         hkl_pseudo_axis_engine_list_fprintf(stdout, engines);
 265                 }
 266         }
 267         hkl_pseudo_axis_engine_list_free(engines);
 268         hkl_detector_free(detector);
 269         hkl_sample_free(sample);
 270         hkl_geometry_free(geom);
 271
 272         return HKL_TEST_PASS;
 273 }
 274
 275 HKL_TEST_SUITE_FUNC(q2)
 276 {
 277         HklPseudoAxisEngineList *engines;
 278         HklPseudoAxisEngine *engine;
 279         const HklGeometryConfig *config;
 280         HklGeometry *geom;
 281         HklDetector *detector;
 282         HklSample *sample;
 283         size_t i, f_idx;
 284         double *Q, *Alpha;
 285
 286         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
 287         geom = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 288         sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
 289
 290         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 291         detector->idx = 1;
 292
 293         engines = hkl_pseudo_axis_engine_list_factory(config);
 294         hkl_pseudo_axis_engine_list_init(engines, geom, detector, sample);
 295
 296         engine = hkl_pseudo_axis_engine_list_get_by_name(engines, "q2");
 297
 298         Q = &(((HklParameter *)engine->pseudoAxes[0])->value);
 299         Alpha = &(((HklParameter *)engine->pseudoAxes[1])->value);
 300
 301         /* the init part */
 302         SET_AXES(geom, 0., 30., 0., 0., 0., 60.);
 303         hkl_pseudo_axis_engine_initialize(engine, NULL);
 304
 305
 306         for(f_idx=0; f_idx<HKL_LIST_LEN(engine->modes); ++f_idx){
 307                 double q, alpha;
 308                 int res;
 309
 310                 hkl_pseudo_axis_engine_select_mode(engine, f_idx);
 311                 for(q=0.1; q<1.; q += 0.1){
 312                         for(alpha = -M_PI; alpha<M_PI; alpha += M_PI/180.){
 313                                 *Q = q;
 314                                 *Alpha = alpha;
 315
 316                                 /* pseudo -> geometry */
 317                                 res = hkl_pseudo_axis_engine_set(engine, NULL);
 318
 319                                 /* geometry -> pseudo */
 320                                 if(res == HKL_SUCCESS){
 321                                         for(i=0; i<hkl_geometry_list_len(engines->geometries); ++i){
 322                                                 *Q = 0;
 323                                                 *Alpha = 0.;
 324
 325                                                 hkl_geometry_init_geometry(geom,
 326                                                                            engines->geometries->items[i]->geometry);
 327                                                 hkl_pseudo_axis_engine_get(engine, NULL);
 328
 329                                                 /* why this precision problem ? */
 330                                                 HKL_ASSERT_DOUBLES_EQUAL(q, *Q, HKL_EPSILON * 10);
 331                                                 HKL_ASSERT_DOUBLES_EQUAL(alpha, *Alpha, HKL_EPSILON);
 332                                         }
 333                                 }
 334                         }
 335                 }
 336         }
 337
 338         hkl_pseudo_axis_engine_list_free(engines);
 339         hkl_detector_free(detector);
 340         hkl_sample_free(sample);
 341         hkl_geometry_free(geom);
 342
 343         return HKL_TEST_PASS;
 344 }
 345
 346
 347 HKL_TEST_SUITE_FUNC(m15110)
 348 {
 349         HklPseudoAxisEngineList *engines;
 350         HklPseudoAxisEngine *engine;
 351         const HklGeometryConfig *config;
 352         HklGeometry *geom;
 353         HklDetector *detector;
 354         HklSample *sample;
 355         int res;
 356
 357         config = hkl_geometry_factory_get_config_from_type(HKL_GEOMETRY_TYPE_KAPPA6C);
 358         geom = hkl_geometry_factory_new(config, 50 * HKL_DEGTORAD);
 359         sample = hkl_sample_new("test", HKL_SAMPLE_TYPE_MONOCRYSTAL);
 360
 361         detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
 362         detector->idx = 1;
 363
 364         engines = hkl_pseudo_axis_engine_list_factory(config);
 365         hkl_pseudo_axis_engine_list_init(engines, geom, detector, sample);
 366
 367         engine = hkl_pseudo_axis_engine_list_get_by_name(engines, "psi");
 368
 369         /* the init part must succed */
 370         SET_AXES(geom, 0., 62.95, 134.75, 0., 0., 60.);
 371         res = hkl_pseudo_axis_engine_initialize(engine, NULL);
 372
 373         HKL_ASSERT_EQUAL(HKL_SUCCESS, res);
 374
 375         hkl_pseudo_axis_engine_list_free(engines);
 376         hkl_detector_free(detector);
 377         hkl_sample_free(sample);
 378         hkl_geometry_free(geom);
 379
 380         return HKL_TEST_PASS;
 381 }
 382
 383 HKL_TEST_SUITE_BEGIN
 384
 385 HKL_TEST( new );
 386 HKL_TEST( degenerated );
 387 HKL_TEST( eulerians );
 388 /* HKL_TEST( manip ); */
 389 HKL_TEST( q2 );
 390 HKL_TEST( m15110 );
 391
 392 HKL_TEST_SUITE_END