1 /* This file is part of the hkl library.
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.
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.
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/>.
16 * Copyright (C) 2003-2015 Synchrotron SOLEIL
17 * L'Orme des Merisiers Saint-Aubin
18 * BP 48 91192 GIF-sur-YVETTE CEDEX
20 * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
21 * Jens Krüger <Jens.Krueger@frm2.tum.de>
23 #include <gsl/gsl_sf_trig.h> // for gsl_sf_angle_restrict_symm
24 #include <math.h> // for sin, asin, M_PI_2, tan, etc
25 #include <stdlib.h> // for free
26 #include <sys/types.h> // for uint
27 #include "hkl-geometry-private.h"
28 #include "hkl-macros-private.h" // for HKL_MALLOC
29 #include "hkl-parameter-private.h" // for _HklParameter, etc
30 #include "hkl-pseudoaxis-common-eulerians-private.h"
31 #include "hkl-pseudoaxis-private.h" // for _HklPseudoAxis, etc
32 #include "hkl.h" // for HklParameter, HklPseudoAxis, etc
33 #include "hkl/ccan/array_size/array_size.h" // for ARRAY_SIZE
34 #include "hkl/ccan/container_of/container_of.h" // for container_of
35 #include "hkl/ccan/darray/darray.h" // for darray_item
37 #define HKL_MODE_EULERIANS_ERROR hkl_mode_eulerians_error_quark ()
39 static GQuark
hkl_mode_eulerians_error_quark (void)
41 return g_quark_from_static_string ("hkl-mode-eulerians-error-quark");
45 HKL_MODE_EULERIANS_ERROR_SET
, /* can not set the engine */
46 } HklModeEuleriansError
;
48 static int kappa_to_eulerian(const double angles
[],
49 double *omega
, double *chi
, double *phi
,
50 double alpha
, int solution
)
52 const double komega
= angles
[0];
53 const double kappa
= gsl_sf_angle_restrict_symm(angles
[1]);
54 const double kphi
= angles
[2];
55 const double p
= atan(tan(kappa
/2.) * cos(alpha
));
58 *omega
= komega
+ p
- M_PI_2
;
59 *chi
= 2 * asin(sin(kappa
/2.) * sin(alpha
));
60 *phi
= kphi
+ p
+ M_PI_2
;
62 *omega
= komega
+ p
+ M_PI_2
;
63 *chi
= -2 * asin(sin(kappa
/2.) * sin(alpha
));
64 *phi
= kphi
+ p
- M_PI_2
;
70 static int eulerian_to_kappa(const double omega
, const double chi
, const double phi
,
72 double alpha
, double solution
)
75 double *komega
= &angles
[0];
76 double *kappa
= &angles
[1];
77 double *kphi
= &angles
[2];
79 if (fabs(chi
) <= alpha
* 2){
80 const double p
= asin(tan(chi
/2.)/tan(alpha
));
83 *komega
= omega
- p
+ M_PI_2
;
84 *kappa
= 2 * asin(sin(chi
/2.)/sin(alpha
));
85 *kphi
= phi
- p
- M_PI_2
;
87 *komega
= omega
+ p
- M_PI_2
;
88 *kappa
= -2 * asin(sin(chi
/2.)/sin(alpha
));
89 *kphi
= phi
+ p
+ M_PI_2
;
97 void kappa_2_kappap(double komega
, double kappa
, double kphi
, double alpha
,
98 double *komegap
, double *kappap
, double *kphip
)
104 p
= atan(tan(kappa
/2.) * cos(alpha
));
105 omega
= komega
+ p
- M_PI_2
;
106 phi
= kphi
+ p
+ M_PI_2
;
108 *komegap
= gsl_sf_angle_restrict_symm(2*omega
- komega
);
110 *kphip
= gsl_sf_angle_restrict_symm(2*phi
- kphi
);
118 static int hkl_mode_get_eulerians_real(HklMode
*self
,
120 HklGeometry
*geometry
,
121 HklDetector
*detector
,
125 HklEngineEulerians
*eulerians
;
126 const double angles
[] = {
127 hkl_parameter_value_get(
128 hkl_geometry_get_axis_by_name(geometry
, "komega"),
130 hkl_parameter_value_get(
131 hkl_geometry_get_axis_by_name(geometry
, "kappa"),
133 hkl_parameter_value_get(
134 hkl_geometry_get_axis_by_name(geometry
, "kphi"),
139 HklParameter
*parameter
;
141 hkl_geometry_update(geometry
);
143 solution
= darray_item(self
->parameters
, 0)->_value
;
145 eulerians
= container_of(engine
, HklEngineEulerians
, engine
);
146 kappa_to_eulerian(angles
,
147 &eulerians
->omega
->_value
,
148 &eulerians
->chi
->_value
,
149 &eulerians
->phi
->_value
,
150 50 * HKL_DEGTORAD
, solution
);
155 static int hkl_mode_set_eulerians_real(HklMode
*self
,
157 HklGeometry
*geometry
,
158 HklDetector
*detector
,
163 HklEngineEulerians
*engine_eulerians
;
166 solution
= darray_item(self
->parameters
, 0)->_value
;
167 engine_eulerians
= container_of(engine
, HklEngineEulerians
, engine
);
168 if(!eulerian_to_kappa(engine_eulerians
->omega
->_value
,
169 engine_eulerians
->chi
->_value
,
170 engine_eulerians
->phi
->_value
,
171 angles
, 50 * HKL_DEGTORAD
, solution
)){
173 HKL_MODE_EULERIANS_ERROR
,
174 HKL_MODE_EULERIANS_ERROR_SET
,
175 "unreachable solution : 0° < chi < 50°");
178 hkl_engine_add_geometry(engine
, angles
);
184 static HklMode
*mode_eulerians()
187 static const char *axes
[] = {"komega", "kappa", "kphi"};
188 static const HklParameter parameters
[] = {
189 { HKL_PARAMETER_DEFAULTS
,.name
= "solutions", ._value
= 1,
190 .description
= "(0/1) to select the first or second solution",
191 .range
= { .max
= 1 },
194 static const HklModeInfo info
= {
195 HKL_MODE_INFO_WITH_PARAMS("eulerians", axes
, axes
, parameters
),
197 static const HklModeOperations operations
= {
198 HKL_MODE_OPERATIONS_DEFAULTS
,
199 .get
= hkl_mode_get_eulerians_real
,
200 .set
= hkl_mode_set_eulerians_real
,
203 return hkl_mode_new(&info
, &operations
, TRUE
);
210 static void hkl_engine_eulerians_free_real(HklEngine
*base
)
212 HklEngineEulerians
*self
;
214 self
= container_of(base
, HklEngineEulerians
, engine
);
215 hkl_engine_release(&self
->engine
);
219 HklEngine
*hkl_engine_eulerians_new(HklEngineList
*engines
)
221 HklEngineEulerians
*self
;
223 static const HklParameter omega
= {
224 HKL_PARAMETER_DEFAULTS_ANGLE
, .name
= "omega",
225 .description
= "omega equivalent for a four circle eulerian geometry",
227 static const HklParameter chi
= {
228 HKL_PARAMETER_DEFAULTS_ANGLE
, .name
= "chi",
229 .description
= "chi equivalent for a four circle eulerian geometry",
231 static const HklParameter phi
= {
232 HKL_PARAMETER_DEFAULTS_ANGLE
, .name
= "phi",
233 .description
= "phi equivalent for a four circle eulerian geometry",
235 static const HklParameter
*pseudo_axes
[] = {&omega
, &chi
, &phi
};
236 static HklEngineInfo info
= {
237 HKL_ENGINE_INFO("eulerians",
239 HKL_ENGINE_DEPENDENCIES_AXES
),
241 static HklEngineOperations operations
= {
242 HKL_ENGINE_OPERATIONS_DEFAULTS
,
243 .free
=hkl_engine_eulerians_free_real
,
246 self
= HKL_MALLOC(HklEngineEulerians
);
247 hkl_engine_init(&self
->engine
, &info
, &operations
, engines
);
249 /* add the pseudo axes with the new API */
250 self
->omega
= register_pseudo_axis(&self
->engine
, engines
, &omega
);
251 self
->chi
= register_pseudo_axis(&self
->engine
, engines
, &chi
);
252 self
->phi
= register_pseudo_axis(&self
->engine
, engines
, &phi
);
254 /* eulerians [default] */
255 mode
= mode_eulerians();
256 hkl_engine_add_mode(&self
->engine
, mode
);
257 hkl_engine_mode_set(&self
->engine
, mode
);
259 return &self
->engine
;