?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* add a dist-hook to generate the changelog from the git repositoy.
[diffractometer.git] / src / TangoHKLAdapter.cpp
blobf4e65b1241914065da3f6bc2eafdb9e2384646e8
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
486 adapter->update_state_and_status_i();
487 }
488 }
489
490 void TangoHKLAdapter::update_state_and_status(void)
491 {
492 Tango::DevState state;
493 std::string status;
494 std::string extra_status;
495
496 state = Tango::STANDBY;
497 if (!_auto_update_from_proxies)
498 status = "AutoUpdateFromProxies OFF";
499 else {
500 status = "AutoUpdateFromProxies ON";
501
502 if (!this->ready) {
503 state = Tango::FAULT;
504 extra_status += "\nCan not connect to axes proxies";
505 // update the monochromator proxy status.
506 if (!_lambdaAttributeProxy && _auto_update_from_proxies) {
507 extra_status += "\nCan not connect to the lambdaAttributeProxy";
508 extra_status += "\nCheck also the lambdaAttributeProxy property";
509 }
510 } else {
511 try {
512 for(unsigned int i=0; i<_axes.size(); ++i) {
513 AxisAdapter const & axis = _axes[i];
514 std::string proxy_name = axis.get_proxy_name();
515 Tango::DevState tmpState = axis.get_state();
516
517 ::compose_state(state, tmpState);
518 if (tmpState != Tango::STANDBY)
519 extra_status += "\n" + proxy_name + " is in " + Tango::DevStateName[tmpState];
520 }
521 } catch(...)
522 {
523 state = Tango::FAULT;
524 extra_status += "\nCan not connect to axes proxies";
525 }
526
527 }
528 }
529
530 if (_diffractometer){
531 status += "\nSample: ";
532 if(!_diffractometer->samples->current){
533 status += "Not yet Set";
534 state = Tango::FAULT;
535 } else
536 status += _diffractometer->samples->current->name;
537 if (state == Tango::STANDBY)
538 extra_status += "\nready to compute hkl";
539 }else{
540 state = Tango::FAULT;
541 extra_status += "\nhkl core not yet initialized !!!";
542 }
543 status += "\nDiffractometer status: ";
544 status += Tango::DevStateName[state];
545 status += extra_status;
546
547 _diffractometerConfig.state = state;
548 _diffractometerConfig.status = status;
549 }
550
551 void TangoHKLAdapter::update(void)
552 {
553 /**********************************************
554 * CRITICAL SECTION
555 **********************************************/
556 omni_mutex_lock lock(_lock);
557
558 this->update_lambda();
559 this->update_axis_adapters();
560 this->update_hkl_from_axis_adapters();
561 this->update_pseudo_axis_adapters_from_hkl();
562 this->update_pseudo_axes_adapters_from_hkl();
563 this->update_state_and_status();
564 /**********************************************
565 * END OF CRITICAL SECTION
566 **********************************************/
567 }
568
569 /********************/
570 /* State and status */
571 /********************/
572 void TangoHKLAdapter::get_diffractometer_config(DiffractometerConfig & config)
573 {
574 omni_mutex_lock lock(_lock);
575
576 config = _diffractometerConfig;
577 }
578
579 /************/
580 /* hkl part */
581 /************/
582
583 short & TangoHKLAdapter::get_angles_idx(void)
584 {
585 omni_mutex_lock lock(_lock);
586
587 return _angles_idx;
588 }
589
590 void TangoHKLAdapter::set_angles_idx(short idx)
591 {
592 omni_mutex_lock lock(_lock);
593
594 // A REVOIR
595 if(idx >= 0 && idx < (int)_angles.ydim){
596 size_t i;
597 double *values;
598
599 _angles_idx = idx;
600 values = &_angles.data[1 + idx * _angles.xdim];
601 for(i=0; i<_axes.size(); ++i)
602 this->write_axis_i(_axes[i], values[i]);
603 }
604 }
605
606 void TangoHKLAdapter::load(void)
607 {
608 this->load_1();
609 }
610
611 void TangoHKLAdapter::load_1(void)
612 {
613 unsigned long nb_properties;
614
615 // Get the Crystal Attributes properties.
616 Tango::DbData properties;
617 properties.push_back(Tango::DbDatum("Crystal"));
618 _device->get_db_device()->get_attribute_property(properties);
619
620 // the first one is the number of properties
621 properties[0] >> nb_properties;
622
623 if (nb_properties > 1) {
624 unsigned long i, j;
625 HklGeometry *geometry;
626 HklDetector *detector;
627
628 geometry = hkl_geometry_new_copy(_diffractometer->geometry_r);
629 detector = hkl_detector_new_copy(_diffractometer->detector);
630
631 hkl_sample_list_clear(_diffractometer->samples);
632 for(i=1; i<=nb_properties; ++i) {
633 // skip the _ver property
634 if(!strcasecmp("_ver", properties[i].name.c_str()))
635 continue;
636
637 HklSample * sample;
638
639 // The name of the property name is the name of a crystal.
640 sample = hkl_sample_new(properties[i].name.c_str(), HKL_SAMPLE_MONOCRYSTAL);
641
642 // Extract the lines store in the property
643 std::vector<std::string> lines;
644 properties[i] >> lines;
645
646 for(j=0; j<lines.size(); j++) {
647 char *line = strdup(lines[j].c_str());
648 char *last;
649 char *key = strtok_r(line, "=", &last);
650
651 if (!strcmp(key,"lattice")) {
652 double a = atof(strtok_r(NULL, ";", &last));
653 double b = atof(strtok_r(NULL, ";", &last));
654 double c = atof(strtok_r(NULL, ";", &last));
655 double alpha = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
656 double beta = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
657 double gamma = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
658 hkl_sample_set_lattice(sample, a, b, c, alpha, beta, gamma);
659
660 sample->lattice->a->fit = atoi(strtok_r(NULL, ";", &last));
661 sample->lattice->b->fit = atoi(strtok_r(NULL, ";", &last));
662 sample->lattice->c->fit = atoi(strtok_r(NULL, ";", &last));
663 sample->lattice->alpha->fit = atoi(strtok_r(NULL, ";", &last));
664 sample->lattice->beta->fit = atoi(strtok_r(NULL, ";", &last));
665 sample->lattice->gamma->fit = atoi(strtok_r(NULL, ";", &last));
666 } else if (!strcmp(key, "uxuyuz")){
667 double ux = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
668 double uy = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
669 double uz = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
670 hkl_sample_set_U_from_euler(sample, ux, uy, uz);
671 } else if (!strcmp(key,"reflection")) {
672 unsigned int idx = 0;
673 HklSampleReflection *reflection;
674
675 double wavelength = atof(strtok_r(NULL, ";", &last));
676 double h = atof(strtok_r(NULL, ";", &last));
677 double k = atof(strtok_r(NULL, ";", &last));
678 double l = atof(strtok_r(NULL, ";", &last));
679 int flag = atoi(strtok_r(NULL, ";", &last));
680
681 // first set the geometry axes
682 while(key = strtok_r(NULL, ";", &last))
683 hkl_axis_set_value_unit(&geometry->axes[idx++], atof(key));
684 geometry->source.wave_length = wavelength;
685
686 reflection = hkl_sample_add_reflection(sample, geometry, detector, h, k, l);
687 reflection->flag = flag;
688 }
689 free(line);
690 // End of key research
691 }// End for each parameters
692 hkl_sample_list_append(_diffractometer->samples, sample);
693 }// End for each property
694
695 hkl_detector_free(detector);
696 hkl_geometry_free(geometry);
697
698 //_device->refresh_crystal_parameters();
699 }
700 }
701
702 void TangoHKLAdapter::save(void)
703 {
704 omni_mutex_lock lock(_lock);
705
706 size_t i, j, k;
707 size_t len;
708 Tango::DbData crystal_prop;
709 Tango::DbData data_put;
710
711 // Step 1 : clean all properties
712 // FP Le mieux serait sans doute de ne pas effacer les propriétés d'attribut
713 // avant d'avoir crée correctement un data_put.
714 crystal_prop.push_back(Tango::DbDatum("Crystal"));
715 _device->get_db_device()->get_attribute_property(crystal_prop);
716 long number_of_prop = 0;
717 crystal_prop[0] >> number_of_prop ;
718 if( number_of_prop > 0)
719 _device->get_db_device()->delete_attribute_property(crystal_prop);
720
721 // Step 2 : create the Crystal properties
722 Tango::DbDatum properties("Crystal");
723 // Put number of properties (= nb of samples + 1)
724 len = hkl_sample_list_len(_diffractometer->samples);
725 properties << (long)(len + 1);
726 data_put.push_back(properties);
727
728 // first property is the format version
729 Tango::DbDatum version("_ver");
730 version << (long)FORMAT_VERSION;
731 data_put.push_back(version);
732
733 // now each sample
734 for(k=0; k<len; ++k){
735 HklSample *sample;
736 std::vector<std::string> lines;
737 char line[256];
738
739 // the lattices values
740 sample = hkl_sample_list_get_ith(_diffractometer->samples, k);
741 double a = hkl_parameter_get_value_unit(sample->lattice->a);
742 double b = hkl_parameter_get_value_unit(sample->lattice->b);
743 double c = hkl_parameter_get_value_unit(sample->lattice->c);
744 double alpha = hkl_parameter_get_value_unit(sample->lattice->alpha);
745 double beta = hkl_parameter_get_value_unit(sample->lattice->beta);
746 double gamma = hkl_parameter_get_value_unit(sample->lattice->gamma);
747 // the fit flag
748 int a_fit = sample->lattice->a->fit;
749 int b_fit = sample->lattice->b->fit;
750 int c_fit = sample->lattice->c->fit;
751 int alpha_fit = sample->lattice->alpha->fit;
752 int beta_fit = sample->lattice->beta->fit;
753 int gamma_fit = sample->lattice->gamma->fit;
754
755 snprintf(line, 255, "lattice=%f;%f;%f;%f;%f;%f;%d;%d;%d;%d;%d;%d",
756 a, b, c, alpha, beta, gamma,
757 a_fit, b_fit, c_fit, alpha_fit, beta_fit, gamma_fit);
758 lines.push_back(line);
759
760 // the UxUyUz parameters
761 double ux, uy, uz;
762 hkl_matrix_to_euler(&sample->U, &ux, &uy, &uz);
763 ux *= HKL_RADTODEG;
764 uy *= HKL_RADTODEG;
765 uz *= HKL_RADTODEG;
766
767 snprintf(line, 255, "uxuyuz=%f;%f;%f", ux, uy, uz);
768 lines.push_back(line);
769
770 // the reflections
771 for(i=0; i<HKL_LIST_LEN(sample->reflections); ++i) {
772 HklSampleReflection *reflection;
773
774 reflection = hkl_sample_get_ith_reflection(sample, i);
775 double wavelength = reflection->geometry->source.wave_length;
776 double h = reflection->hkl.data[0];
777 double k = reflection->hkl.data[1];
778 double l = reflection->hkl.data[2];
779 int flag = reflection->flag;
780
781 snprintf(line, 255, "reflection=%f;%f;%f;%f;%d",
782 wavelength, h, k, l, flag);
783 // Extract values of each axes
784 for(j=0; j<HKL_LIST_LEN(reflection->geometry->axes); ++j) {
785 char pos[256];
786 double rad = hkl_axis_get_value_unit(&reflection->geometry->axes[j]);
787 snprintf(pos, 255, ";%f", rad);
788 strncat(line, pos, 255);
789 }
790 lines.push_back(line);
791 }
792
793 // Try to create property
794 // Get crystal name
795 Tango::DbDatum property(sample->name);
796 property << lines;
797 data_put.push_back(property);
798 }
799
800 //update database for this property
801 _device->get_db_device()->put_attribute_property(data_put);
802 }
803
804 /***************/
805 /* sample part */
806 /***************/
807
808 char const *TangoHKLAdapter::get_sample_name(void)
809 {
810 omni_mutex_lock lock(_lock);
811
812 HklSample *sample = _diffractometer->samples->current;
813 if(sample)
814 return sample->name;
815 else
816 return "";
817 }
818
819 void TangoHKLAdapter::set_current_sample(char const * name)
820 {
821 omni_mutex_lock lock(_lock);
822
823 HklSample *last;
824
825 last = _diffractometer->samples->current;
826 if (HKL_SUCCESS == hkl_sample_list_select_current(_diffractometer->samples, name))
827 if (last != _diffractometer->samples->current){
828 this->update_pseudo_axis_engines();
829 this->update_ub();
830 this->update_ux_uy_uz();
831 this->update_reflections_angles();
832 this->update_reflections();
833 this->update_state_and_status();
834 }
835 }
836
837 void TangoHKLAdapter::get_sample_lattices(double *a, double *b, double *c,
838 double *alpha, double *beta, double *gamma,
839 double *a_star, double *b_star, double *c_star,
840 double *alpha_star, double *beta_star, double *gamma_star)
841 {
842 omni_mutex_lock lock(_lock);
843
844 HklSample * sample = _diffractometer->samples->current;
845 if (!sample)
846 return;
847
848 HklLattice const *lattice = sample->lattice;
849 HklLattice *reciprocal = hkl_lattice_new_copy(lattice);
850
851 hkl_lattice_reciprocal(lattice, reciprocal);
852
853 // direct space
854 *a = hkl_parameter_get_value_unit(lattice->a);
855 *b = hkl_parameter_get_value_unit(lattice->b);
856 *c = hkl_parameter_get_value_unit(lattice->c);
857 *alpha = hkl_parameter_get_value_unit(lattice->alpha);
858 *beta = hkl_parameter_get_value_unit(lattice->beta);
859 *gamma = hkl_parameter_get_value_unit(lattice->gamma);
860
861 // reciprocal space
862 *a_star = hkl_parameter_get_value_unit(reciprocal->a);
863 *b_star = hkl_parameter_get_value_unit(reciprocal->b);
864 *c_star = hkl_parameter_get_value_unit(reciprocal->c);
865 *alpha_star = hkl_parameter_get_value_unit(reciprocal->alpha);
866 *beta_star = hkl_parameter_get_value_unit(reciprocal->beta);
867 *gamma_star = hkl_parameter_get_value_unit(reciprocal->gamma);
868
869 hkl_lattice_free(reciprocal);
870 }
871
872 void TangoHKLAdapter::get_sample_fit(bool *afit, bool *bfit, bool *cfit,
873 bool *alphafit, bool *betafit, bool *gammafit,
874 bool *uxfit, bool *uyfit, bool *uzfit)
875 {
876 omni_mutex_lock lock(_lock);
877
878 HklSample * sample = _diffractometer->samples->current;
879 if (!sample)
880 return;
881
882 HklLattice const *lattice = sample->lattice;
883
884 *afit = lattice->a->fit;
885 *bfit = lattice->b->fit;
886 *cfit = lattice->c->fit;
887 *alphafit = lattice->alpha->fit;
888 *betafit = lattice->beta->fit;
889 *gammafit = lattice->gamma->fit;
890 *uxfit = _uxfit;
891 *uyfit = _uyfit;
892 *uzfit = _uzfit;
893 }
894
895
896 void TangoHKLAdapter::set_sample_Ux(double ux)
897 {
898 HklSample *sample;
899
900 sample = _diffractometer->samples->current;
901 if (sample){
902 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
903 ux * HKL_DEGTORAD,
904 _uy * HKL_DEGTORAD,
905 _uz * HKL_DEGTORAD)){
906 _ux = ux;
907 this->update_ub();
908 }else
909 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Ux value",
910 "Set a correct value");
911 }
912 }
913
914 void TangoHKLAdapter::set_sample_Uy(double uy)
915 {
916 HklSample *sample;
917
918 sample = _diffractometer->samples->current;
919 if (sample){
920 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
921 _ux * HKL_DEGTORAD,
922 uy * HKL_DEGTORAD,
923 _uz * HKL_DEGTORAD)){
924 _uy = uy;
925 this->update_ub();
926 }else
927 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Uy value",
928 "Set a correct value");
929 }
930 }
931
932 void TangoHKLAdapter::set_sample_Uz(double uz)
933 {
934 HklSample *sample;
935
936 sample = _diffractometer->samples->current;
937 if (sample){
938 if (HKL_SUCCESS == hkl_sample_set_U_from_euler(sample,
939 _ux * HKL_DEGTORAD,
940 _uy * HKL_DEGTORAD,
941 uz * HKL_DEGTORAD)){
942 _uz = uz;
943 this->update_ub();
944 }else
945 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this Uz value",
946 "Set a correct value");
947 }
948 }
949
950 void TangoHKLAdapter::set_sample_AFit(bool fit)
951 {
952 HklSample *sample;
953
954 sample = _diffractometer->samples->current;
955 if (sample)
956 sample->lattice->a->fit = fit;
957 }
958
959 void TangoHKLAdapter::set_sample_BFit(bool fit)
960 {
961 HklSample *sample;
962
963 sample = _diffractometer->samples->current;
964 if (sample)
965 sample->lattice->b->fit = fit;
966 }
967
968 void TangoHKLAdapter::set_sample_CFit(bool fit)
969 {
970 HklSample *sample;
971
972 sample = _diffractometer->samples->current;
973 if (sample)
974 sample->lattice->c->fit = fit;
975 }
976
977 void TangoHKLAdapter::set_sample_AlphaFit(bool fit)
978 {
979 HklSample *sample;
980
981 sample = _diffractometer->samples->current;
982 if (sample)
983 sample->lattice->alpha->fit = fit;
984 }
985
986 void TangoHKLAdapter::set_sample_BetaFit(bool fit)
987 {
988 HklSample *sample;
989
990 sample = _diffractometer->samples->current;
991 if (sample)
992 sample->lattice->beta->fit = fit;
993 }
994
995 void TangoHKLAdapter::set_sample_GammaFit(bool fit)
996 {
997 HklSample *sample;
998
999 sample = _diffractometer->samples->current;
1000 if (sample)
1001 sample->lattice->gamma->fit = fit;
1002 }
1003
1004 void TangoHKLAdapter::set_sample_UxFit(bool fit)
1005 {
1006 HklSample *sample;
1007
1008 sample = _diffractometer->samples->current;
1009 if (sample)
1010 _uxfit = _uyfit = _uzfit = fit;
1011 }
1012
1013 void TangoHKLAdapter::set_sample_UyFit(bool fit)
1014 {
1015 HklSample *sample;
1016
1017 sample = _diffractometer->samples->current;
1018 if (sample)
1019 _uxfit = _uyfit = _uzfit = fit;
1020 }
1021
1022 void TangoHKLAdapter::set_sample_UzFit(bool fit)
1023 {
1024 HklSample *sample;
1025
1026 sample = _diffractometer->samples->current;
1027 if (sample)
1028 _uxfit = _uyfit = _uzfit = fit;
1029 }
1030
1031 void TangoHKLAdapter::add_new_sample(std::string const & name)
1032 {
1033 omni_mutex_lock lock(_lock);
1034
1035 HklSample *sample = hkl_sample_new(name.c_str(), HKL_SAMPLE_MONOCRYSTAL);
1036
1037 if (!hkl_sample_list_append(_diffractometer->samples, sample)){
1038 hkl_sample_free(sample);
1039 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not add a sample with this name",
1040 "A sample with the same name is already present in the sample list");
1041 }
1042 }
1043
1044 void TangoHKLAdapter::copy_sample_as(Tango::DevString copy_name)
1045 {
1046 omni_mutex_lock lock(_lock);
1047
1048 HklSample *sample;
1049 HklSample const *current;
1050
1051 current = _diffractometer->samples->current;
1052 if(!current)
1053 TANGO_EXCEPTION_THROW_WITHOUT_LOG("No current sample set",
1054 "Please set a current sample");
1055
1056 sample = hkl_sample_list_get_by_name(_diffractometer->samples, copy_name);
1057 if (sample)
1058 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not add a sample with this name",
1059 "A sample with the same name is already present in the sample list");
1060
1061 sample = hkl_sample_new_copy(current);
1062 if(sample){
1063 hkl_sample_set_name(sample, copy_name);
1064 hkl_sample_list_append(_diffractometer->samples, sample);
1065 }
1066 }
1067
1068 void TangoHKLAdapter::del_sample(void)
1069 {
1070 omni_mutex_lock lock(_lock);
1071
1072 HklSampleList *samples = _diffractometer->samples;
1073 hkl_sample_list_del(samples, samples->current);
1074
1075 // add a default sample if no more sample in the list
1076 if(hkl_sample_list_len(samples) == 0){
1077 HklSample *sample = hkl_sample_new("default", HKL_SAMPLE_MONOCRYSTAL);
1078 samples->current = hkl_sample_list_append(samples, sample);
1079 }else
1080 samples->current = hkl_sample_list_get_ith(samples, 0);
1081 this->update_ub();
1082 this->update_ux_uy_uz();
1083 this->update_reflections_angles();
1084 this->update_reflections();
1085 }
1086
1087 void TangoHKLAdapter::set_lattice(const Tango::DevVarDoubleArray *argin)
1088 {
1089 omni_mutex_lock lock(_lock);
1090
1091 if (argin && argin->length() != 6)
1092 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1093 "Did not receive the exact amount of crystal parameters: A, B, C, alpha, beta, gamma");
1094
1095 HklSample *sample = _diffractometer->samples->current;
1096 if (HKL_FAIL == hkl_sample_set_lattice(sample,
1097 (*argin)[0],(*argin)[1], (*argin)[2],
1098 (*argin)[3] * HKL_DEGTORAD,
1099 (*argin)[4] * HKL_DEGTORAD,
1100 (*argin)[5] * HKL_DEGTORAD))
1101
1102 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set this lattice combination.",
1103 "Please set a good combination");
1104 this->update_ub();
1105 this->update_reflections_angles();
1106 }
1107
1108 void TangoHKLAdapter::add_reflection(const Tango::DevVarDoubleArray *argin)
1109 {
1110 omni_mutex_lock lock(_lock);
1111
1112 HklSample *sample = _diffractometer->samples->current;
1113
1114 if(sample){
1115 double h, k, l;
1116 HklSampleReflection *ref;
1117
1118 if(argin && argin->length() == 3){
1119 h = (*argin)[0];
1120 k = (*argin)[1];
1121 l = (*argin)[2];
1122 }else{
1123 HklPseudoAxisEngine *engine;
1124
1125 engine = hkl_pseudo_axis_engine_list_get_by_name(_diffractometer->engines_r, "hkl");
1126
1127 h = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[0]);
1128 k = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[1]);
1129 l = hkl_parameter_get_value_unit((HklParameter *)engine->pseudoAxes[2]);
1130 }
1131
1132 ref = hkl_sample_add_reflection(sample,
1133 _diffractometer->geometry_r,
1134 _diffractometer->detector,
1135 h, k, l);
1136 if(ref){
1137 this->update_reflections_angles();
1138 this->update_reflections();
1139 }
1140 }
1141 }
1142
1143 void TangoHKLAdapter::del_reflection(Tango::DevShort argin)
1144 {
1145 omni_mutex_lock lock(_lock);
1146
1147 if (HKL_FAIL == hkl_sample_del_reflection(_diffractometer->samples->current, argin))
1148 TANGO_EXCEPTION_THROW_WITHOUT_LOG("index out of range",
1149 "change the reflection index");
1150 this->update_reflections_angles();
1151 this->update_reflections();
1152 }
1153
1154 void TangoHKLAdapter::set_reflections(Matrix<double> const & img)
1155 {
1156 omni_mutex_lock lock(_lock);
1157
1158 HklSample *sample = _diffractometer->samples->current;
1159 if (sample
1160 && img.xdim == _reflections.xdim
1161 && img.ydim == _reflections.ydim) {
1162
1163 size_t i = 0;
1164 size_t j = 0;
1165 for(i=0; i<HKL_LIST_LEN(sample->reflections); ++i) {
1166 HklSampleReflection *r;
1167
1168 r = hkl_sample_get_ith_reflection(sample, i);
1169 if (r) {
1170 hkl_sample_reflection_set_hkl(r, img.data[j+1], img.data[j+2], img.data[j+3]);
1171 hkl_sample_reflection_set_flag(r, (int)img.data[j+5]);
1172 if(!_device->protectReflectionAxes){
1173 HklAxis *axes;
1174 size_t len;
1175 size_t k;
1176
1177 len = HKL_LIST_LEN(r->geometry->axes);
1178 axes = &r->geometry->axes[0];
1179
1180 for(k=6; k<6+len; ++k)
1181 hkl_axis_set_value_unit(axes++, img.data[j+k]);
1182
1183 hkl_geometry_update(r->geometry);
1184 hkl_sample_reflection_set_geometry(r, r->geometry);
1185 }
1186 }
1187 j += _reflections.xdim;
1188 }
1189 this->update_reflections();
1190 this->update_reflections_angles();
1191 }
1192 }
1193
1194 double TangoHKLAdapter::affine_sample(std::string name)
1195 {
1196 omni_mutex_lock lock(_lock);
1197
1198 HklSample *sample;
1199 double res = 0.;
1200
1201 sample = hkl_sample_list_get_by_name(_diffractometer->samples, name.c_str());
1202 if(sample){
1203 HklSample *tmp;
1204
1205 // check if the affine sample is already in the HklSampleList
1206 std::string name = sample->name;
1207 name += "(affine)";
1208 tmp = hkl_sample_list_get_by_name(_diffractometer->samples, name.c_str());
1209 hkl_sample_list_del(_diffractometer->samples, tmp);
1210
1211 tmp = hkl_sample_new_copy(sample);
1212 hkl_sample_set_name(tmp, name.c_str());
1213 res = hkl_sample_affine(tmp);
1214
1215 hkl_sample_list_append(_diffractometer->samples, tmp);
1216 _diffractometer->samples->current = tmp;
1217
1218 this->update_ub();
1219 this->update_ux_uy_uz();
1220 this->update_reflections_angles();
1221 }
1222
1223 return res;
1224 }
1225
1226
1227 std::vector<std::string> TangoHKLAdapter::get_samples_names(void)
1228 {
1229 omni_mutex_lock lock(_lock);
1230
1231 std::vector<std::string> names;
1232 size_t i, len;
1233 HklSampleList *samples = _diffractometer->samples;
1234
1235 len = hkl_sample_list_len(samples);
1236 for(i=0; i<len; ++i)
1237 names.push_back(hkl_sample_list_get_ith(samples, i)->name);
1238
1239 return names;
1240 }
1241
1242 // DEPRECATED
1243 void TangoHKLAdapter::get_sample_parameter_values(Tango::DevVarDoubleStringArray *argout)
1244 {
1245 omni_mutex_lock lock(_lock);
1246
1247 HklSample *sample;
1248 HklParameter *parameter = NULL;
1249 std::string name;
1250
1251 //check parameters
1252 if (argout->svalue.length() != 1)
1253 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1254 "only one string = parameter name");
1255
1256 sample = _diffractometer->samples->current;
1257 if(sample){
1258 //parameters OK
1259 name = argout->svalue[0];
1260 if(name == "a")
1261 parameter = sample->lattice->a;
1262 else if(name == "b")
1263 parameter = sample->lattice->b;
1264 else if(name == "c")
1265 parameter = sample->lattice->c;
1266 else if(name == "alpha")
1267 parameter = sample->lattice->alpha;
1268 else if(name == "beta")
1269 parameter = sample->lattice->beta;
1270 else if(name == "gamma")
1271 parameter = sample->lattice->gamma;
1272
1273 if (parameter){
1274 argout->dvalue[0] = parameter->range.min;
1275 argout->dvalue[1] = parameter->range.max;
1276 argout->dvalue[2] = parameter->fit;
1277 }else
1278 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Wrong parameter name",
1279 "Select: a, b, c, alpha, beta, gamma");
1280 }
1281 }
1282
1283 //DEPRECATED
1284 void TangoHKLAdapter::set_sample_parameter_values(Tango::DevVarDoubleStringArray const *argin)
1285 {
1286 omni_mutex_lock lock(_lock);
1287
1288 HklSample *sample;
1289 HklParameter *parameter = NULL;
1290 std::string name;
1291
1292 // check parameters
1293 if(argin->dvalue.length() != 3)
1294 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1295 "set_crystal_parameter_values did not receive the right amount of scalar parameters: min, max, flag");
1296 if((argin->svalue.length() ) != 1)
1297 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1298 "set_crystal_parameter_values did not receive the right amount of string parameters: parameter name");
1299
1300 // parameters OK
1301 sample = _diffractometer->samples->current;
1302 if(!sample)
1303 TANGO_EXCEPTION_THROW_WITHOUT_LOG("No current sample set",
1304 "Please set a current sample");
1305
1306 name = argin->svalue[0];
1307 if(name == "a")
1308 parameter = sample->lattice->a;
1309 else if(name == "b")
1310 parameter = sample->lattice->b;
1311 else if(name == "c")
1312 parameter = sample->lattice->c;
1313 else if(name == "alpha")
1314 parameter = sample->lattice->alpha;
1315 else if(name == "beta")
1316 parameter = sample->lattice->beta;
1317 else if(name == "gamma")
1318 parameter = sample->lattice->gamma;
1319
1320 if (parameter){
1321 parameter->range.min = argin->dvalue[0];
1322 parameter->range.max = argin->dvalue[1];
1323 parameter->fit = argin->dvalue[2] != 0.;
1324 }else
1325 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Wrong parameter name",
1326 "Select: a, b, c, alpha, beta, gamma");
1327 this->update_ub();
1328 this->update_ux_uy_uz();
1329 this->update_reflections_angles();
1330 }
1331
1332 void TangoHKLAdapter::compute_u(const Tango::DevVarLongArray *argin)
1333 {
1334 omni_mutex_lock lock(_lock);
1335
1336 HklSample *sample;
1337
1338 // is parameter ok ?
1339 if (argin->length() != 2)
1340 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Need exactly two reflections indexes",
1341 "use the right number of parameters");
1342
1343 sample = _diffractometer->samples->current;
1344 if (!sample)
1345 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not compute the U matrix without current sample set.",
1346 "Set a current sample");
1347
1348 if (hkl_sample_compute_UB_busing_levy(sample, (*argin)[0], (*argin)[1]))
1349 TANGO_EXCEPTION_THROW_WITHOUT_LOG("can not compute the UB matrix using thoses reflections index",
1350 "Use other reflections");
1351 this->update_ub();
1352 this->update_ux_uy_uz();
1353 }
1354
1355 /*************/
1356 /* Axis part */
1357 /*************/
1358
1359 void TangoHKLAdapter::read_axis(int idx, double & read, double & write)
1360 {
1361 omni_mutex_lock lock(_lock);
1362
1363 AxisAdapter & axis = _axes[idx];
1364 read = axis.get_read();
1365 write = axis.get_write();
1366 }
1367
1368 void TangoHKLAdapter::stop_all_axis(void)
1369 {
1370 #ifdef WRITE_TO_PROXY_ALLOWED
1371 size_t i;
1372 for(i=0; i<_axes.size(); ++i)
1373 _axes[i].stop();
1374 #endif
1375 }
1376
1377 void TangoHKLAdapter::write_axis(AxisAdapter & axis, double value)
1378 {
1379 omni_mutex_lock lock(_lock);
1380
1381 this->write_axis_i(axis, value);
1382 }
1383
1384 void TangoHKLAdapter::write_axis_i(AxisAdapter & axis, double value)
1385 {
1386 axis._read = axis._write = value;
1387 hkl_axis_set_value_unit(axis._axis_r, value);
1388 hkl_axis_set_value_unit(axis._axis_w, value);
1389 }
1390
1391 /*******************/
1392 /* pseudoAxis part */
1393 /*******************/
1394
1395 std::vector<std::string> TangoHKLAdapter::pseudo_axis_get_names(void)
1396 {
1397 omni_mutex_lock lock(_lock);
1398
1399 std::vector<std::string> names;
1400 size_t i, j;
1401
1402 for(i=0; i<HKL_LIST_LEN(_diffractometer->engines_r_real->engines); ++i){
1403 HklPseudoAxisEngine *engine;
1404
1405 engine = _diffractometer->engines_r_real->engines[i];
1406 for(j=0; j<HKL_LIST_LEN(engine->pseudoAxes); ++j)
1407 names.push_back(((HklParameter *)(&engine->pseudoAxes[j]))->name);
1408 }
1409
1410 return names;
1411 }
1412
1413 PseudoAxisAdapter *TangoHKLAdapter::pseudo_axis_buffer_new(char const *name)
1414 {
1415 omni_mutex_lock lock(_lock);
1416
1417 PseudoAxisAdapter * buffer = NULL;
1418 HklPseudoAxis *pseudo_r;
1419 HklPseudoAxis *pseudo_w;
1420
1421 pseudo_r = hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name(
1422 _diffractometer->engines_r_real, name);
1423 pseudo_w = hkl_pseudo_axis_engine_list_get_pseudo_axis_by_name(
1424 _diffractometer->engines_w_real, name);
1425
1426 if(pseudo_r && pseudo_w) {
1427 try
1428 {
1429 buffer = new PseudoAxisAdapter(*this, pseudo_r, pseudo_w);
1430 _pseudoAxisAdapters.push_back(buffer);
1431 }
1432 catch (Tango::DevFailed)
1433 {
1434 delete buffer;
1435 buffer = NULL;
1436 }
1437 }
1438 return buffer;
1439 }
1440
1441 Tango::DevBoolean TangoHKLAdapter::pseudo_axis_get_initialized(PseudoAxisAdapter *buffer)
1442 {
1443 omni_mutex_lock lock(_lock);
1444
1445 if(!buffer->_pseudo_r->engine->mode->initialize)
1446 return true;
1447 }
1448
1449 void TangoHKLAdapter::pseudo_axis_set_initialized(PseudoAxisAdapter *buffer,
1450 Tango::DevBoolean initialized)
1451 {
1452 if(initialized){
1453 this->update();
1454
1455 omni_mutex_lock lock(_lock);
1456
1457 hkl_pseudo_axis_engine_initialize(buffer->_pseudo_r->engine);
1458 hkl_pseudo_axis_engine_initialize(buffer->_pseudo_w->engine);
1459 }
1460 }
1461
1462 void TangoHKLAdapter::pseudo_axis_write(PseudoAxisAdapter * buffer, double value)
1463 {
1464 omni_mutex_lock lock(_lock);
1465
1466 int res = HKL_FAIL;
1467
1468 HklPseudoAxisEngineList *engines_w_real = _diffractometer->engines_w_real;
1469 HklPseudoAxisEngine *engine = buffer->_pseudo_w->engine;
1470 HklGeometry *geometry_w_real = _diffractometer->geometry_w_real;
1471
1472 hkl_parameter_set_value_unit((HklParameter *)buffer->_pseudo_w, value);
1473 res = hkl_pseudo_axis_engine_set(buffer->_pseudo_w->engine);
1474 //hkl_pseudo_axis_engine_fprintf(stdout, buffer->_pseudo_w->engine);
1475 if (HKL_SUCCESS == res){
1476 hkl_geometry_init_geometry(geometry_w_real, engine->engines->geometries->geometries[0]);
1477 hkl_pseudo_axis_engine_list_get(engines_w_real);
1478
1479 _angles_idx = 0;
1480 this->update_angles();
1481 buffer->to_proxies();
1482 this->update_axis_adapters();
1483 this->update_pseudo_axis_adapters_from_hkl();
1484 this->update_pseudo_axes_adapters_from_hkl();
1485 }else
1486 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not write on this pseudo axis",
1487 "Check the sample");
1488
1489 }
1490
1491 Tango::DevString *TangoHKLAdapter::pseudo_axis_get_mode(PseudoAxisAdapter const *buffer)
1492 {
1493 omni_mutex_lock lock(_lock);
1494
1495 return const_cast<Tango::DevString *>(&buffer->_pseudo_r->engine->mode->name);
1496 }
1497
1498 void TangoHKLAdapter::pseudo_axis_set_mode(PseudoAxisAdapter *buffer, Tango::DevString const & mode)
1499 {
1500 omni_mutex_lock lock(_lock);
1501
1502 size_t i, len;
1503
1504 len = HKL_LIST_LEN(buffer->_pseudo_r->engine->modes);
1505 for(i=0; i<len; ++i)
1506 if(!strcasecmp(mode, buffer->_pseudo_r->engine->modes[i]->name))
1507 break;
1508 if(i<len){
1509 hkl_pseudo_axis_engine_select_mode(buffer->_pseudo_r->engine, i);
1510 hkl_pseudo_axis_engine_select_mode(buffer->_pseudo_w->engine, i);
1511 }
1512 }
1513
1514 void TangoHKLAdapter::pseudo_axis_get_mode_parameters(PseudoAxisAdapter *buffer, Tango::DevVarDoubleStringArray *argout)
1515 {
1516 omni_mutex_lock lock(_lock);
1517
1518 HklPseudoAxisEngine *engine = buffer->_pseudo_r->engine;
1519 if (engine && engine->mode){
1520 size_t i;
1521 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1522
1523 argout->svalue.length(len);
1524 argout->dvalue.length(len);
1525 for(i=0; i<len; ++i){
1526 argout->svalue[i] = CORBA::string_dup(engine->mode->parameters[i].name);
1527 argout->dvalue[i] = hkl_parameter_get_value_unit(&engine->mode->parameters[i]);
1528 }
1529 }else
1530 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not get the current Mode parameters values without a current mode set.",
1531 "");
1532 }
1533
1534 void TangoHKLAdapter::pseudo_axis_set_mode_parameters(PseudoAxisAdapter *buffer, const Tango::DevVarDoubleStringArray *argin)
1535 {
1536 omni_mutex_lock lock(_lock);
1537
1538 if(argin->svalue.length() != argin->dvalue.length())
1539 TANGO_EXCEPTION_THROW_WITHOUT_LOG("DATA_OUT_OF_RANGE",
1540 "set_mode_parameters_values did not receive the same amount between string and double values");
1541
1542 HklPseudoAxisEngine *engine_r = buffer->_pseudo_r->engine;
1543 HklPseudoAxisEngine *engine_w = buffer->_pseudo_w->engine;
1544 if (engine_r && engine_w){
1545 size_t i;
1546 size_t len;
1547
1548 len = argin->svalue.length();
1549 if (HKL_LIST_LEN(engine_r->mode->parameters) != len)
1550 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Not the right number of parameter",
1551 "gives the right number of parameters");
1552
1553 for(i=0; i<len; ++i){
1554 double value = argin->dvalue[i];
1555 char const *name = argin->svalue[i];
1556 if(!strcmp(name, engine_r->mode->parameters[i].name)){
1557 hkl_parameter_set_value_unit(&engine_r->mode->parameters[i], value);
1558 hkl_parameter_set_value_unit(&engine_w->mode->parameters[i], value);
1559 }
1560 }
1561 }else
1562 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not set the current Mode parameters values without a current mode set.",
1563 "");
1564 }
1565
1566 void TangoHKLAdapter::pseudo_axis_on(PseudoAxisAdapter *buffer)
1567 {
1568 omni_mutex_lock lock(_lock);
1569
1570 for(size_t i=0; i<buffer->_axes.size(); ++i)
1571 buffer->_axes[i]->on();
1572 }
1573
1574 /*******************/
1575 /* pseudoAxes part */
1576 /*******************/
1577
1578 PseudoAxesAdapter *TangoHKLAdapter::pseudo_axes_adapter_get_by_name(std::string const & name)
1579 {
1580 //omni_mutex_lock lock(_lock);
1581
1582 unsigned int i;
1583 PseudoAxesAdapter *adapter = NULL;
1584
1585 for(i=0; i<_pseudoAxesAdapters.size(); ++i)
1586 if(_pseudoAxesAdapters[i]->get_name() == name){
1587 adapter = _pseudoAxesAdapters[i];
1588 break;
1589 }
1590 return adapter;
1591 }
1592
1593
1594 void TangoHKLAdapter::pseudo_axes_write(size_t idx, Matrix<double> const & write) throw (Tango::DevFailed)
1595 {
1596 omni_mutex_lock lock(_lock);
1597
1598 size_t i, len;
1599 int res = HKL_FAIL;
1600 HklPseudoAxisEngineList *engines_r, *engines_w;
1601 HklGeometry *geometry_r, *geometry_w;
1602
1603 engines_r = _diffractometer->engines_r;
1604 engines_w = _diffractometer->engines_w;
1605 len = HKL_LIST_LEN(engines_w->engines[idx]->pseudoAxes);
1606
1607 geometry_r = _diffractometer->geometry_r;
1608 geometry_w = _diffractometer->geometry_w;
1609
1610 for(i=0; i<len; ++i)
1611 hkl_parameter_set_value_unit((HklParameter *)(engines_w->engines[idx]->pseudoAxes[i]), write.data[i]);
1612
1613 res = hkl_pseudo_axis_engine_set(engines_w->engines[idx]);
1614
1615 if (HKL_SUCCESS == res){
1616 // force auto update OFF when we write on a PseudoAxes.
1617 _auto_update_from_proxies = false;
1618
1619 hkl_geometry_init_geometry(geometry_w, engines_w->geometries->geometries[0]);
1620 hkl_pseudo_axis_engine_list_get(engines_w);
1621 hkl_geometry_init_geometry(geometry_r, engines_w->geometries->geometries[0]);
1622 hkl_pseudo_axis_engine_list_get(engines_r);
1623
1624 _angles_idx = 0;
1625 this->update_angles();
1626 this->update_axis_adapters();
1627 this->update_pseudo_axis_adapters_from_hkl();
1628 this->update_pseudo_axes_adapters_from_hkl();
1629 }else
1630 TANGO_EXCEPTION_THROW_WITHOUT_LOG("Can not write on this pseudo axis",
1631 "Check the sample");
1632
1633 }
1634
1635 Tango::DevString *TangoHKLAdapter::pseudo_axes_get_mode(size_t idx)
1636 {
1637 omni_mutex_lock lock(_lock);
1638
1639 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1640 if(engine->mode)
1641 return const_cast<Tango::DevString *>(&engine->mode->name);
1642 else
1643 return NULL;
1644 }
1645
1646 void TangoHKLAdapter::pseudo_axes_set_mode(size_t idx, const Tango::DevString name)
1647 {
1648 omni_mutex_lock lock(_lock);
1649
1650 size_t i;
1651 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1652
1653 // check if we try to set the same mode than the current one
1654 if (engine->mode)
1655 if(!strcasecmp(name, engine->mode->name))
1656 return;
1657
1658 // no so set the mode if possible
1659 size_t len = HKL_LIST_LEN(engine->modes);
1660 for(i=0; i<len; ++i)
1661 if(!strcasecmp(name, engine->modes[i]->name))
1662 break;
1663 if(i<len){
1664 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_r->engines[idx], i);
1665 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_w->engines[idx], i);
1666 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_r_real->engines[idx], i);
1667 hkl_pseudo_axis_engine_select_mode(_diffractometer->engines_w_real->engines[idx], i);
1668 _pseudoAxesAdapters[idx]->update_axes_i(engine);
1669 _pseudoAxesAdapters[idx]->update_state_and_status_i();
1670 }
1671 }
1672
1673 Matrix<char *> & TangoHKLAdapter::pseudo_axes_get_mode_parameters_names(size_t idx)
1674 {
1675 omni_mutex_lock lock(_lock);
1676
1677 size_t i;
1678 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1679 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1680 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[idx];
1681 adapter->_mode_parameters_names.resize(len, 1);
1682 for(i=0; i<len; ++i)
1683 adapter->_mode_parameters_names.data[i] = const_cast<char *>(engine->mode->parameters[i].name);
1684 return adapter->_mode_parameters_names;
1685 }
1686
1687 Matrix<double> const & TangoHKLAdapter::pseudo_axes_get_mode_parameters(size_t idx)
1688 {
1689 omni_mutex_lock lock(_lock);
1690
1691 size_t i;
1692 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1693 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1694 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[idx];
1695 adapter->_mode_parameters.resize(len, 1);
1696 for(i=0; i<len; ++i)
1697 adapter->_mode_parameters.data[i] = hkl_parameter_get_value_unit(&engine->mode->parameters[i]);
1698 return adapter->_mode_parameters;
1699 }
1700
1701 void TangoHKLAdapter::pseudo_axes_set_mode_parameters(size_t idx, Matrix<double> const & values)
1702 {
1703 omni_mutex_lock lock(_lock);
1704
1705 size_t i;
1706 HklPseudoAxisEngine *engine = _diffractometer->engines_r->engines[idx];
1707 size_t len = HKL_LIST_LEN(engine->mode->parameters);
1708 if(len == values.xdim)
1709 for(i=0; i<len; ++i){
1710 double & value = values.data[i];
1711
1712 hkl_parameter_set_value_unit(&_diffractometer->engines_r->engines[idx]->mode->parameters[i],
1713 value);
1714 hkl_parameter_set_value_unit(&_diffractometer->engines_w->engines[idx]->mode->parameters[i],
1715 value);
1716 hkl_parameter_set_value_unit(&_diffractometer->engines_r_real->engines[idx]->mode->parameters[i],
1717 value);
1718 hkl_parameter_set_value_unit(&_diffractometer->engines_w_real->engines[idx]->mode->parameters[i],
1719 value);
1720 }
1721 }
1722
1723 void TangoHKLAdapter::pseudo_axes_init(size_t idx)
1724 {
1725 omni_mutex_lock lock(_lock);
1726
1727 HklPseudoAxisEngine *engine_r = _diffractometer->engines_r->engines[idx];
1728 HklPseudoAxisEngine *engine_w = _diffractometer->engines_w->engines[idx];
1729 HklPseudoAxisEngine *engine_r_real = _diffractometer->engines_r_real->engines[idx];
1730 HklPseudoAxisEngine *engine_w_real = _diffractometer->engines_w_real->engines[idx];
1731
1732 hkl_pseudo_axis_engine_initialize(engine_r);
1733 hkl_pseudo_axis_engine_initialize(engine_w);
1734 hkl_pseudo_axis_engine_initialize(engine_r_real);
1735 hkl_pseudo_axis_engine_initialize(engine_w_real);
1736 }
1737
1738 void TangoHKLAdapter::pseudo_axes_add_dynamic_attributes(size_t idx)
1739 {
1740 //omni_mutex_lock lock(_lock);
1741
1742 size_t i, j;
1743
1744 // check if all the PseudoAxes were instantiated
1745 for(i=0; i<_pseudoAxesAdapters.size(); ++i)
1746 if(!_pseudoAxesAdapters[i]->_device)
1747 return;
1748
1749 /*
1750 * we need to attach the dynamic attributes after all instance of
1751 * the PseudoAxes devices were started. otherwise it cause problem.
1752 * only add the attributs if they were not already added.
1753 */
1754 for(i=0; i<_pseudoAxesAdapters.size(); ++i){
1755 PseudoAxesAdapter *adapter = _pseudoAxesAdapters[i];
1756 Tango::MultiAttribute *multiattribute = adapter->_device->get_device_attr();
1757
1758 for(j=0; j<adapter->_dynamic_attribute_pseudo_axes_axis.size(); ++j){
1759 try{
1760 multiattribute->get_attr_by_name(adapter->get_pseudo_axis_names().data[j]);
1761 }catch (Tango::DevFailed){
1762 adapter->_device->add_attribute(adapter->_dynamic_attribute_pseudo_axes_axis[j]);
1763 }
1764 }
1765 }
1766 }
1767
1768 void TangoHKLAdapter::pseudo_axes_remove_dynamic_attributes(size_t idx)
1769 {
1770 size_t i;
1771 PseudoAxesAdapter *adapter;
1772
1773 adapter = _pseudoAxesAdapters[idx];
1774 if(adapter->_device){
1775 for(i=0; i<adapter->_dynamic_attribute_pseudo_axes_axis.size(); ++i)
1776 adapter->_device->remove_attribute(adapter->_dynamic_attribute_pseudo_axes_axis[i], false);
1777 adapter->_device = NULL;
1778 }
1779 }
1780
1781 void TangoHKLAdapter::pseudo_axes_create_and_start_devices(void)
1782 {
1783 omni_mutex_lock lock(_lock);
1784
1785 unsigned int i, j;
1786
1787 Tango::Util *tg = Tango::Util::instance();
1788 Tango::Database *db = tg->get_database();
1789 for(i=0; i<_pseudoAxesAdapters.size(); ++i){
1790 std::string dev_name = _pseudoAxesAdapters[i]->get_proxy_name();
1791
1792 // first check if the device is already defined in the database
1793 try{
1794 Tango::DbDevImportInfo my_device_import_info;
1795
1796 my_device_import_info = db->import_device(dev_name);
1797 } catch (Tango::DevFailed &) {
1798 Tango::DbDevInfo my_device_info;
1799
1800 // add the device to the database
1801 my_device_info.name = dev_name.c_str();
1802 my_device_info._class = "PseudoAxes";
1803 my_device_info.server = tg->get_ds_name().c_str();
1804
1805 db->add_device(my_device_info);
1806
1807 // add the right properties to that device
1808 Tango::DbDatum DiffractometerProxy("DiffractometerProxy"), EngineName("EngineName");
1809 Tango::DbData properties;
1810 DiffractometerProxy << _device->name();
1811 EngineName << _pseudoAxesAdapters[i]->get_name();
1812 properties.push_back(DiffractometerProxy);
1813 properties.push_back(EngineName);
1814 db->put_device_property(dev_name,properties);
1815
1816
1817 // now start the device
1818 const std::vector<Tango::DeviceClass *> *cl_list = tg->get_class_list();
1819 for(j=0; j<cl_list->size(); ++j){
1820 if((*cl_list)[j]->get_name() == "PseudoAxes"){
1821 try{
1822 Tango::DevVarStringArray na;
1823 na.length(1);
1824 na[0] = dev_name.c_str();
1825 (*cl_list)[j]->device_factory(&na);
1826 std::cout << "Started " << dev_name << std::endl;
1827 break;
1828 }
1829 catch (Tango::DevFailed &e)
1830 {
1831 }
1832 }
1833 }
1834 }
1835 }
1836 }
1837
1838 Tango::DevBoolean TangoHKLAdapter::pseudo_axes_get_initialized(size_t idx)
1839 {
1840 omni_mutex_lock lock(_lock);
1841
1842 if(!_diffractometer->engines_r->engines[idx]->mode->initialize)
1843 return true;
1844 }
1845
1846 void TangoHKLAdapter::pseudo_axes_set_initialized(size_t idx, bool initialized)
1847 {
1848 if(initialized){
1849 this->update();
1850
1851 omni_mutex_lock lock(_lock);
1852
1853 HklPseudoAxisEngine *engine_r = _diffractometer->engines_r->engines[idx];
1854 HklPseudoAxisEngine *engine_w = _diffractometer->engines_w->engines[idx];
1855 HklPseudoAxisEngine *engine_r_real = _diffractometer->engines_r_real->engines[idx];
1856 HklPseudoAxisEngine *engine_w_real = _diffractometer->engines_w_real->engines[idx];
1857
1858 hkl_pseudo_axis_engine_initialize(engine_r);
1859 hkl_pseudo_axis_engine_initialize(engine_w);
1860 hkl_pseudo_axis_engine_initialize(engine_r_real);
1861 hkl_pseudo_axis_engine_initialize(engine_w_real);
1862 }
1863 }
1864
1865 /**********************/
1866 /* Dynamic attributes */
1867 /**********************/
1868
1869 void TangoHKLAdapter::create_axes_dynamic_attributes(void)
1870 {
1871 size_t i;
1872 size_t len = _axes.size();
1873 _dynamic_attribute_axes_names.resize(len, 1);
1874 for(i=0; i<len; ++i){
1875 std::string name;
1876 AxisAttrib *att;
1877 size_t l;
1878
1879 // compute the diffractometer axis names
1880 name = "Axis";
1881 l = name.size();
1882 name += _axes[i].get_name();
1883 name[l] = toupper(name[l]);
1884
1885 // create the AxisAttrib to deal with the proxy connection.
1886 att = new AxisAttrib(name.c_str(), _axes[i]);
1887 _dynamic_attribute_axes.push_back(att);
1888 _dynamic_attribute_axes_names.data[i] = const_cast<char *>(att->get_name().c_str());
1889 }
1890 }
1891
1892 void TangoHKLAdapter::destroy_axes_dynamic_attributes(void)
1893 {
1894 size_t i;
1895 size_t len = _dynamic_attribute_axes.size();
1896
1897 for(i=0; i<len; ++i)
1898 delete _dynamic_attribute_axes[i];
1899 }
1900
1901 void TangoHKLAdapter::attach_dynamic_attributes_to_device(void)
1902 {
1903 size_t i;
1904
1905 for(i=0; i<_dynamic_attribute_axes.size(); ++i)
1906 _device->add_attribute(_dynamic_attribute_axes[i]);
1907
1908 }
1909
1910 void TangoHKLAdapter::detach_dynamic_attributes_from_device(void)
1911 {
1912 size_t i;
1913
1914 for(i=0; i<_dynamic_attribute_axes.size(); ++i)
1915 _device->remove_attribute(_dynamic_attribute_axes[i], false);
1916
1917 }
1918
1919 bool TangoHKLAdapter::get_auto_update_from_proxies(void)
1920 {
1921 omni_mutex_lock lock(_lock);
1922
1923 return _auto_update_from_proxies;
1924 }
1925
1926 void TangoHKLAdapter::set_auto_update_from_proxies(bool update)
1927 {
1928 bool old = _auto_update_from_proxies;
1929 _auto_update_from_proxies = update;
1930 if(old = false && update == true)
1931 this->update();
1932 }
1933
1934 } // namespace
1935
1936 std::string hkl_axes_consign_as_string(HklAxis const **axes, size_t axes_len)
1937 {
1938 size_t i;
1939 std::string out;
1940
1941 std::ostringstream line, tmp;
1942 for(i=0; i<axes_len; ++i) {
1943 HklParameter const *axis = (HklParameter const *)axes[i];
1944 double value = hkl_parameter_get_value_unit(axis);
1945
1946 out += " \"";
1947 out += axis->name;
1948 out + "\" ";
1949 std::ostringstream tmp;
1950 tmp << showpos;
1951 tmp << value << "°";
1952 out += tmp.str();
1953 }
1954
1955 return out;
1956 }
Tango Diffractometer Device