test/hkl-test-pseudoaxis-E4CV.c

   1 #include <math.h>
   2
   3 #include <hkl/hkl-geometry-factory.h>
   4 #include <hkl/hkl-pseudoaxis-E4CV.h>
   5
   6 #include "hkl-test.h"
   7
   8 #ifdef HKL_TEST_SUITE_NAME
   9 # undef HKL_TEST_SUITE_NAME
  10 #endif
  11 #define HKL_TEST_SUITE_NAME pseudoaxis_E4CV
  12
  13 #define SET_AXES(geometry, a, b, c, d) do{\
  14         HklAxisConfig *Omega = &geometry->axes[0]->config;\
  15         HklAxisConfig *Chi = &geometry->axes[1]->config;\
  16         HklAxisConfig *Phi = &geometry->axes[2]->config;\
  17         HklAxisConfig *Tth = &geometry->axes[3]->config;\
  18         \
  19         Omega->value = a * HKL_DEGTORAD;\
  20         Omega->dirty = 1;\
  21         \
  22         Chi->value = b * HKL_DEGTORAD;\
  23         Chi->dirty = 1;\
  24         \
  25         Phi->value = c * HKL_DEGTORAD;\
  26         Phi->dirty = 1;\
  27         \
  28         Tth->value = d * HKL_DEGTORAD;\
  29         Tth->dirty = 1;\
  30 } while(0)
  31
  32 #define CHECK_PSEUDOAXES(engine, a, b, c) do{\
  33         HklPseudoAxis *H = &engine->pseudoAxes[0];\
  34         HklPseudoAxis *K = &engine->pseudoAxes[1];\
  35         HklPseudoAxis *L = &engine->pseudoAxes[2];\
  36         \
  37         HKL_ASSERT_DOUBLES_EQUAL(a, H->config.value, HKL_EPSILON);\
  38         HKL_ASSERT_DOUBLES_EQUAL(b, K->config.value, HKL_EPSILON);\
  39         HKL_ASSERT_DOUBLES_EQUAL(c, L->config.value, HKL_EPSILON);\
  40 } while(0)
  41
  42 HKL_TEST_SUITE_FUNC(new)
  43 {
  44         HklPseudoAxisEngine *engine = hkl_pseudoAxisEngine_new_E4CV_HKL();
  45         hkl_pseudoAxisEngine_free(engine);
  46
  47         return HKL_TEST_PASS;
  48 }
  49
  50 HKL_TEST_SUITE_FUNC(update)
  51 {
  52         HklPseudoAxisEngine *engine;
  53         HklGeometry *geom;
  54         HklDetector det = {1};
  55         HklSample *sample;
  56
  57         geom = hkl_geometry_factory_new(HKL_GEOMETRY_EULERIAN4C_VERTICAL);
  58         sample = hkl_sample_new("test", HKL_SAMPLE_MONOCRYSTAL);
  59
  60         engine = hkl_pseudoAxisEngine_new_E4CV_HKL();
  61         hkl_pseudoAxisEngine_set(engine, 0, geom, &det, sample);
  62
  63         // geometry -> pseudo
  64         SET_AXES(engine->geometry, 30., 0., 0., 60.);
  65         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
  66         CHECK_PSEUDOAXES(engine, 0., 0., 1.);
  67
  68         SET_AXES(engine->geometry, 30., 0., 90., 60.);
  69         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
  70         CHECK_PSEUDOAXES(engine, 1., 0., 0.);
  71
  72         SET_AXES(engine->geometry, 30, 0., -90., 60.);
  73         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
  74         CHECK_PSEUDOAXES(engine, -1., 0., 0.);
  75
  76         SET_AXES(engine->geometry, 30., 0., 180., 60.);
  77         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
  78         CHECK_PSEUDOAXES(engine, 0., 0., -1.);
  79
  80         SET_AXES(engine->geometry, 45., 0., 135., 90.);
  81         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
  82         CHECK_PSEUDOAXES(engine, 1., 0., -1.);
  83
  84         hkl_pseudoAxisEngine_free(engine);
  85         hkl_sample_free(sample);
  86         hkl_geometry_free(geom);
  87
  88         return HKL_TEST_PASS;
  89 }
  90
  91 HKL_TEST_SUITE_FUNC(set)
  92 {
  93         HklPseudoAxisEngine *engine = NULL;
  94         HklGeometry *geom;
  95         HklDetector det = {1};
  96         HklSample *sample;
  97         size_t i, j, f_idx;
  98         double *H, *K, *L;
  99         int miss = 0;
 100
 101         geom = hkl_geometry_factory_new(HKL_GEOMETRY_EULERIAN4C_VERTICAL);
 102         sample = hkl_sample_new("test", HKL_SAMPLE_MONOCRYSTAL);
 103
 104         engine = hkl_pseudoAxisEngine_new_E4CV_HKL();
 105
 106         H = &engine->pseudoAxes[0].config.value;
 107         K = &engine->pseudoAxes[1].config.value;
 108         L = &engine->pseudoAxes[2].config.value;
 109
 110         for(f_idx=0; f_idx<engine->config.functions_len; ++f_idx) {
 111                 hkl_pseudoAxisEngine_set(engine, f_idx, geom, &det, sample);
 112                 if (f_idx>0)
 113                         engine->function->parameters[0].value = 1.;
 114                 for(i=0;i<1000;++i) {
 115                         double h, k, l;
 116                         int res;
 117
 118                         *H = h = (double)rand() / RAND_MAX * 2 - 1.;
 119                         *K = k = (double)rand() / RAND_MAX * 2 - 1.;
 120                         *L = l = (double)rand() / RAND_MAX * 2 - 1.;
 121
 122                         // pseudo -> geometry
 123                         res = hkl_pseudoAxisEngine_to_geometry(engine);
 124                         //hkl_pseudoAxisEngine_fprintf(engine, stdout);
 125
 126                         // geometry -> pseudo
 127                         if (res) {
 128                                 for(j=0; j<engine->geometries_len; ++j) {
 129                                         *H = *K = *L = 0;
 130
 131                                         hkl_geometry_init_geometry(engine->geometry, engine->geometries[j]);
 132                                         hkl_pseudoAxisEngine_to_pseudoAxes(engine);
 133
 134                                         HKL_ASSERT_DOUBLES_EQUAL(h, *H, HKL_EPSILON);
 135                                         HKL_ASSERT_DOUBLES_EQUAL(k, *K, HKL_EPSILON);
 136                                         HKL_ASSERT_DOUBLES_EQUAL(l, *L, HKL_EPSILON);
 137                                 }
 138                         } else
 139                                 miss++;
 140                 }
 141         }
 142         fprintf(stderr, "\nE4CV missed : %d", miss);
 143
 144         hkl_pseudoAxisEngine_free(engine);
 145         hkl_sample_free(sample);
 146         hkl_geometry_free(geom);
 147
 148         return HKL_TEST_PASS;
 149 }
 150
 151 HKL_TEST_SUITE_BEGIN
 152
 153 HKL_TEST( new );
 154 HKL_TEST( update );
 155 HKL_TEST( set );
 156
 157 HKL_TEST_SUITE_END