test/hkl-test-pseudoaxis-K4CV.c

   1 #include <math.h>
   2
   3 #include <hkl/hkl-geometry-factory.h>
   4 #include <hkl/hkl-pseudoaxis-K4CV.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_K4CV
  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_K4CV_HKL();
  45         hkl_pseudoAxisEngine_free(engine);
  46
  47         return HKL_TEST_PASS;
  48 }
  49
  50 HKL_TEST_SUITE_FUNC(set)
  51 {
  52         HklPseudoAxisEngine *engine = NULL;
  53         HklGeometry *geom;
  54         HklDetector det = {1};
  55         HklSample *sample;
  56         size_t i, j, f_idx;
  57         double *H, *K, *L;
  58         int miss = 0;
  59
  60         geom = hkl_geometry_factory_new(HKL_GEOMETRY_KAPPA4C_VERTICAL, 50 * HKL_DEGTORAD);
  61         sample = hkl_sample_new("test", HKL_SAMPLE_MONOCRYSTAL);
  62
  63         engine = hkl_pseudoAxisEngine_new_K4CV_HKL();
  64
  65         H = &engine->pseudoAxes[0].config.value;
  66         K = &engine->pseudoAxes[1].config.value;
  67         L = &engine->pseudoAxes[2].config.value;
  68
  69         for(f_idx=0; f_idx<engine->getsets_len; ++f_idx) {
  70                 hkl_pseudoAxisEngine_select_get_set(engine, f_idx);
  71                 if (f_idx>0)
  72                         engine->getset->parameters[0].value = 1.;
  73                 for(i=0;i<1000;++i) {
  74                         double h, k, l;
  75                         int res;
  76
  77                         *H = h = (double)rand() / RAND_MAX * 2 - 1.;
  78                         *K = k = (double)rand() / RAND_MAX * 2 - 1.;
  79                         *L = l = (double)rand() / RAND_MAX * 2 - 1.;
  80
  81                         // pseudo -> geometry
  82                         res = hkl_pseudoAxisEngine_setter(engine, geom, &det, sample);
  83                         //hkl_pseudoAxisEngine_fprintf(engine, stdout);
  84
  85                         // geometry -> pseudo
  86                         if (res) {
  87                                 for(j=0; j<engine->geometries_len; ++j) {
  88                                         *H = *K = *L = 0;
  89
  90                                         hkl_geometry_init_geometry(engine->geometry, engine->geometries[j]);
  91                                         hkl_pseudoAxisEngine_getter(engine, engine->geometry, &det, sample);
  92
  93                                         HKL_ASSERT_DOUBLES_EQUAL(h, *H, HKL_EPSILON);
  94                                         HKL_ASSERT_DOUBLES_EQUAL(k, *K, HKL_EPSILON);
  95                                         HKL_ASSERT_DOUBLES_EQUAL(l, *L, HKL_EPSILON);
  96                                 }
  97                         } else
  98                                 miss++;
  99                 }
 100         }
 101         fprintf(stderr, "\nK4CV missed : %d", miss);
 102
 103         hkl_pseudoAxisEngine_free(engine);
 104         hkl_sample_free(sample);
 105         hkl_geometry_free(geom);
 106
 107         return HKL_TEST_PASS;
 108 }
 109
 110 HKL_TEST_SUITE_FUNC(degenerated)
 111 {
 112         HklPseudoAxisEngine *engine = NULL;
 113         HklGeometry *geom;
 114         HklDetector det = {1};
 115         HklSample *sample;
 116         size_t i, f_idx;
 117         double *H, *K, *L;
 118
 119         geom = hkl_geometry_factory_new(HKL_GEOMETRY_KAPPA4C_VERTICAL, 50 * HKL_DEGTORAD);
 120         sample = hkl_sample_new("test", HKL_SAMPLE_MONOCRYSTAL);
 121
 122         engine = hkl_pseudoAxisEngine_new_K4CV_HKL();
 123
 124         H = &engine->pseudoAxes[0].config.value;
 125         K = &engine->pseudoAxes[1].config.value;
 126         L = &engine->pseudoAxes[2].config.value;
 127
 128         for(f_idx=0; f_idx<engine->getsets_len; ++f_idx) {
 129                 hkl_pseudoAxisEngine_select_get_set(engine, f_idx);
 130                 if (f_idx>0)
 131                         engine->getset->parameters[0].value = 1.;
 132
 133                 double h, k, l;
 134                 int res;
 135
 136                 /* studdy this degenerated case */
 137                 *H = h = 0;
 138                 *K = k = 1;
 139                 *L = l = 0;
 140
 141                 // pseudo -> geometry
 142                 res = hkl_pseudoAxisEngine_setter(engine, geom, &det, sample);
 143                 //hkl_pseudoAxisEngine_fprintf(engine, stdout);
 144
 145                 // geometry -> pseudo
 146                 if (res) {
 147                         for(i=0; i<engine->geometries_len; ++i) {
 148                                 *H = *K = *L = 0;
 149
 150                                 hkl_geometry_init_geometry(engine->geometry, engine->geometries[i]);
 151                                 hkl_pseudoAxisEngine_getter(engine, engine->geometry, &det, sample);
 152
 153                                 HKL_ASSERT_DOUBLES_EQUAL(h, *H, HKL_EPSILON);
 154                                 HKL_ASSERT_DOUBLES_EQUAL(k, *K, HKL_EPSILON);
 155                                 HKL_ASSERT_DOUBLES_EQUAL(l, *L, HKL_EPSILON);
 156                         }
 157                 }
 158         }
 159
 160         hkl_pseudoAxisEngine_free(engine);
 161         hkl_sample_free(sample);
 162         hkl_geometry_free(geom);
 163
 164         return HKL_TEST_PASS;
 165 }
 166
 167 HKL_TEST_SUITE_BEGIN
 168
 169 HKL_TEST( new );
 170 HKL_TEST( set );
 171 HKL_TEST( degenerated );
 172
 173 HKL_TEST_SUITE_END