?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* rename PseudoAxesAdapter::update_state_and_status_i -> update
[diffractometer.git] / src / TangoHKLAdapter.cpp
blob6fe4ec40bbdc51d2ba8c935114aebcd148f062ef
1 #if ( _MSC_VER && _MSC_VER <= 1200 )
2 // Ce pragma ne devrait pas etre dans ce fichier car le warning ne s'affiche
3 // que si l'on compile une version DEBUG de la librairie.
4 // Il faut utiliser l'option de compilation \wd4786 mais elle n'est presente
5 // qu'à partir de VC++7
6 # pragma warning (disable : 4786)
7 #endif
8
9 #include <iomanip>
10
11 #include <hkl/hkl-pseudoaxis.h>
12
13 #include "macros.h"
14 #include "TangoHKLAdapter.h"
15 #include "Diffractometer.h"
16 #include "PseudoAxes.h"
17 #include "AxisAdapter.h"
18 #include "AxisAttrib.h"
19 #include "PseudoAxesAttrib.h"
20
21 //#define DEBUG
22 #ifndef NDEBUG
23 # define STDOUT(stream) std::cout << stream
24 #else
25 # define STDOUT(stream) {};
26 #endif
27
28 namespace Diffractometer_ns
29 {
30 //+----------------------------------------------------------------------------
31 //
32 // method : TangoHKLAdapter::TangoHKLAdapter(string &s)
33 //
34 // description : constructor for the adapter between HKl library and Tango
35 //
36 // in : - type : Type of diffractometer to instancate
37 //
38 //-----------------------------------------------------------------------------
39 TangoHKLAdapter::TangoHKLAdapter(Diffractometer *device, HklGeometryType type) :
40 _device(device),
41 _type(type)
42 {
43 size_t i, len;
44 HklAxis *axes_r;
45 HklAxis *axes_w;
46 HklAxis *axes_r_real;
47 HklAxis *axes_w_real;
48
49 this->ready = false;
50 _auto_update_from_proxies = false;
51 _lambdaAttributeProxy = NULL;
52 _wrong_nb_of_axis_proxies = false;
53 _ux = 0;
54 _uy = 0;
55 _uz = 0;
56 _uxfit = true;
57 _uyfit = true;
58 _uzfit = true;
59 _angles_idx = 0;
60
61 duration.Start();
62
63 // Create the hkl part
64 // 4 geometries
65 _diffractometer = new HklDiffractometer;
66 _diffractometer->geometry_r = hkl_geometry_factory_new(type, 50 * HKL_DEGTORAD);
67 _diffractometer->geometry_w = hkl_geometry_factory_new(type, 50 * HKL_DEGTORAD);
68 _diffractometer->geometry_r_real = hkl_geometry_factory_new(type, 50 * HKL_DEGTORAD);
69 _diffractometer->geometry_w_real = hkl_geometry_factory_new(type, 50 * HKL_DEGTORAD);
70
71 // 2 detectors
72 _diffractometer->detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
73 _diffractometer->detector->idx = 1;
74
75 _diffractometer->detector_real = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
76 _diffractometer->detector_real->idx = 1;
77
78 // 1 sample list
79 _diffractometer->samples = hkl_sample_list_new();
80
81 // the pseudoAxesenginesList (one per geometry)
82 _diffractometer->engines_r = hkl_pseudo_axis_engine_list_factory(type);
83 _diffractometer->engines_w = hkl_pseudo_axis_engine_list_factory(type);
84 _diffractometer->engines_r_real = hkl_pseudo_axis_engine_list_factory(type);
85 _diffractometer->engines_w_real = hkl_pseudo_axis_engine_list_factory(type);
86 this->update_pseudo_axis_engines();
87
88 // Build Group
89 Tango::GroupReply::enable_exception(true);
90
91 // fill the axisAdapter.
92 len = HKL_LIST_LEN(_diffractometer->geometry_r->axes);
93 axes_r = _diffractometer->geometry_r->axes;
94 axes_w = _diffractometer->geometry_w->axes;
95 axes_r_real = _diffractometer->geometry_r_real->axes;
96 axes_w_real = _diffractometer->geometry_w_real->axes;
97 for(i=0; i<len; ++i)
98 _axes.push_back(AxisAdapter(this, &axes_r[i], &axes_w[i], &axes_r_real[i], &axes_w_real[i]));
99
100 // hack to connect all axes the first time
101 _auto_update_from_proxies = true;
102 this->connect_all_proxies();
103 _auto_update_from_proxies = false;
104
105 // fill the pseudoAxesAdapters
106 {
107 omni_mutex_lock lock(_lock);
108
109 len = HKL_LIST_LEN(_diffractometer->engines_r->engines);
110 _pseudo_axes_proxies.resize(len, 1);
111 for(i=0; i<len; ++i){
112 PseudoAxesAdapter *adapter;
113
114 adapter = new PseudoAxesAdapter(this, i);
115 _pseudoAxesAdapters.push_back(adapter);
116 _pseudo_axes_proxies.data[i] = const_cast<char *>(adapter->_proxy_name.c_str());
117 }
118 }
119
120 // create the dynamic attributes
121 this->create_axes_dynamic_attributes();
122
123 // set the default lambda
124 this->set_lambda(1.54);
125 }
126
127 TangoHKLAdapter::~TangoHKLAdapter(void)
128 {
129 unsigned int i;
130
131 this->destroy_axes_dynamic_attributes();
132
133 // remove all pseudo axis adapters
134 for(i=0;i<_pseudoAxisAdapters.size();i++)
135 delete _pseudoAxisAdapters[i];
136
137 // remove all pseudo axes adapters;
138 for(i=0; i<_pseudoAxesAdapters.size(); ++i)
139 delete _pseudoAxesAdapters[i];
140
141 // remove all axisAdapter
142 _axes.clear();
143
144 if (_lambdaAttributeProxy)
145 delete _lambdaAttributeProxy;
146
147 // remove the hkl part
148 hkl_geometry_free(_diffractometer->geometry_r);
149 hkl_geometry_free(_diffractometer->geometry_w);
150 hkl_geometry_free(_diffractometer->geometry_r_real);
151 hkl_geometry_free(_diffractometer->geometry_w_real);
152 hkl_detector_free(_diffractometer->detector);
153 hkl_detector_free(_diffractometer->detector_real);
154 hkl_sample_list_free(_diffractometer->samples);
155 hkl_pseudo_axis_engine_list_free(_diffractometer->engines_r);
156 hkl_pseudo_axis_engine_list_free(_diffractometer->engines_w);
157 hkl_pseudo_axis_engine_list_free(_diffractometer->engines_r_real);
158 hkl_pseudo_axis_engine_list_free(_diffractometer->engines_w_real);
159
160 if(_diffractometer) {
161 delete _diffractometer;
162 _diffractometer = NULL;
163 }
164 }
165
166 void TangoHKLAdapter::connect_all_proxies(void)
167 {
168 omni_mutex_lock lock(_lock);
169
170 // connect the lambda proxy
171 if ((!_lambdaAttributeProxy && _auto_update_from_proxies)
172 && _device->lambdaAttributeProxy != "") {
173 try
174 {
175 _lambdaAttributeProxy = new Tango::AttributeProxy(_device->lambdaAttributeProxy);
176 }
177 catch(...) {
178 }
179 }
180
181 // connect the axes proxies
182 if (!this->ready && _auto_update_from_proxies) {
183 unsigned int nb;
184
185 nb = _device->realAxisProxies.size();
186 if (nb != _axes.size()) {
187 _wrong_nb_of_axis_proxies = true;
188 return;
189 } else {
190 unsigned int i, j;
191 bool ready = true;
192
193 for(i=0; i<nb; ++i) {
194 AxisAdapter & axis = _axes[i];
195 if (!axis.is_ready()){
196 // Find axis in the proxy list
197 for(j=0; j<nb; ++j) {
198 char *line = strdup(_device->realAxisProxies[j].c_str());
199 char *last;
200 char *axis_name = strtok_r(line, ":", &last);
201 char *proxy_name = strtok_r(NULL, ":", &last);
202 if (axis.get_name() == axis_name)
203 axis.connect(proxy_name);
204 free(line);
205 }
206 if (!axis.is_ready())
207 ready = false;
208 }
209 }
210 this->ready = ready;
211 }
212 }
213 }
214
215 void TangoHKLAdapter::set_lambda(double lambda)
216 {
217 omni_mutex_lock lock(_lock);
218
219 if ((!_auto_update_from_proxies || _device->lambdaAttributeProxy == "")
220 && lambda > 0){
221 _lambda = lambda;
222 _diffractometer->geometry_r->source.wave_length = lambda;
223 _diffractometer->geometry_w->source.wave_length = lambda;
224 _diffractometer->geometry_r_real->source.wave_length = lambda;
225 _diffractometer->geometry_w_real->source.wave_length = lambda;
226 }
227 }
228
229 // this method connect engines to the right geometry, detector and sample
230 void TangoHKLAdapter::update_pseudo_axis_engines(void)
231 {
232 hkl_pseudo_axis_engine_list_init(_diffractometer->engines_r,
233 _diffractometer->geometry_r,
234 _diffractometer->detector,
235 _diffractometer->samples->current);
236
237 hkl_pseudo_axis_engine_list_init(_diffractometer->engines_w,
238 _diffractometer->geometry_w,
239 _diffractometer->detector,
240 _diffractometer->samples->current);
241
242 hkl_pseudo_axis_engine_list_init(_diffractometer->engines_r_real,
243 _diffractometer->geometry_r_real,
244 _diffractometer->detector,
245 _diffractometer->samples->current);
246
247 hkl_pseudo_axis_engine_list_init(_diffractometer->engines_w_real,
248 _diffractometer->geometry_w_real,
249 _diffractometer->detector,
250 _diffractometer->samples->current);
251 }
252
253 void TangoHKLAdapter::update_lambda(void)
254 {
255 if (_lambdaAttributeProxy && _auto_update_from_proxies){
256 try{
257 _lambdaAttributeProxy->read() >> _lambda;
258 _diffractometer->geometry_r->source.wave_length = _lambda;
259 _diffractometer->geometry_w->source.wave_length = _lambda;
260 _diffractometer->geometry_r_real->source.wave_length = _lambda;
261 _diffractometer->geometry_w_real->source.wave_length = _lambda;
262 }
263 catch (Tango::DevFailed &){
264 }
265 }else
266 _lambda = _diffractometer->geometry_r->source.wave_length;
267 }
268
269 /**
270 * this method update the angles attribut from the engines->geometry list
271 */
272 void TangoHKLAdapter::update_angles(void)
273 {
274 size_t i, j;
275 size_t xdim;
276 size_t ydim;
277 HklPseudoAxisEngine *engine;
278 double *data;
279 HklGeometry **geometries;
280
281 if(!_auto_update_from_proxies)
282 engine = hkl_pseudo_axis_engine_list_get_by_name(_diffractometer->engines_w, "hkl");
283 else
284 engine = hkl_pseudo_axis_engine_list_get_by_name(_diffractometer->engines_w_real, "hkl");
285
286 // update the computed_angles part
287 xdim = 1 + HKL_LIST_LEN(_diffractometer->geometry_r->axes);
288 ydim = HKL_LIST_LEN(engine->engines->geometries->geometries);
289
290 _angles.resize(xdim, ydim);
291 _angles.clear();
292
293 //fill the array
294 data = _angles.data;
295 geometries = engine->engines->geometries->geometries;
296 for(j=0; j<ydim; ++j){
297 HklGeometry *geom = geometries[j];
298
299 data[0] = j;
300 for(i=1; i<xdim; ++i)
301 data[i] = hkl_axis_get_value_unit(&geom->axes[i-1]);
302 data += xdim;
303 }
304 }
305
306 /**
307 * this method update the reflections_angles when we change a sample parameter
308 */
309 void TangoHKLAdapter::update_reflections_angles(void)
310 {
311 HklSample *sample = _diffractometer->samples->current;
312 if (sample) {
313 unsigned int i, j;
314 size_t rdim;
315 double *data;
316
317 // the reflection Angles
318 rdim = HKL_LIST_LEN(sample->reflections);
319 _reflections_angles.resize(rdim, rdim);
320 _reflections_angles.clear();
321
322 data = _reflections_angles.data;
323 for(i=0; i<rdim; ++i) {
324 for(j=0; j<rdim; ++j) {
325 double angle = 0.;
326 if (j < i)
327 angle = hkl_sample_get_reflection_theoretical_angle(sample, i, j);
328 else if (j > i)
329 angle = hkl_sample_get_reflection_mesured_angle(sample, i, j);
330
331 *data = angle * HKL_RADTODEG;
332 data++;
333 }
334 }
335 }
336 }
337
338 void TangoHKLAdapter::update_reflections(void)
339 {
340 HklSample *sample = _diffractometer->samples->current;
341 if (sample) {
342
343 // Allocation of the image
344 unsigned int xdim = 6 + HKL_LIST_LEN(_diffractometer->geometry_r->axes);
345 unsigned int ydim = HKL_LIST_LEN(sample->reflections);
346 _reflections.resize(xdim, ydim);
347
348 size_t i = 0;
349 double *data = _reflections.data;
350 for(i=0; i<ydim; ++i) {
351 HklSampleReflection *r;
352
353 r = hkl_sample_get_ith_reflection(sample, i);
354 if (r) {
355 size_t k;
356 HklAxis *axes = r->geometry->axes;
357
358 data[0] = i;
359 data[1] = r->hkl.data[0];
360 data[2] = r->hkl.data[1];
361 data[3] = r->hkl.data[2];
362 data[4] = 0;
363 data[5] = (double)r->flag;
364
365 for(k=0; k<HKL_LIST_LEN(r->geometry->axes); ++k)
366 data[6 + k] = hkl_axis_get_value_unit(&axes[k]);
367 }
368 data += xdim;
369 }
370 }
371 }
372
373 void TangoHKLAdapter::update_ub(void)
374 {
375 HklSample const *sample = _diffractometer->samples->current;
376 if(sample){
377 size_t dim = 3;
378 _ub.resize(dim, dim);
379 _ub.set_data_from_buffer(&(sample->UB.data[0][0]), dim, dim);
380 }
381 }
382
383 void TangoHKLAdapter::update_ux_uy_uz(void)
384 {
385 HklSample *sample = _diffractometer->samples->current;
386
387 if(sample){
388 hkl_matrix_to_euler(&sample->U, &_ux, &_uy, &_uz);
389 _ux *= HKL_RADTODEG;
390 _uy *= HKL_RADTODEG;
391 _uz *= HKL_RADTODEG;
392 }
393 }
394
395 /**
396 * this method update all the AxisAdapter from the proxy every 200 ms.
397 * this from_proxy get the real part from the proxy and the "sim" part
398 * from the HklAxis in simulated mode or from the proxy in real mode
399 * else it updates them from the HklAxis.
400 *
401 * every 200 ms
402 * simulated:
403 * real <- proxy
404 * sim <- HklAxis
405 * non simulated:
406 * real <- proxy
407 * sim <- proxy
408 * rest of the time
409 * real <- HklAxis
410 * simulated -> HklAxis
411 */
412 void TangoHKLAdapter::update_axis_adapters(void)
413 {
414 size_t i;
415
416 // first read from the proxy.
417 duration.Stop();
418 if(duration.GetDurationInMs() >= 200) {
419 for(size_t i=0; i<_axes.size(); ++i)
420 _axes[i].from_proxy(!_auto_update_from_proxies);
421 duration.Start();
422 }else
423 for(i=0; i<_axes.size(); ++i)
424 _axes[i].from_HklAxis();
425 }
426
427 void TangoHKLAdapter::update_hkl_from_axis_adapters(void)
428 {
429 size_t i;
430
431 // set the axis
432 for(i=0; i<_axes.size(); ++i)
433 _axes[i].to_HklAxis();
434
435 // update the pseudo axes
436 if(_diffractometer && _diffractometer->samples){
437 hkl_pseudo_axis_engine_list_get(_diffractometer->engines_r);
438 hkl_pseudo_axis_engine_list_get(_diffractometer->engines_w);
439 hkl_pseudo_axis_engine_list_get(_diffractometer->engines_r_real);
440 hkl_pseudo_axis_engine_list_get(_diffractometer->engines_w_real);
441 }
442 }
443
444 void TangoHKLAdapter::update_pseudo_axis_adapters_from_hkl(void)
445 {
446 for(size_t i=0;i<_pseudoAxisAdapters.size();++i)
447 _pseudoAxisAdapters[i]->update();
448 }
449
450 void TangoHKLAdapter::update_proxies_from_axis_adapters(void)
451 {
452 size_t i;
453
454 // first stop motion of all axes.
455 for(i=0; i<_axes.size(); ++i)
456 _axes[i].stop();
457
458 // then send write values to the proxies
459 for(i=0; i<_axes.size(); ++i)
460 _axes[i].to_proxy();
461 }
462
463 void TangoHKLAdapter::update_proxies_from_pseudo_axis_adapters(PseudoAxisAdapter *adapter)
464 {
465 adapter->to_proxies();
466 }
467
468 void TangoHKLAdapter::update_pseudo_axes_adapters_from_hkl(void)
469 {
470 size_t i, j, len;
471 HklPseudoAxisEngine *engine_r, *engine_w;
472
473 for(i=0; i<_pseudoAxesAdapters.size(); ++i){
474 PseudoAxesAdapter *adapter;
475
476 adapter = _pseudoAxesAdapters[i];
477 engine_r = _diffractometer->engines_r->engines[i];
478 engine_w = _diffractometer->engines_w->engines[i];
479 len = HKL_LIST_LEN(engine_r->pseudoAxes);
480 for(j=0; j<len; ++j){
481 adapter->_read.data[j] = hkl_parameter_get_value_unit((HklParameter *)engine_r->pseudoAxes[j]);
482 adapter->_write.data[j] = hkl_parameter_get_value_unit((HklParameter *)engine_w->pseudoAxes[j]);
483
484 }
485 adapter->update();
486 }
487 }
488
489 void TangoHKLAdapter::update_state_and_status(void)
490 {
491 Tango::DevState state;
492 std::string status;
493 std::string extra_status;
494
495 state = Tango::STANDBY;
496 if (!_auto_update_from_proxies)
497 status = "AutoUpdateFromProxies OFF";
498 else {
499 status = "AutoUpdateFromProxies ON";
500
501 if (!this->ready) {
502 state = Tango::FAULT;
503 extra_status += "\nCan not connect to axes proxies";
504 // update the monochromator proxy status.
505 if (!_lambdaAttributeProxy && _auto_update_from_proxies) {
506 extra_status += "\nCan not connect to the lambdaAttributeProxy";
507 extra_status += "\nCheck also the lambdaAttributeProxy property";
508 }
509 } else {
510 try {
511 for(unsigned int i=0; i<_axes.size(); ++i) {
512 AxisAdapter const & axis = _axes[i];
513 std::string proxy_name = axis.get_proxy_name();
514 Tango::DevState tmpState = axis.get_state();
515
516 ::compose_state(state, tmpState);
517 if (tmpState != Tango::STANDBY)
518 extra_status += "\n" + proxy_name + " is in " + Tango::DevStateName[tmpState];
519 }
520 } catch(...)
521 {
522 state = Tango::FAULT;
523 extra_status += "\nCan not connect to axes proxies";
524 }
525
526 }
527 }
528
529 if (_diffractometer){
530 status += "\nSample: ";
531 if(!_diffractometer->samples->current){
532 status += "Not yet Set";
533 state = Tango::FAULT;
534 } else
535 status += _diffractometer->samples->current->name;
536 if (state == Tango::STANDBY)
537 extra_status += "\nready to compute hkl";
538 }else{
539 state = Tango::FAULT;
540 extra_status += "\nhkl core not yet initialized !!!";
541 }
542 status += "\nDiffractometer status: ";
543 status += Tango::DevStateName[state];
544 status += extra_status;
545
546 _diffractometerConfig.state = state;
547 _diffractometerConfig.status = status;
548 }
549
550 void TangoHKLAdapter::update(void)
551 {
552 /**********************************************
553 * CRITICAL SECTION
554 **********************************************/
555 omni_mutex_lock lock(_lock);
556
557 this->update_lambda();
558 this->update_axis_adapters();
559 this->update_hkl_from_axis_adapters();
560 this->update_pseudo_axis_adapters_from_hkl();
561 this->update_pseudo_axes_adapters_from_hkl();
562 this->update_state_and_status();
563 /**********************************************
564 * END OF CRITICAL SECTION
565 **********************************************/
566 }
567
568 /********************/
569 /* State and status */
570 /********************/
571 void TangoHKLAdapter::get_diffractometer_config(DiffractometerConfig & config)
572 {
573 omni_mutex_lock lock(_lock);
574
575 config = _diffractometerConfig;
576 }
577
578 /************/
579 /* hkl part */
580 /************/
581
582 short & TangoHKLAdapter::get_angles_idx(void)
583 {
584 omni_mutex_lock lock(_lock);
585
586 return _angles_idx;
587 }
588
589 void TangoHKLAdapter::set_angles_idx(short idx)
590 {
591 omni_mutex_lock lock(_lock);
592
593 // A REVOIR
594 if(idx >= 0 && idx < (int)_angles.ydim){
595 size_t i;
596 double *values;
597
598 _angles_idx = idx;
599 values = &_angles.data[1 + idx * _angles.xdim];
600 for(i=0; i<_axes.size(); ++i)
601 this->write_axis_i(_axes[i], values[i]);
602 }
603 }
604
605 void TangoHKLAdapter::load(void)
606 {
607 this->load_1();
608 }
609
610 void TangoHKLAdapter::load_1(void)
611 {
612 unsigned long nb_properties;
613
614 // Get the Crystal Attributes properties.
615 Tango::DbData properties;
616 properties.push_back(Tango::DbDatum("Crystal"));
617 _device->get_db_device()->get_attribute_property(properties);
618
619 // the first one is the number of properties
620 properties[0] >> nb_properties;
621
622 if (nb_properties > 1) {
623 unsigned long i, j;
624 HklGeometry *geometry;
625 HklDetector *detector;
626
627 geometry = hkl_geometry_new_copy(_diffractometer->geometry_r);
628 detector = hkl_detector_new_copy(_diffractometer->detector);
629
630 hkl_sample_list_clear(_diffractometer->samples);
631 for(i=1; i<=nb_properties; ++i) {
632 // skip the _ver property
633 if(!strcasecmp("_ver", properties[i].name.c_str()))
634 continue;
635
636 HklSample * sample;
637
638 // The name of the property name is the name of a crystal.
639 sample = hkl_sample_new(properties[i].name.c_str(), HKL_SAMPLE_MONOCRYSTAL);
640
641 // Extract the lines store in the property
642 std::vector<std::string> lines;
643 properties[i] >> lines;
644
645 for(j=0; j<lines.size(); j++) {
646 char *line = strdup(lines[j].c_str());
647 char *last;
648 char *key = strtok_r(line, "=", &last);
649
650 if (!strcmp(key,"lattice")) {
651 double a = atof(strtok_r(NULL, ";", &last));
652 double b = atof(strtok_r(NULL, ";", &last));
653 double c = atof(strtok_r(NULL, ";", &last));
654 double alpha = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
655 double beta = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
656 double gamma = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
657 hkl_sample_set_lattice(sample, a, b, c, alpha, beta, gamma);
658
659 sample->lattice->a->fit = atoi(strtok_r(NULL, ";", &last));
660 sample->lattice->b->fit = atoi(strtok_r(NULL, ";", &last));
661 sample->lattice->c->fit = atoi(strtok_r(NULL, ";", &last));
662 sample->lattice->alpha->fit = atoi(strtok_r(NULL, ";", &last));
663 sample->lattice->beta->fit = atoi(strtok_r(NULL, ";", &last));
664 sample->lattice->gamma->fit = atoi(strtok_r(NULL, ";", &last));
665 } else if (!strcmp(key, "uxuyuz")){
666 double ux = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
667 double uy = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
668 double uz = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
669 hkl_sample_set_U_from_euler(sample, ux, uy, uz);
670 } else if (!strcmp(key,"reflection")) {
671 unsigned int idx = 0;
672 HklSampleReflection *reflection;
673
674 double wavelength = atof(strtok_r(NULL, ";", &last));
675 double h = atof(strtok_r(NULL, ";", &last));
676 double k = atof(strtok_r(NULL, ";", &last));
677 double l = atof(strtok_r(NULL, ";", &last));
678 int flag = atoi(strtok_r(NULL, ";", &last));
679
680 // first set the geometry axes
681 while(key = strtok_r(NULL, ";", &last))
682 hkl_axis_set_value_unit(&geometry->axes[idx++], atof(key));
683 geometry->source.wave_length = wavelength;
684
685 reflection = hkl_sample_add_reflection(sample, geometry, detector, h, k, l);
686 reflection->flag = flag;
687 }
688 free(line);
689 // End of key research
690 }// End for each parameters
691 hkl_sample_list_append(_diffractometer->samples, sample);
692 }// End for each property
693
694 hkl_detector_free(detector);
695 hkl_geometry_free(geometry);
696
697 //_device->refresh_crystal_parameters();
698 }
699 }
700
701 void TangoHKLAdapter::save(void)
702 {
703 omni_mutex_lock lock(_lock);
704
705 size_t i, j, k;
706 size_t len;
707 Tango::DbData crystal_prop;
708 Tango::DbData data_put;
709
710 // Step 1 : clean all properties
711 // FP Le mieux serait sans doute de ne pas effacer les propriétés d'attribut
712 // avant d'avoir crée correctement un data_put.
713 crystal_prop.push_back(Tango::DbDatum("Crystal"));
714 _device->get_db_device()->get_attribute_property(crystal_prop);
715 long number_of_prop = 0;
716 crystal_prop[0] >> number_of_prop ;
717 if( number_of_prop > 0)
718 _device->get_db_device()->delete_attribute_property(crystal_prop);
719
720 // Step 2 : create the Crystal properties
721 Tango::DbDatum properties("Crystal");
722 // Put number of properties (= nb of samples + 1)
723 len = hkl_sample_list_len(_diffractometer->samples);
724 properties << (long)(len + 1);
725 data_put.push_back(properties);
726
727 // first property is the format version
728 Tango::DbDatum version("_ver");
729 version << (long)FORMAT_VERSION;
730 data_put.push_back(version);
731
732 // now each sample
733 for(k=0; k<len; ++k){
734 HklSample *sample;
735 std::vector<std::string> lines;
736 char line[256];
737
738 // the lattices values
739 sample = hkl_sample_list_get_ith(_diffractometer->samples, k);
740 double a = hkl_parameter_get_value_unit(sample->lattice->a);
741 double b = hkl_parameter_get_value_unit(sample->lattice->b);
742 double c = hkl_parameter_get_value_unit(sample->lattice->c);
743 double alpha = hkl_parameter_get_value_unit(sample->lattice->alpha);
744 double beta = hkl_parameter_get_value_unit(sample->lattice->beta);
745 double gamma = hkl_parameter_get_value_unit(sample->lattice->gamma);
746 // the fit flag
747 int a_fit = sample->lattice->a->fit;
748 int b_fit = sample->lattice->b->fit;
749 int c_fit = sample->lattice->c->fit;
750 int alpha_fit = sample->lattice->alpha->fit;
751 int beta_fit = sample->lattice->beta->fit;
752 int gamma_fit = sample->lattice->gamma->fit;
753
754 snprintf(line, 255, "lattice=%f;%f;%f;%f;%f;%f;%d;%d;%d;%d;%d;%d",
755 a, b, c, alpha, beta, gamma,
756 a_fit, b_fit, c_fit, alpha_fit, beta_fit, gamma_fit);
757 lines.push_back(line);
758
759 // the UxUyUz parameters
760 double ux, uy, uz;
761 hkl_matrix_to_euler(&sample->U, &ux, &uy, &uz);
762 ux *= HKL_RADTODEG;
763 uy *= HKL_RADTODEG;
764 uz *= HKL_RADTODEG;
765
766 snprintf(line, 255, "uxuyuz=%f;%f;%f", ux, uy, uz);
767 lines.push_back(line);
768
769 // the reflections
770 for(i=0; i<HKL_LIST_LEN(sample->reflections); ++i) {
771 HklSampleReflection *reflection;
772
773 reflection = hkl_sample_get_ith_reflection(sample, i);
774 double wavelength = reflection->geometry->source.wave_length;
775 double h = reflection->hkl.data[0];
776 double k = reflection->hkl.data[1];
777 double l = reflection->hkl.data[2];
778 int flag = reflection->flag;
779
780 snprintf(line, 255, "reflection=%f;%f;%f;%f;%d",
781 wavelength, h, k, l, flag);
782 // Extract values of each axes
783 for(j=0; j<HKL_LIST_LEN(reflection->geometry->axes); ++j) {
784 char pos[256];
785 double rad = hkl_axis_get_value_unit(&reflection->geometry->axes[j]);
786 snprintf(pos, 255, ";%f", rad);
787 strncat(line, pos, 255);
788 }
789 lines.push_back(line);
790 }
791
792 // Try to create property
793 // Get crystal name
794 Tango::DbDatum property(sample->name);
795 property << lines;
796 data_put.push_back(property);
797 }
798
799 //update database for this property
800 _device->get_db_device()->put_attribute_property(data_put);
801 }
802
803 /***************/
804 /* sample part */
805 /***************/
806
807 char const *TangoHKLAdapter::get_sample_name(void)
808 {
809 omni_mutex_lock lock(_lock);
810
811 HklSample *sample = _diffractometer->samples->current;
812 if(sample)
813 return sample->name;
814 else
815 return "";
816 }
817
818 void TangoHKLAdapter::set_current_sample(char const * name)
819 {
820 omni_mutex_lock lock(_lock);
821
822 HklSample *last;
823
824 last = _diffractometer->samples->current;
825 if (HKL_SUCCESS == hkl_sample_list_select_current(_diffractometer->samples, name))
826 if (last != _diffractometer->samples->current){
827 this->update_pseudo_axis_engines();
828 this->update_ub();
829 this->update_ux_uy_uz();
830 this->update_reflections_angles();
831 this->update_reflections();
832 this->update_state_and_status();
833 }
834 }
835
836 void TangoHKLAdapter::get_sample_lattices(double *a, double *b, double *c,
837 double *alpha, double *beta, double *gamma,
838 double *a_star, double *b_star, double *c_star,
839 double *alpha_star, double *beta_star, double *gamma_star)
840 {
841 omni_mutex_lock lock(_lock);
842
843 HklSample * sample = _diffractometer->samples->current;
844 if (!sample)
845 return;
846
847 HklLattice const *lattice = sample->lattice;
848 HklLattice *reciprocal = hkl_lattice_new_copy(lattice);
849
850 hkl_lattice_reciprocal(lattice, reciprocal);
851
852 // direct space
853 *a = hkl_parameter_get_value_unit(lattice->a);
854 *b = hkl_parameter_get_value_unit(lattice->b);
855 *c = hkl_parameter_get_value_unit(lattice->c);
856 *alpha = hkl_parameter_get_value_unit(lattice->alpha);
857 *beta = hkl_parameter_get_value_unit(lattice->beta);
858 *gamma = hkl_parameter_get_value_unit(lattice->gamma);
859
860 // reciprocal space
861 *a_star = hkl_parameter_get_value_unit(reciprocal->a);
862 *b_star = hkl_parameter_get_value_unit(reciprocal->b);
863 *c_star = hkl_parameter_get_value_unit(reciprocal->c);
864 *alpha_star = hkl_parameter_get_value_unit(reciprocal->alpha);
865 *beta_star = hkl_parameter_get_value_unit(reciprocal->beta);
866 *gamma_star = hkl_parameter_get_value_unit(reciprocal->gamma);
867
868 hkl_lattice_free(reciprocal);
869 }
870
871 void TangoHKLAdapter::get_sample_fit(bool *afit, bool *bfit, bool *cfit,
872 bool *alphafit, bool *betafit, bool *gammafit,
873 bool *uxfit, bool *uyfit, bool *uzfit)
874 {
875 omni_mutex_lock lock(_lock);
876
877 HklSample * sample = _diffractometer->samples->current;
878 if (!sample)
879 return;
880
881 HklLattice const *lattice = sample->lattice;
882
883 *afit = lattice->a->fit;
884 *bfit = lattice->b->fit;
885 *cfit = lattice->c->fit;
886 *alphafit = lattice->alpha->fit;
887 *betafit = lattice->beta->fit;
888 *gammafit = lattice->gamma->fit;
889 *uxfit = _uxfit;
890 *uyfit = _uyfit;
891 *uzfit = _uzfit;
892 }
893
894
895 void TangoHKLAdapter::set_sample_Ux(double ux)
896 {
897 HklSample *sample;
898
899 sample = _diffractometer->samples->current;
900 if (sample){
901 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
902 ux * HKL_DEGTORAD,
903 _uy * HKL_DEGTORAD,
904 _uz * HKL_DEGTORAD)){
905 _ux = ux;
906 this->update_ub();
907 }else
908 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Ux value",
909 "Set a correct value");
910 }
911 }
912
913 void TangoHKLAdapter::set_sample_Uy(double uy)
914 {
915 HklSample *sample;
916
917 sample = _diffractometer->samples->current;
918 if (sample){
919 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
920 _ux * HKL_DEGTORAD,
921 uy * HKL_DEGTORAD,
922 _uz * HKL_DEGTORAD)){
923 _uy = uy;
924 this->update_ub();
925 }else
926 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Uy value",
927 "Set a correct value");
928 }
929 }
930
931 void TangoHKLAdapter::set_sample_Uz(double uz)
932 {
933 HklSample *sample;
934
935 sample = _diffractometer->samples->current;
936 if (sample){
937 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
938 _ux * HKL_DEGTORAD,
939 _uy * HKL_DEGTORAD,
940 uz * HKL_DEGTORAD)){
941 _uz = uz;
942 this->update_ub();
943 }else
944 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Uz value",
945 "Set a correct value");
946 }
947 }
948
949 void TangoHKLAdapter::set_sample_AFit(bool fit)
950 {
951 HklSample *sample;
952
953 sample = _diffractometer->samples->current;
954 if (sample)
955 sample->lattice->a->fit = fit;
956 }
957
958 void TangoHKLAdapter::set_sample_BFit(bool fit)
959 {
960 HklSample *sample;
961
962 sample = _diffractometer->samples->current;
963 if (sample)
964 sample->lattice->b->fit = fit;
965 }
966
967 void TangoHKLAdapter::set_sample_CFit(bool fit)
968 {
969 HklSample *sample;
970
971 sample = _diffractometer->samples->current;
972 if (sample)
973 sample->lattice->c->fit = fit;
974 }
975
976 void TangoHKLAdapter::set_sample_AlphaFit(bool fit)
977 {
978 HklSample *sample;
979
980 sample = _diffractometer->samples->current;
981 if (sample)
982 sample->lattice->alpha->fit = fit;
983 }
984
985 void TangoHKLAdapter::set_sample_BetaFit(bool fit)
986 {
987 HklSample *sample;
988
989 sample = _diffractometer->samples->current;
990 if (sample)
991 sample->lattice->beta->fit = fit;
992 }
993
994 void TangoHKLAdapter::set_sample_GammaFit(bool fit)
995 {
996 HklSample *sample;
997
998 sample = _diffractometer->samples->current;
999 if (sample)
1000 sample->lattice->gamma->fit = fit;
1001 }
1002
1003 void TangoHKLAdapter::set_sample_UxFit(bool fit)
1004 {
1005 HklSample *sample;
1006
1007 sample = _diffractometer->samples->current;
1008 if (sample)
1009 _uxfit = _uyfit = _uzfit = fit;
1010 }
1011
1012 void TangoHKLAdapter::set_sample_UyFit(bool fit)
1013 {
1014 HklSample *sample;
1015
1016 sample = _diffractometer->samples->current;
1017 if (sample)
1018 _uxfit = _uyfit = _uzfit = fit;
1019 }
1020
1021 void TangoHKLAdapter::set_sample_UzFit(bool fit)
1022 {
1023 HklSample *sample;
1024
1025 sample = _diffractometer->samples->current;
1026 if (sample)
1027 _uxfit = _uyfit = _uzfit = fit;
1028 }
1029
1030 void TangoHKLAdapter::add_new_sample(std::string const & name)
1031 {
1032 omni_mutex_lock lock(_lock);
1033
1034 HklSample *sample = hkl_sample_new(name.c_str(), HKL_SAMPLE_MONOCRYSTAL);
1035
1036 if (!hkl_sample_list_append(_diffractometer->samples, sample)){
1037 hkl_sample_free(sample);
1038 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not add a sample with this name",
1039 "A sample with the same name is already present in the sample list");
1040 }
1041 }
1042
1043 void TangoHKLAdapter::copy_sample_as(Tango::DevString copy_name)
1044 {
1045 omni_mutex_lock lock(_lock);
1046
1047 HklSample *sample;
1048 HklSample const *current;
1049
1050 current = _diffractometer->samples->current;
1051 if(!current)
1052 TANGO_EXCEPTION_THROW_WITHOUT_LOG("No current sample set",
1053 "Please set a current sample");
1054
1055 sample = hkl_sample_list_get_by_name(_diffractometer->samples, copy_name);
1056 if (sample)
1057 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not add a sample with this name",
1058 "A sample with the same name is already present in the sample list");
1059
1060 sample = hkl_sample_new_copy(current);
1061 if(sample){
1062 hkl_sample_set_name(sample, copy_name);
1063 hkl_sample_list_append(_diffractometer->samples, sample);
1064 }
1065 }
1066
1067 void TangoHKLAdapter::del_sample(void)
1068 {
1069 omni_mutex_lock lock(_lock);
1070
1071 HklSampleList *samples = _diffractometer->samples;
1072 hkl_sample_list_del(samples, samples->current);
1073
1074 // add a default sample if no more sample in the list
1075 if(hkl_sample_list_len(samples) == 0){
1076 HklSample *sample = hkl_sample_new("default", HKL_SAMPLE_MONOCRYSTAL);
1077 samples->current = hkl_sample_list_append(samples, sample);
1078 }else
1079 samples->current = hkl_sample_list_get_ith(samples, 0);
1080 this->update_ub();
1081 this->update_ux_uy_uz();
1082 this->update_reflections_angles();
1083 this->update_reflections();
1084 }
1085
1086 void TangoHKLAdapter::set_lattice(const Tango::DevVarDoubleArray *argin)
1087 {
1088 omni_mutex_lock lock(_lock);
1089
1090 if (argin && argin->length() != 6)
1091 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1092 "Did not receive the exact amount of crystal parameters: A, B, C, alpha, beta, gamma");
1093
1094 HklSample *sample = _diffractometer->samples->current;
1095 if (HKL_FAIL == hkl_sample_set_lattice(sample,
1096 (*argin)[0],(*argin)[1], (*argin)[2],
1097 (*argin)[3] * HKL_DEGTORAD,
1098 (*argin)[4] * HKL_DEGTORAD,
1099 (*argin)[5] * HKL_DEGTORAD))
1100
1101 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this lattice combination.",
1102 "Please set a good combination");
1103 this->update_ub();
1104 this->update_reflections_angles();
1105 }
1106
1107 void TangoHKLAdapter::add_reflection(const Tango::DevVarDoubleArray *argin)
1108 {
1109 omni_mutex_lock lock(_lock);
1110
1111 HklSample *sample = _diffractometer->samples->current;
1112
1113 if(sample){
1114 double h, k, l;
1115 HklSampleReflection *ref;
1116
1117 if(argin && argin->length() == 3){
1118 h = (*argin)[0];
1119 k = (*argin)[1];
1120 l = (*argin)[2];
1121 }else{
1122 HklPseudoAxisEngine *engine;
1123
1124 engine = hkl_pseudo_axis_engine_list_get_by_name(_diffractometer->engines_r, "hkl");
1125
1126 h = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[0]);
1127 k = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[1]);
1128 l = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[2]);
1129 }
1130
1131 ref = hkl_sample_add_reflection(sample,
1132 _diffractometer->geometry_r,
1133 _diffractometer->detector,
1134 h, k, l);
1135 if(ref){
1136 this->update_reflections_angles();
1137 this->update_reflections();
1138 }
1139 }
1140 }
1141
1142 void TangoHKLAdapter::del_reflection(Tango::DevShort argin)
1143 {
1144 omni_mutex_lock lock(_lock);
1145
1146 if (HKL_FAIL == hkl_sample_del_reflection(_diffractometer->samples->current, argin))
1147 TANGO_EXCEPTION_THROW_WITHOUT_LOG("index out of range",
1148 "change the reflection index");
1149 this->update_reflections_angles();
1150 this->update_reflections();
1151 }
1152
1153 void TangoHKLAdapter::set_reflections(Matrix<double> const & img)
1154 {
1155 omni_mutex_lock lock(_lock);
1156
1157 HklSample *sample = _diffractometer->samples->current;
1158 if (sample
1159 && img.xdim == _reflections.xdim
1160 && img.ydim == _reflections.ydim) {
1161
1162 size_t i = 0;
1163 size_t j = 0;
1164 for(i=0; i<HKL_LIST_LEN(sample->reflections); ++i) {
1165 HklSampleReflection *r;
1166
1167 r = hkl_sample_get_ith_reflection(sample, i);
1168 if (r) {
1169 hkl_sample_reflection_set_hkl(r, img.data[j+1], img.data[j+2], img.data[j+3]);
1170 hkl_sample_reflection_set_flag(r, (int)img.data[j+5]);
1171 if(!_device->protectReflectionAxes){
1172 HklAxis *axes;
1173 size_t len;
1174 size_t k;
1175
1176 len = HKL_LIST_LEN(r->geometry->axes);
1177 axes = &r->geometry->axes[0];
1178
1179 for(k=6; k<6+len; ++k)
1180 hkl_axis_set_value_unit(axes++, img.data[j+k]);
1181
1182 hkl_geometry_update(r->geometry);
1183 hkl_sample_reflection_set_geometry(r, r->geometry);
1184 }
1185 }
1186 j += _reflections.xdim;
1187 }
1188 this->update_reflections();
1189 this->update_reflections_angles();
1190 }
1191 }
1192
1193 double TangoHKLAdapter::affine_sample(std::string name)
1194 {
1195 omni_mutex_lock lock(_lock);
1196
1197 HklSample *sample;
1198 double res = 0.;
1199
1200 sample = hkl_sample_list_get_by_name(_diffractometer->samples, name.c_str());
1201 if(sample){
1202 HklSample *tmp;
1203
1204 // check if the affine sample is already in the HklSampleList
1205 std::string name = sample->name;
1206 name += "(affine)";
1207 tmp = hkl_sample_list_get_by_name(_diffractometer->samples, name.c_str());
1208 hkl_sample_list_del(_diffractometer->samples, tmp);
1209
1210 tmp = hkl_sample_new_copy(sample);
1211 hkl_sample_set_name(tmp, name.c_str());
1212 res = hkl_sample_affine(tmp);
1213
1214 hkl_sample_list_append(_diffractometer->samples, tmp);
1215 _diffractometer->samples->current = tmp;
1216
1217 this->update_ub();
1218 this->update_ux_uy_uz();
1219 this->update_reflections_angles();
1220 }
1221
1222 return res;
1223 }
1224
1225
1226 std::vector<std::string> TangoHKLAdapter::get_samples_names(void)
1227 {
1228 omni_mutex_lock lock(_lock);
1229
1230 std::vector<std::string> names;
1231 size_t i, len;
1232 HklSampleList *samples = _diffractometer->samples;
1233
1234 len = hkl_sample_list_len(samples);
1235 for(i=0; i<len; ++i)
1236 names.push_back(hkl_sample_list_get_ith(samples, i)->name);
1237
1238 return names;
1239 }
1240
1241 // DEPRECATED
1242 void TangoHKLAdapter::get_sample_parameter_values(Tango::DevVarDoubleStringArray *argout)
1243 {
1244 omni_mutex_lock lock(_lock);
1245
1246 HklSample *sample;
1247 HklParameter *parameter = NULL;
1248 std::string name;
1249
1250 //check parameters
1251 if (argout->svalue.length() != 1)
1252 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1253 "only one string = parameter name");
1254
1255 sample = _diffractometer->samples->current;
1256 if(sample){
1257 //parameters OK
1258 name = argout->svalue[0];
1259 if(name == "a")
1260 parameter = sample->lattice->a;
1261 else if(name == "b")
1262 parameter = sample->lattice->b;
1263 else if(name == "c")
1264 parameter = sample->lattice->c;
1265 else if(name == "alpha")
1266 parameter = sample->lattice->alpha;
1267 else if(name == "beta")
1268 parameter = sample->lattice->beta;
1269 else if(name == "gamma")
1270 parameter = sample->lattice->gamma;
1271
1272 if (parameter){
1273 argout->dvalue[0] = parameter->range.min;
1274 argout->dvalue[1] = parameter->range.max;
1275 argout->dvalue[2] = parameter->fit;
1276 }else
1277 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Wrong parameter name",
1278 "Select: a, b, c, alpha, beta, gamma");
1279 }
1280 }
1281
1282 //DEPRECATED
1283 void TangoHKLAdapter::set_sample_parameter_values(Tango::DevVarDoubleStringArray const *argin)
1284 {
1285 omni_mutex_lock lock(_lock);
1286
1287 HklSample *sample;
1288 HklParameter *parameter = NULL;
1289 std::string name;
1290
1291 // check parameters
1292 if(argin->dvalue.length() != 3)
1293 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1294 "set_crystal_parameter_values did not receive the right amount of scalar parameters: min, max, flag");
1295 if((argin->svalue.length() ) != 1)
1296 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1297 "set_crystal_parameter_values did not receive the right amount of string parameters: parameter name");
1298
1299 // parameters OK
1300 sample = _diffractometer->samples->current;
1301 if(!sample)
1302 TANGO_EXCEPTION_THROW_WITHOUT_LOG("No current sample set",
1303 "Please set a current sample");
1304
1305 name = argin->svalue[0];
1306 if(name == "a")
1307 parameter = sample->lattice->a;
1308 else if(name == "b")
1309 parameter = sample->lattice->b;
1310 else if(name == "c")
1311 parameter = sample->lattice->c;
1312 else if(name == "alpha")
1313 parameter = sample->lattice->alpha;
1314 else if(name == "beta")
1315 parameter = sample->lattice->beta;
1316 else if(name == "gamma")
1317 parameter = sample->lattice->gamma;
1318
1319 if (parameter){
1320 parameter->range.min = argin->dvalue[0];
1321 parameter->range.max = argin->dvalue[1];
1322 parameter->fit = argin->dvalue[2] != 0.;
1323 }else
1324 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Wrong parameter name",
1325 "Select: a, b, c, alpha, beta, gamma");
1326 this->update_ub();
1327 this->update_ux_uy_uz();
1328 this->update_reflections_angles();
1329 }
1330
1331 void TangoHKLAdapter::compute_u(const Tango::DevVarLongArray *argin)
1332 {
1333 omni_mutex_lock lock(_lock);
1334
1335 HklSample *sample;
1336
1337 // is parameter ok ?
1338 if (argin->length() != 2)
1339 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Need exactly two reflections indexes",
1340 "use the right number of parameters");
1341
1342 sample = _diffractometer->samples->current;
1343 if (!sample)
1344 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not compute the U matrix without current sample set.",
1345 "Set a current sample");
1346
1347 if (hkl_sample_compute_UB_busing_levy(sample, (*argin)[0], (*argin)[1]))
1348 TANGO_EXCEPTION_THROW_WITHOUT_LOG("can not compute the UB matrix using thoses reflections index",
1349 "Use other reflections");
1350 this->update_ub();
1351 this->update_ux_uy_uz();
1352 }
1353
1354 /*************/
1355 /* Axis part */
1356 /*************/
1357
1358 void TangoHKLAdapter::read_axis(int idx, double & read, double & write)
1359 {
1360 omni_mutex_lock lock(_lock);
1361
1362 AxisAdapter & axis = _axes[idx];
1363 read = axis.get_read();
1364 write = axis.get_write();
1365 }
1366
1367 void TangoHKLAdapter::stop_all_axis(void)
1368 {
1369 #ifdef WRITE_TO_PROXY_ALLOWED
1370 size_t i;
1371 for(i=0; i<_axes.size(); ++i)
1372 _axes[i].stop();
1373 #endif
1374 }
1375
1376 void TangoHKLAdapter::write_axis(AxisAdapter & axis, double value)
1377 {
1378 omni_mutex_lock lock(_lock);
1379
1380 this->write_axis_i(axis, value);
1381 }
1382
1383 void TangoHKLAdapter::write_axis_i(AxisAdapter & axis, double value)
1384 {
1385 axis._read = axis._write = value;
1386 hkl_axis_set_value_unit(axis._axis_r, value);
1387 hkl_axis_set_value_unit(axis._axis_w, value);
1388 }
1389
1390 /*******************/
1391 /* pseudoAxis part */
1392 /*******************/
1393
1394 std::vector<std::string> TangoHKLAdapter::pseudo_axis_get_names(void)
1395 {
1396 omni_mutex_lock lock(_lock);
1397
1398 std::vector<std::string> names;
1399 size_t i, j;
1400
1401 for(i=0; i<HKL_LIST_LEN(_diffractometer->engines_r_real->engines); ++i){
1402 HklPseudoAxisEngine *engine;
1403
1404 engine = _diffractometer->engines_r_real->engines[i];
1405 for(j=0; j<HKL_LIST_LEN(engine->pseudoAxes); ++j)
1406 names.push_back(((HklParameter *)(&engine->pseudoAxes[j]))->name);
1407 }
1408
1409 return names;
1410 }
1411
1412 PseudoAxisAdapter *TangoHKLAdapter::pseudo_axis_buffer_new(char const *name)
1413 {
1414 omni_mutex_lock lock(_lock);
1415
1416 PseudoAxisAdapter * buffer = NULL;
1417 HklPseudoAxis *pseudo_r;
1418 HklPseudoAxis *pseudo_w;
1419
1420 pseudo_r = hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name(
1421 _diffractometer->engines_r_real, name);
1422 pseudo_w = hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name(
1423 _diffractometer->engines_w_real, name);
1424
1425 if(pseudo_r && pseudo_w) {
1426 try
1427 {
1428 buffer = new PseudoAxisAdapter(*this, pseudo_r, pseudo_w);
1429 _pseudoAxisAdapters.push_back(buffer);
1430 }
1431 catch (Tango::DevFailed)
1432 {
1433 delete buffer;
1434 buffer = NULL;
1435 }
1436 }
1437 return buffer;
1438 }
1439
1440 void TangoHKLAdapter::pseudo_axis_set_initialized(PseudoAxisAdapter *buffer,
1441 Tango::DevBoolean initialized)
1442 {
1443 if(initialized){
1444 this->update();
1445
1446 omni_mutex_lock lock(_lock);
1447
1448 hkl_pseudo_axis_engine_initialize(buffer->_pseudo_r->engine);
1449 hkl_pseudo_axis_engine_initialize(buffer->_pseudo_w->engine);
1450 }
1451 }
1452
1453 void TangoHKLAdapter::pseudo_axis_set_position(PseudoAxisAdapter *buffer,
1454 const Tango::DevDouble & position)
1455 {
1456 omni_mutex_lock lock(_lock);
1457
1458 double value = position - buffer->_config.offset;
1459 int res = HKL_FAIL;
1460
1461 HklPseudoAxisEngineList *engines_w_real = _diffractometer->engines_w_real;
1462 HklPseudoAxisEngine *engine = buffer->_pseudo_w->engine;
1463 HklGeometry *geometry_w_real = _diffractometer->geometry_w_real;
1464
1465 hkl_parameter_set_value_unit((HklParameter *)buffer->_pseudo_w, value);
1466 res = hkl_pseudo_axis_engine_set(buffer->_pseudo_w->engine);
1467 if (HKL_SUCCESS == res){
1468 hkl_geometry_init_geometry(geometry_w_real, engine->engines->geometries->geometries[0]);
1469 hkl_pseudo_axis_engine_list_get(engines_w_real);
1470
1471 _angles_idx = 0;
1472 this->update_angles();
1473 buffer->to_proxies();
1474 this->update_axis_adapters();
1475 this->update_pseudo_axis_adapters_from_hkl();
1476 this->update_pseudo_axes_adapters_from_hkl();
1477 }else
1478 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not write on this pseudo axis",
1479 "Check the sample");
1480
1481 }
1482
1483 PseudoAxisConfig TangoHKLAdapter::pseudo_axis_get_config(PseudoAxisAdapter *buffer)
1484 {
1485 this->update();
1486
1487 omni_mutex_lock lock(_lock);
1488
1489 return buffer->_config;
1490 }
1491
1492 void TangoHKLAdapter::pseudo_axis_set_mode(PseudoAxisAdapter *buffer, Tango::DevString const & mode)
1493 {
1494 omni_mutex_lock lock(_lock);
1495
1496 size_t i, len;
1497
1498 len = HKL_LIST_LEN(buffer->_pseudo_r->engine->modes);
1499 for(i=0; i<len; ++i)
1500 if(!strcasecmp(mode, buffer->_pseudo_r->engine->modes[i]->name))
1501 break;
1502 if(i<len){
1503 hkl_pseudo_axis_engine_select_mode(buffer->_pseudo_r->engine, i);
1504 hkl_pseudo_axis_engine_select_mode(buffer->_pseudo_w->engine, i);
1505 }
1506 }
1507
1508 void TangoHKLAdapter::pseudo_axis_get_mode_parameters(PseudoAxisAdapter *buffer, Tango::DevVarDoubleStringArray *argout)
1509 {
1510 omni_mutex_lock lock(_lock);
1511
1512 HklPseudoAxisEngine *engine = buffer->_pseudo_r->engine;
1513 if (engine && engine->mode){
1514 size_t i;
1515 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1516
1517 argout->svalue.length(len);
1518 argout->dvalue.length(len);
1519 for(i=0; i<len; ++i){
1520 argout->svalue[i] = CORBA::string_dup(engine->mode->parameters[i].name);
1521 argout->dvalue[i] = hkl_parameter_get_value_unit(&engine->mode->parameters[i]);
1522 }
1523 }else
1524 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not get the current Mode parameters values without a current mode set.",
1525 "");
1526 }
1527
1528 void TangoHKLAdapter::pseudo_axis_set_mode_parameters(PseudoAxisAdapter *buffer, const Tango::DevVarDoubleStringArray *argin)
1529 {
1530 omni_mutex_lock lock(_lock);
1531
1532 if(argin->svalue.length() != argin->dvalue.length())
1533 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1534 "set_mode_parameters_values did not receive the same amount between string and double values");
1535
1536 HklPseudoAxisEngine *engine_r = buffer->_pseudo_r->engine;
1537 HklPseudoAxisEngine *engine_w = buffer->_pseudo_w->engine;
1538 if (engine_r && engine_w){
1539 size_t i;
1540 size_t len;
1541
1542 len = argin->svalue.length();
1543 if (HKL_LIST_LEN(engine_r->mode->parameters) != len)
1544 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Not the right number of parameter",
1545 "gives the right number of parameters");
1546
1547 for(i=0; i<len; ++i){
1548 double value = argin->dvalue[i];
1549 char const *name = argin->svalue[i];
1550 if(!strcmp(name, engine_r->mode->parameters[i].name)){
1551 hkl_parameter_set_value_unit(&engine_r->mode->parameters[i], value);
1552 hkl_parameter_set_value_unit(&engine_w->mode->parameters[i], value);
1553 }
1554 }
1555 }else
1556 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set the current Mode parameters values without a current mode set.",
1557 "");
1558 }
1559
1560 void TangoHKLAdapter::pseudo_axis_on(PseudoAxisAdapter *buffer)
1561 {
1562 omni_mutex_lock lock(_lock);
1563
1564 for(size_t i=0; i<buffer->_axes.size(); ++i)
1565 buffer->_axes[i]->on();
1566 }
1567
1568 /*******************/
1569 /* pseudoAxes part */
1570 /*******************/
1571
1572 PseudoAxesAdapter *TangoHKLAdapter::pseudo_axes_adapter_get_by_name(std::string const & name)
1573 {
1574 //omni_mutex_lock lock(_lock);
1575
1576 unsigned int i;
1577 PseudoAxesAdapter *adapter = NULL;
1578
1579 for(i=0; i<_pseudoAxesAdapters.size(); ++i)
1580 if(_pseudoAxesAdapters[i]->get_name() == name){
1581 adapter = _pseudoAxesAdapters[i];
1582 break;
1583 }
1584 return adapter;
1585 }
1586
1587 PseudoAxesConfig TangoHKLAdapter::pseudo_axes_get_config(size_t idx)
1588 {
1589 this->update();
1590
1591 omni_mutex_lock lock(_lock);
1592
1593 return _pseudoAxesAdapters[idx]->_config;
1594 }
1595
1596
1597 void TangoHKLAdapter::pseudo_axes_write(size_t idx, Matrix<double> const & write) throw (Tango::DevFailed)
1598 {
1599 omni_mutex_lock lock(_lock);
1600
1601 size_t i, len;
1602 int res = HKL_FAIL;
1603 HklPseudoAxisEngineList *engines_r, *engines_w;
1604 HklGeometry *geometry_r, *geometry_w;
1605
1606 engines_r = _diffractometer->engines_r;
1607 engines_w = _diffractometer->engines_w;
1608 len = HKL_LIST_LEN(engines_w->engines[idx]->pseudoAxes);
1609
1610 geometry_r = _diffractometer->geometry_r;
1611 geometry_w = _diffractometer->geometry_w;
1612
1613 for(i=0; i<len; ++i)
1614 hkl_parameter_set_value_unit((HklParameter *)(engines_w->engines[idx]->pseudoAxes[i]), write.data[i]);
1615
1616 res = hkl_pseudo_axis_engine_set(engines_w->engines[idx]);
1617
1618 if (HKL_SUCCESS == res){
1619 // force auto update OFF when we write on a PseudoAxes.
1620 _auto_update_from_proxies = false;
1621
1622 hkl_geometry_init_geometry(geometry_w, engines_w->geometries->geometries[0]);
1623 hkl_pseudo_axis_engine_list_get(engines_w);
1624 hkl_geometry_init_geometry(geometry_r, engines_w->geometries->geometries[0]);
1625 hkl_pseudo_axis_engine_list_get(engines_r);
1626
1627 _angles_idx = 0;
1628 this->update_angles();
1629 this->update_axis_adapters();
1630 this->update_pseudo_axis_adapters_from_hkl();
1631 this->update_pseudo_axes_adapters_from_hkl();
1632 }else
1633 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not write on this pseudo axis",
1634 "Check the sample");
1635
1636 }
1637
1638 Tango::DevString *TangoHKLAdapter::pseudo_axes_get_mode(size_t idx)
1639 {
1640 omni_mutex_lock lock(_lock);
1641
1642 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1643 if(engine->mode)
1644 return const_cast<Tango::DevString *>(&engine->mode->name);
1645 else
1646 return NULL;
1647 }
1648
1649 void TangoHKLAdapter::pseudo_axes_set_mode(size_t idx, const Tango::DevString name)
1650 {
1651 omni_mutex_lock lock(_lock);
1652
1653 size_t i;
1654 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1655
1656 // check if we try to set the same mode than the current one
1657 if (engine->mode)
1658 if(!strcasecmp(name, engine->mode->name))
1659 return;
1660
1661 // no so set the mode if possible
1662 size_t len = HKL_LIST_LEN(engine->modes);
1663 for(i=0; i<len; ++i)
1664 if(!strcasecmp(name, engine->modes[i]->name))
1665 break;
1666 if(i<len){
1667 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_r->engines[idx], i);
1668 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_w->engines[idx], i);
1669 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_r_real->engines[idx], i);
1670 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_w_real->engines[idx], i);
1671 _pseudoAxesAdapters[idx]->update_axes_i(engine);
1672 _pseudoAxesAdapters[idx]->update_state_and_status_i();
1673 }
1674 }
1675
1676 Matrix<char *> & TangoHKLAdapter::pseudo_axes_get_mode_parameters_names(size_t idx)
1677 {
1678 omni_mutex_lock lock(_lock);
1679
1680 size_t i;
1681 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1682 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1683 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[idx];
1684 adapter->_mode_parameters_names.resize(len, 1);
1685 for(i=0; i<len; ++i)
1686 adapter->_mode_parameters_names.data[i] = const_cast<char *>(engine->mode->parameters[i].name);
1687 return adapter->_mode_parameters_names;
1688 }
1689
1690 Matrix<double> const & TangoHKLAdapter::pseudo_axes_get_mode_parameters(size_t idx)
1691 {
1692 omni_mutex_lock lock(_lock);
1693
1694 size_t i;
1695 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1696 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1697 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[idx];
1698 adapter->_mode_parameters.resize(len, 1);
1699 for(i=0; i<len; ++i)
1700 adapter->_mode_parameters.data[i] = hkl_parameter_get_value_unit(&engine->mode->parameters[i]);
1701 return adapter->_mode_parameters;
1702 }
1703
1704 void TangoHKLAdapter::pseudo_axes_set_mode_parameters(size_t idx, Matrix<double> const & values)
1705 {
1706 omni_mutex_lock lock(_lock);
1707
1708 size_t i;
1709 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1710 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1711 if(len == values.xdim)
1712 for(i=0; i<len; ++i){
1713 double & value = values.data[i];
1714
1715 hkl_parameter_set_value_unit(&_diffractometer->engines_r->engines[idx]->mode->parameters[i],
1716 value);
1717 hkl_parameter_set_value_unit(&_diffractometer->engines_w->engines[idx]->mode->parameters[i],
1718 value);
1719 hkl_parameter_set_value_unit(&_diffractometer->engines_r_real->engines[idx]->mode->parameters[i],
1720 value);
1721 hkl_parameter_set_value_unit(&_diffractometer->engines_w_real->engines[idx]->mode->parameters[i],
1722 value);
1723 }
1724 }
1725
1726 void TangoHKLAdapter::pseudo_axes_init(size_t idx)
1727 {
1728 omni_mutex_lock lock(_lock);
1729
1730 HklPseudoAxisEngine *engine_r = _diffractometer->engines_r->engines[idx];
1731 HklPseudoAxisEngine *engine_w = _diffractometer->engines_w->engines[idx];
1732 HklPseudoAxisEngine *engine_r_real = _diffractometer->engines_r_real->engines[idx];
1733 HklPseudoAxisEngine *engine_w_real = _diffractometer->engines_w_real->engines[idx];
1734
1735 hkl_pseudo_axis_engine_initialize(engine_r);
1736 hkl_pseudo_axis_engine_initialize(engine_w);
1737 hkl_pseudo_axis_engine_initialize(engine_r_real);
1738 hkl_pseudo_axis_engine_initialize(engine_w_real);
1739 }
1740
1741 void TangoHKLAdapter::pseudo_axes_add_dynamic_attributes(size_t idx)
1742 {
1743 //omni_mutex_lock lock(_lock);
1744
1745 size_t i, j;
1746
1747 // check if all the PseudoAxes were instantiated
1748 for(i=0; i<_pseudoAxesAdapters.size(); ++i)
1749 if(!_pseudoAxesAdapters[i]->_device)
1750 return;
1751
1752 /*
1753 * we need to attach the dynamic attributes after all instance of
1754 * the PseudoAxes devices were started. otherwise it cause problem.
1755 * only add the attributs if they were not already added.
1756 */
1757 for(i=0; i<_pseudoAxesAdapters.size(); ++i){
1758 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[i];
1759 Tango::MultiAttribute *multiattribute = adapter->_device->get_device_attr();
1760
1761 for(j=0; j<adapter->_dynamic_attribute_pseudo_axes_axis.size(); ++j){
1762 try{
1763 multiattribute->get_attr_by_name(adapter->get_pseudo_axis_names().data[j]);
1764 }catch (Tango::DevFailed){
1765 adapter->_device->add_attribute(adapter->_dynamic_attribute_pseudo_axes_axis[j]);
1766 }
1767 }
1768 }
1769 }
1770
1771 void TangoHKLAdapter::pseudo_axes_remove_dynamic_attributes(size_t idx)
1772 {
1773 size_t i;
1774 PseudoAxesAdapter *adapter;
1775
1776 adapter = _pseudoAxesAdapters[idx];
1777 if(adapter->_device){
1778 for(i=0; i<adapter->_dynamic_attribute_pseudo_axes_axis.size(); ++i)
1779 adapter->_device->remove_attribute(adapter->_dynamic_attribute_pseudo_axes_axis[i], false);
1780 adapter->_device = NULL;
1781 }
1782 }
1783
1784 void TangoHKLAdapter::pseudo_axes_create_and_start_devices(void)
1785 {
1786 omni_mutex_lock lock(_lock);
1787
1788 unsigned int i, j;
1789
1790 Tango::Util *tg = Tango::Util::instance();
1791 Tango::Database *db = tg->get_database();
1792 for(i=0; i<_pseudoAxesAdapters.size(); ++i){
1793 std::string dev_name = _pseudoAxesAdapters[i]->get_proxy_name();
1794
1795 // first check if the device is already defined in the database
1796 try{
1797 Tango::DbDevImportInfo my_device_import_info;
1798
1799 my_device_import_info = db->import_device(dev_name);
1800 } catch (Tango::DevFailed &) {
1801 Tango::DbDevInfo my_device_info;
1802
1803 // add the device to the database
1804 my_device_info.name = dev_name.c_str();
1805 my_device_info._class = "PseudoAxes";
1806 my_device_info.server = tg->get_ds_name().c_str();
1807
1808 db->add_device(my_device_info);
1809
1810 // add the right properties to that device
1811 Tango::DbDatum DiffractometerProxy("DiffractometerProxy"), EngineName("EngineName");
1812 Tango::DbData properties;
1813 DiffractometerProxy << _device->name();
1814 EngineName << _pseudoAxesAdapters[i]->get_name();
1815 properties.push_back(DiffractometerProxy);
1816 properties.push_back(EngineName);
1817 db->put_device_property(dev_name,properties);
1818
1819
1820 // now start the device
1821 const std::vector<Tango::DeviceClass *> *cl_list = tg->get_class_list();
1822 for(j=0; j<cl_list->size(); ++j){
1823 if((*cl_list)[j]->get_name() == "PseudoAxes"){
1824 try{
1825 Tango::DevVarStringArray na;
1826 na.length(1);
1827 na[0] = dev_name.c_str();
1828 (*cl_list)[j]->device_factory(&na);
1829 std::cout << "Started " << dev_name << std::endl;
1830 break;
1831 }
1832 catch (Tango::DevFailed &e)
1833 {
1834 }
1835 }
1836 }
1837 }
1838 }
1839 }
1840
1841 Tango::DevBoolean TangoHKLAdapter::pseudo_axes_get_initialized(size_t idx)
1842 {
1843 omni_mutex_lock lock(_lock);
1844
1845 if(!_diffractometer->engines_r->engines[idx]->mode->initialize)
1846 return true;
1847 }
1848
1849 void TangoHKLAdapter::pseudo_axes_set_initialized(size_t idx, bool initialized)
1850 {
1851 if(initialized){
1852 this->update();
1853
1854 omni_mutex_lock lock(_lock);
1855
1856 HklPseudoAxisEngine *engine_r = _diffractometer->engines_r->engines[idx];
1857 HklPseudoAxisEngine *engine_w = _diffractometer->engines_w->engines[idx];
1858 HklPseudoAxisEngine *engine_r_real = _diffractometer->engines_r_real->engines[idx];
1859 HklPseudoAxisEngine *engine_w_real = _diffractometer->engines_w_real->engines[idx];
1860
1861 hkl_pseudo_axis_engine_initialize(engine_r);
1862 hkl_pseudo_axis_engine_initialize(engine_w);
1863 hkl_pseudo_axis_engine_initialize(engine_r_real);
1864 hkl_pseudo_axis_engine_initialize(engine_w_real);
1865 }
1866 }
1867
1868 /**********************/
1869 /* Dynamic attributes */
1870 /**********************/
1871
1872 void TangoHKLAdapter::create_axes_dynamic_attributes(void)
1873 {
1874 size_t i;
1875 size_t len = _axes.size();
1876 _dynamic_attribute_axes_names.resize(len, 1);
1877 for(i=0; i<len; ++i){
1878 std::string name;
1879 AxisAttrib *att;
1880 size_t l;
1881
1882 // compute the diffractometer axis names
1883 name = "Axis";
1884 l = name.size();
1885 name += _axes[i].get_name();
1886 name[l] = toupper(name[l]);
1887
1888 // create the AxisAttrib to deal with the proxy connection.
1889 att = new AxisAttrib(name.c_str(), _axes[i]);
1890 _dynamic_attribute_axes.push_back(att);
1891 _dynamic_attribute_axes_names.data[i] = const_cast<char *>(att->get_name().c_str());
1892 }
1893 }
1894
1895 void TangoHKLAdapter::destroy_axes_dynamic_attributes(void)
1896 {
1897 size_t i;
1898 size_t len = _dynamic_attribute_axes.size();
1899
1900 for(i=0; i<len; ++i)
1901 delete _dynamic_attribute_axes[i];
1902 }
1903
1904 void TangoHKLAdapter::attach_dynamic_attributes_to_device(void)
1905 {
1906 size_t i;
1907
1908 for(i=0; i<_dynamic_attribute_axes.size(); ++i)
1909 _device->add_attribute(_dynamic_attribute_axes[i]);
1910
1911 }
1912
1913 void TangoHKLAdapter::detach_dynamic_attributes_from_device(void)
1914 {
1915 size_t i;
1916
1917 for(i=0; i<_dynamic_attribute_axes.size(); ++i)
1918 _device->remove_attribute(_dynamic_attribute_axes[i], false);
1919
1920 }
1921
1922 bool TangoHKLAdapter::get_auto_update_from_proxies(void)
1923 {
1924 omni_mutex_lock lock(_lock);
1925
1926 return _auto_update_from_proxies;
1927 }
1928
1929 void TangoHKLAdapter::set_auto_update_from_proxies(bool update)
1930 {
1931 bool old = _auto_update_from_proxies;
1932 _auto_update_from_proxies = update;
1933 if(old = false && update == true)
1934 this->update();
1935 }
1936
1937 } // namespace
1938
1939 std::string hkl_axes_consign_as_string(HklAxis const **axes, size_t axes_len)
1940 {
1941 size_t i;
1942 std::string out;
1943
1944 std::ostringstream line, tmp;
1945 for(i=0; i<axes_len; ++i) {
1946 HklParameter const *axis = (HklParameter const *)axes[i];
1947 double value = hkl_parameter_get_value_unit(axis);
1948
1949 out += " \"";
1950 out += axis->name;
1951 out + "\" ";
1952 std::ostringstream tmp;
1953 tmp << showpos;
1954 tmp << value << "°";
1955 out += tmp.str();
1956 }
1957
1958 return out;
1959 }
Tango Diffractometer Device