src/DiffractometerDevice.cpp

   1 static const char *RcsId = "$Header: /cvsroot/tango-ds/Instrumentation/Diffractometer/src/DiffractometerDevice.cpp,v 1.5 2008/11/28 15:46:32 piccaf Exp $";
   2 //+=============================================================================
   3 //
   4 // file :         DiffractometerDevice.cpp
   5 //
   6 // description :  C++ source for the DiffractometerDevice and its commands.
   7 //                The class is derived from Device. It represents the
   8 //                CORBA servant object which will be accessed from the
   9 //                network. All commands which can be executed on the
  10 //                DiffractometerDevice are implemented in this file.
  11 //
  12 // project :      TANGO Device Server
  13 //
  14 // $Author: piccaf $
  15 //
  16 // $Revision: 1.5 $
  17 //
  18 // $Log: DiffractometerDevice.cpp,v $
  19 // Revision 1.5  2008/11/28 15:46:32  piccaf
  20 // * close # mantis: 11051
  21 //
  22 // Revision 1.4  2008/10/16 10:16:55  piccaf
  23 // * update to build on windows with vc8
  24 // * add the Eulerian6C diffractometer.
  25 // * add the dynamic attributes in the factory instead of the init device
  26 //
  27 // Revision 1.3  2008/09/22 16:20:35  vince_soleil
  28 // Set first character of attribute name in minus
  29 //
  30 // Revision 1.2  2008/09/22 08:46:23  piccaf
  31 // * add files from the new diffractometer Device
  32 //
  33 //
  34 // copyleft :     European Synchrotron Radiation Facility
  35 //                BP 220, Grenoble 38043
  36 //                FRANCE
  37 //
  38 //-=============================================================================
  39 //
  40 //              This file is generated by POGO
  41 //      (Program Obviously used to Generate tango Object)
  42 //
  43 //         (c) - Software Engineering Group - ESRF
  44 //=============================================================================
  45
  46
  47
  48 //===================================================================
  49 //
  50 //      The following table gives the correspondence
  51 //      between commands and method name.
  52 //
  53 //  Command name               |  Method name
  54 //      ----------------------------------------
  55 //  State                      |  dev_state()
  56 //  Status                     |  dev_status()
  57 //  Abort                      |  abort()
  58 //  AddNewCrystal              |  add_new_crystal()
  59 //  AddReflection              |  add_reflection()
  60 //  AffineCrystal              |  affine_crystal()
  61 //  ComputedAnglesClear        |  computed_angles_clear()
  62 //  ComputedAnglesHKLList      |  computed_angles_hkllist()
  63 //  ComputeU                   |  compute_u()
  64 //  ConfigureCrystal           |  configure_crystal()
  65 //  CopyCurrentCrystalAs       |  copy_current_crystal_as()
  66 //  CopyReflectionTo           |  copy_reflection_to()
  67 //  DeleteCurrentCrystal       |  delete_current_crystal()
  68 //  GetAffinementIteration     |  get_affinement_iteration()
  69 //  GetAffinementList          |  get_affinement_list()
  70 //  GetAffinementMaxIteration  |  get_affinement_max_iteration()
  71 //  GetAxesNames               |  get_axes_names()
  72 //  GetCrystalNames            |  get_crystal_names()
  73 //  GetCrystalParameterValues  |  get_crystal_parameter_values()
  74 //  GetModeDescription         |  get_mode_description()
  75 //  GetModeParametersNames     |  get_mode_parameters_names()
  76 //  GetModeParametersValues    |  get_mode_parameters_values()
  77 //  GetModeParameterValue      |  get_mode_parameter_value()
  78 //  GetReflection              |  get_reflection()
  79 //  GetReflectionSize          |  get_reflection_size()
  80 //  GotoComputedAngles         |  goto_computed_angles()
  81 //  GotoReflection             |  goto_reflection()
  82 //  Load                       |  load()
  83 //  RemoveReflection           |  remove_reflection()
  84 //  Save                       |  save()
  85 //  SetAffinementMaxIteration  |  set_affinement_max_iteration()
  86 //  SetCrystalParameterValues  |  set_crystal_parameter_values()
  87 //  SetHKL                     |  set_hkl()
  88 //  SetModeParametersValues    |  set_mode_parameters_values()
  89 //  SetReflection              |  set_reflection()
  90 //
  91 //===================================================================
  92
  93
  94 #include <tango.h>
  95 #include <DiffractometerDevice.h>
  96 #include <DiffractometerDeviceClass.h>
  97
  98 #include <time.h>
  99 #include <sstream>
 100 #include <algorithm>
 101 #include <cctype>
 102 #include <string>
 103
 104 #include "macros.h"
 105 #include "DynamicAttrAxis.h"
 106 #include "TangoHKLAdapterFactory.h"
 107
 108 namespace DiffractometerDevice_ns
 109 {
 110
 111 //+----------------------------------------------------------------------------
 112 //
 113 // method :             DiffractometerDevice::DiffractometerDevice(string &s)
 114 //
 115 // description :        constructor for simulated DiffractometerDevice
 116 //
 117 // in : - cl : Pointer to the DeviceClass object
 118 //      - s : Device name
 119 //
 120 //-----------------------------------------------------------------------------
 121 DiffractometerDevice::DiffractometerDevice(Tango::DeviceClass *cl,string &s)
 122 :Tango::Device_3Impl(cl,s.c_str())
 123 {
 124         init_device();
 125 }
 126
 127 DiffractometerDevice::DiffractometerDevice(Tango::DeviceClass *cl,const char *s)
 128 :Tango::Device_3Impl(cl,s)
 129 {
 130         init_device();
 131 }
 132
 133 DiffractometerDevice::DiffractometerDevice(Tango::DeviceClass *cl,const char *s,const char *d)
 134 :Tango::Device_3Impl(cl,s,d)
 135 {
 136         init_device();
 137 }
 138 //+----------------------------------------------------------------------------
 139 //
 140 // method :             DiffractometerDevice::delete_device()
 141 //
 142 // description :        will be called at device destruction or at init command.
 143 //
 144 //-----------------------------------------------------------------------------
 145 void DiffractometerDevice::delete_device()
 146 {
 147         //      Delete device's allocated object
 148         this->save();
 149
 150         // Delete device's allocated object
 151         DELETE_SCALAR_ATTRIBUTE(attr_H_read);
 152         DELETE_SCALAR_ATTRIBUTE(attr_K_read);
 153         DELETE_SCALAR_ATTRIBUTE(attr_L_read);
 154         DELETE_SCALAR_ATTRIBUTE(attr_AnglesIdx_read);
 155         DELETE_SCALAR_ATTRIBUTE(attr_WaveLength_read);
 156         DELETE_SCALAR_ATTRIBUTE(attr_Simulated_read);
 157         DELETE_SCALAR_ATTRIBUTE(attr_A_read);
 158         DELETE_SCALAR_ATTRIBUTE(attr_B_read);
 159         DELETE_SCALAR_ATTRIBUTE(attr_C_read);
 160         DELETE_SCALAR_ATTRIBUTE(attr_Alpha_read);
 161         DELETE_SCALAR_ATTRIBUTE(attr_Beta_read);
 162         DELETE_SCALAR_ATTRIBUTE(attr_Gamma_read);
 163         DELETE_SCALAR_ATTRIBUTE(attr_Ux_read);
 164         DELETE_SCALAR_ATTRIBUTE(attr_Uy_read);
 165         DELETE_SCALAR_ATTRIBUTE(attr_Uz_read);
 166         DELETE_SCALAR_ATTRIBUTE(attr_AStar_read);
 167         DELETE_SCALAR_ATTRIBUTE(attr_BStar_read);
 168         DELETE_SCALAR_ATTRIBUTE(attr_CStar_read);
 169         DELETE_SCALAR_ATTRIBUTE(attr_AlphaStar_read);
 170         DELETE_SCALAR_ATTRIBUTE(attr_BetaStar_read);
 171         DELETE_SCALAR_ATTRIBUTE(attr_GammaStar_read);
 172
 173         DELETE_DEVSTRING_ATTRIBUTE(attr_Mode_read);
 174         DELETE_DEVSTRING_ATTRIBUTE(attr_Crystal_read);
 175
 176         if(attr_CrystalReflections_read) {
 177                 delete[] attr_CrystalReflections_read;
 178                 attr_CrystalReflections_read = NULL;
 179         }
 180
 181         if(attr_UB_read) {
 182                 delete[] attr_UB_read;
 183                 attr_UB_read = NULL;
 184         }
 185
 186         if(attr_ReflectionsAngles_read) {
 187                 delete [] attr_ReflectionsAngles_read;
 188                 attr_ReflectionsAngles_read = NULL;
 189         }
 190
 191         if (attr_ComputedAngles_read) {
 192                 delete [] attr_ComputedAngles_read;
 193                 attr_ComputedAngles_read = NULL;
 194         }
 195
 196         if(attr_Reflections_read){
 197                 delete[] attr_Reflections_read;
 198                 attr_Reflections_read = NULL;
 199         }
 200
 201         this->remove_dynamic_attributes();
 202
 203         /*
 204          * Do not remove the diffractometer in the delete method
 205          * of the Derived classes to avoid a segmentation fault
 206          * during the save method call. Indeed the Derived class delete
 207          * method is called before this delete method.
 208          */
 209         TangoHKLAdapterFactory::instance()->detach_device(this);
 210 }
 211
 212 //+----------------------------------------------------------------------------
 213 //
 214 // method :             DiffractometerDevice::init_device()
 215 //
 216 // description :        will be called at device initialization.
 217 //
 218 //-----------------------------------------------------------------------------
 219 void DiffractometerDevice::init_device()
 220 {
 221         INFO_STREAM << "DiffractometerDevice::DiffractometerDevice() create device " << device_name << endl;
 222
 223         // Initialise variables to default values
 224         //--------------------------------------------
 225         get_device_property();
 226
 227         CREATE_SCALAR_ATTRIBUTE(attr_H_read, 0.0);
 228         CREATE_SCALAR_ATTRIBUTE(attr_K_read, 0.0);
 229         CREATE_SCALAR_ATTRIBUTE(attr_L_read, 0.0);
 230         CREATE_SCALAR_ATTRIBUTE(attr_AnglesIdx_read, (short)-1);
 231         CREATE_SCALAR_ATTRIBUTE(attr_WaveLength_read, 0.0);
 232         CREATE_SCALAR_ATTRIBUTE(attr_Simulated_read, true);
 233         CREATE_SCALAR_ATTRIBUTE(attr_A_read, 0.0);
 234         CREATE_SCALAR_ATTRIBUTE(attr_B_read, 0.0);
 235         CREATE_SCALAR_ATTRIBUTE(attr_C_read, 0.0);
 236         CREATE_SCALAR_ATTRIBUTE(attr_Alpha_read, 0.0);
 237         CREATE_SCALAR_ATTRIBUTE(attr_Beta_read, 0.0);
 238         CREATE_SCALAR_ATTRIBUTE(attr_Gamma_read, 0.0);
 239         CREATE_SCALAR_ATTRIBUTE(attr_Ux_read, 0.0);
 240         CREATE_SCALAR_ATTRIBUTE(attr_Uy_read, 0.0);
 241         CREATE_SCALAR_ATTRIBUTE(attr_Uz_read, 0.0);
 242         CREATE_SCALAR_ATTRIBUTE(attr_AStar_read);
 243         CREATE_SCALAR_ATTRIBUTE(attr_BStar_read);
 244         CREATE_SCALAR_ATTRIBUTE(attr_CStar_read);
 245         CREATE_SCALAR_ATTRIBUTE(attr_AlphaStar_read);
 246         CREATE_SCALAR_ATTRIBUTE(attr_BetaStar_read);
 247         CREATE_SCALAR_ATTRIBUTE(attr_GammaStar_read);
 248
 249         CREATE_DEVSTRING_ATTRIBUTE(attr_Crystal_read, 1, "");
 250         CREATE_DEVSTRING_ATTRIBUTE(attr_Mode_read, 1, "");
 251
 252         attr_CrystalReflections_read = NULL;
 253         attr_UB_read = NULL;
 254         attr_ReflectionsAngles_read = NULL;
 255         attr_ComputedAngles_read = NULL;
 256         attr_Reflections_read = NULL;
 257         attr_AxesNames_read = NULL;
 258
 259         // get the write part of the hkl attributes
 260         _att_h_w = &dev_attr->get_w_attr_by_name("h");
 261         _att_k_w = &dev_attr->get_w_attr_by_name("k");
 262         _att_l_w = &dev_attr->get_w_attr_by_name("l");
 263
 264         // Device is in FAULT state because it was not yet configured.
 265         this->set_state(Tango::FAULT);
 266         this->set_status("Configure Diffractometer: crystal, wavelength,etc ..");
 267
 268         _computedAngles_size = 0;
 269
 270         // Write values
 271         attr_H_write = 0.0;
 272         attr_K_write = 0.0;
 273         attr_L_write = 0.0;
 274
 275
 276         _type = this->get_type_from_property(diffractometerType);
 277
 278         /*
 279          * this method must be call after get_device_property() as
 280          * TangoHKLAdapter create the axisbuffer from the
 281          * realAxisProxies.
 282          */
 283         _hklAdapter = TangoHKLAdapterFactory::instance()->attach_device(this, _type);
 284         if (!_hklAdapter) {
 285                 this->set_state(Tango::FAULT);
 286                 this->set_status("Fatal can not initialize the hkl library");
 287                 TANGO_EXCEPTION_THROW("Internal Fatal Error", "Device can't get an instance of TangoHKLAdapter");
 288         } else {
 289                 // Restore the Diffractometer state from the last run.
 290                 this->load();
 291
 292                 _hklAdapter->connect_all_proxies();
 293         }
 294
 295         _write_attributes_hkl_together = false;
 296 }
 297
 298
 299 //+----------------------------------------------------------------------------
 300 //
 301 // method :             DiffractometerDevice::get_device_property()
 302 //
 303 // description :        Read the device properties from database.
 304 //
 305 //-----------------------------------------------------------------------------
 306 void DiffractometerDevice::get_device_property()
 307 {
 308         //      Initialize your default values here (if not done with  POGO).
 309         //------------------------------------------------------------------
 310
 311         //      Read device properties from database.(Automatic code generation)
 312         //------------------------------------------------------------------
 313         Tango::DbData   dev_prop;
 314         dev_prop.push_back(Tango::DbDatum("TauConstant"));
 315         dev_prop.push_back(Tango::DbDatum("RealAxisProxies"));
 316         dev_prop.push_back(Tango::DbDatum("LambdaAttributeProxy"));
 317         dev_prop.push_back(Tango::DbDatum("DiffractometerType"));
 318
 319         //      Call database and extract values
 320         //--------------------------------------------
 321         if (Tango::Util::instance()->_UseDb==true)
 322                 get_db_device()->get_property(dev_prop);
 323         Tango::DbDatum  def_prop, cl_prop;
 324         DiffractometerDeviceClass       *ds_class =
 325                 (static_cast<DiffractometerDeviceClass *>(get_device_class()));
 326         int     i = -1;
 327
 328         //      Try to initialize TauConstant from class property
 329         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 330         if (cl_prop.is_empty()==false)  cl_prop  >>  tauConstant;
 331         else {
 332                 //      Try to initialize TauConstant from default device value
 333                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 334                 if (def_prop.is_empty()==false) def_prop  >>  tauConstant;
 335         }
 336         //      And try to extract TauConstant value from database
 337         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  tauConstant;
 338
 339         //      Try to initialize RealAxisProxies from class property
 340         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 341         if (cl_prop.is_empty()==false)  cl_prop  >>  realAxisProxies;
 342         else {
 343                 //      Try to initialize RealAxisProxies from default device value
 344                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 345                 if (def_prop.is_empty()==false) def_prop  >>  realAxisProxies;
 346         }
 347         //      And try to extract RealAxisProxies value from database
 348         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  realAxisProxies;
 349
 350         //      Try to initialize LambdaAttributeProxy from class property
 351         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 352         if (cl_prop.is_empty()==false)  cl_prop  >>  lambdaAttributeProxy;
 353         else {
 354                 //      Try to initialize LambdaAttributeProxy from default device value
 355                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 356                 if (def_prop.is_empty()==false) def_prop  >>  lambdaAttributeProxy;
 357         }
 358         //      And try to extract LambdaAttributeProxy value from database
 359         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  lambdaAttributeProxy;
 360
 361         //      Try to initialize DiffractometerType from class property
 362         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 363         if (cl_prop.is_empty()==false)  cl_prop  >>  diffractometerType;
 364         else {
 365                 //      Try to initialize DiffractometerType from default device value
 366                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 367                 if (def_prop.is_empty()==false) def_prop  >>  diffractometerType;
 368         }
 369         //      And try to extract DiffractometerType value from database
 370         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  diffractometerType;
 371
 372
 373
 374         //      End of Automatic code generation
 375         //------------------------------------------------------------------
 376
 377 }
 378 //+----------------------------------------------------------------------------
 379 //
 380 // method :             DiffractometerDevice::always_executed_hook()
 381 //
 382 // description :        method always executed before any command is executed
 383 //
 384 //-----------------------------------------------------------------------------
 385 void DiffractometerDevice::always_executed_hook()
 386 {
 387         if (_hklAdapter)
 388                 _hklAdapter->connect_all_proxies();
 389 }
 390 //+----------------------------------------------------------------------------
 391 //
 392 // method :             DiffractometerDevice::read_attr_hardware
 393 //
 394 // description :        Hardware acquisition for attributes.
 395 //
 396 //-----------------------------------------------------------------------------
 397 void DiffractometerDevice::read_attr_hardware(vector<long> &attr_list)
 398 {
 399         DEBUG_STREAM << "DiffractometerDevice::read_attr_hardware(vector<long> &attr_list) entering... "<< endl;
 400         //      Add your own code here
 401         if (!_hklAdapter)
 402                 return;
 403
 404         _hklAdapter->update();
 405
 406         // update the hkl attributes
 407         try
 408         {
 409                 HKLBuffer const & buffer = _hklAdapter->get_HKLBuffer();
 410                 *attr_H_read = buffer.h_r;
 411                 attr_H_write = buffer.h_w;
 412                 *attr_K_read = buffer.k_r;
 413                 attr_K_write = buffer.k_w;
 414                 *attr_L_read = buffer.l_r;
 415                 attr_L_write = buffer.l_w;
 416
 417                 // set the write part of the hkl attributes
 418                 _att_h_w->set_write_value(buffer.h_w);
 419                 _att_k_w->set_write_value(buffer.k_w);
 420                 _att_l_w->set_write_value(buffer.l_w);
 421         }
 422         catch (Tango::DevFailed & e)
 423         {
 424                 ERROR_STREAM << e <<endl;
 425         }
 426
 427         _hklAdapter->get_sample_lattices(attr_A_read, attr_B_read, attr_C_read,
 428                                          attr_Alpha_read, attr_Beta_read, attr_Gamma_read,
 429                                          attr_AStar_read, attr_BStar_read, attr_CStar_read,
 430                                          attr_AlphaStar_read, attr_BetaStar_read, attr_GammaStar_read);
 431 }
 432 //+----------------------------------------------------------------------------
 433 //
 434 // method :             DiffractometerDevice::read_AnglesIdx
 435 //
 436 // description :        Extract real attribute values for AnglesIdx acquisition result.
 437 //
 438 //-----------------------------------------------------------------------------
 439 void DiffractometerDevice::read_AnglesIdx(Tango::Attribute &attr)
 440 {
 441         DEBUG_STREAM << "DiffractometerDevice::read_AnglesIdx(Tango::Attribute &attr) entering... "<< endl;
 442
 443         if(_hklAdapter){
 444                 *attr_AnglesIdx_read = _hklAdapter->get_angles_idx();
 445                 attr.set_value(attr_AnglesIdx_read);
 446         }
 447 }
 448
 449 //+----------------------------------------------------------------------------
 450 //
 451 // method :             DiffractometerDevice::write_AnglesIdx
 452 //
 453 // description :        Write AnglesIdx attribute values to hardware.
 454 //
 455 //-----------------------------------------------------------------------------
 456 void DiffractometerDevice::write_AnglesIdx(Tango::WAttribute &attr)
 457 {
 458         DEBUG_STREAM << "DiffractometerDevice::write_AnglesIdx(Tango::WAttribute &attr) entering... "<< endl;
 459
 460         attr.get_write_value(attr_AnglesIdx_write);
 461         if(_hklAdapter)
 462                 _hklAdapter->set_angles_idx(attr_AnglesIdx_write);
 463 }
 464
 465 //+----------------------------------------------------------------------------
 466 //
 467 // method :             DiffractometerDevice::read_AxesNames
 468 //
 469 // description :        Extract real attribute values for AxesNames acquisition result.
 470 //
 471 //-----------------------------------------------------------------------------
 472 void DiffractometerDevice::read_AxesNames(Tango::Attribute &attr)
 473 {
 474         attr.set_value(_dynamic_axes_names_char, _dynamic_axes_names.size());
 475 }
 476
 477 //+----------------------------------------------------------------------------
 478 //
 479 // method :             DiffractometerDevice::read_Angles
 480 //
 481 // description :        Extract real attribute values for Angles acquisition result.
 482 //
 483 //-----------------------------------------------------------------------------
 484 void DiffractometerDevice::read_Angles(Tango::Attribute &attr)
 485 {
 486         DEBUG_STREAM << "DiffractometerDevice::read_Angles(Tango::Attribute &attr) entering... "<< endl;
 487         if(_hklAdapter){
 488                 Matrix<double> const & img = _hklAdapter->get_angles();
 489                 attr.set_value(img.data, img.xdim, img.ydim);
 490         }
 491 }
 492
 493 //+----------------------------------------------------------------------------
 494 //
 495 // method :             DiffractometerDevice::read_AnglesDegenerated
 496 //
 497 // description :        Extract real attribute values for AnglesDegenerated acquisition result.
 498 //
 499 //-----------------------------------------------------------------------------
 500 void DiffractometerDevice::read_AnglesDegenerated(Tango::Attribute &attr)
 501 {
 502         DEBUG_STREAM << "DiffractometerDevice::read_AnglesDegenerated(Tango::Attribute &attr) entering... "<< endl;
 503 }
 504
 505 //+----------------------------------------------------------------------------
 506 //
 507 // method :             DiffractometerDevice::read_AnglesRangeCheck
 508 //
 509 // description :        Extract real attribute values for AnglesRangeCheck acquisition result.
 510 //
 511 //-----------------------------------------------------------------------------
 512 void DiffractometerDevice::read_AnglesRangeCheck(Tango::Attribute &attr)
 513 {
 514         DEBUG_STREAM << "DiffractometerDevice::read_AnglesRangeCheck(Tango::Attribute &attr) entering... "<< endl;
 515 }
 516
 517 //+----------------------------------------------------------------------------
 518 //
 519 // method :             DiffractometerDevice::read_Reflections
 520 //
 521 // description :        Extract real attribute values for Reflections acquisition result.
 522 //
 523 //-----------------------------------------------------------------------------
 524 void DiffractometerDevice::read_Reflections(Tango::Attribute &attr)
 525 {
 526         DEBUG_STREAM << "DiffractometerDevice::read_Reflections(Tango::Attribute &attr) entering... "<< endl;
 527         if(_hklAdapter){
 528                 Matrix<double> const & img = _hklAdapter->get_sample_reflections();
 529                 attr.set_value(img.data, img.xdim, img.ydim);
 530         }
 531 }
 532
 533 //+----------------------------------------------------------------------------
 534 //
 535 // method :             DiffractometerDevice::write_Reflections
 536 //
 537 // description :        Write Reflections attribute values to hardware.
 538 //
 539 //-----------------------------------------------------------------------------
 540 void DiffractometerDevice::write_Reflections(Tango::WAttribute &attr)
 541 {
 542         DEBUG_STREAM << "DiffractometerDevice::write_Reflections(Tango::WAttribute &attr) entering... "<< endl;
 543
 544         attr.get_write_value(attr_Reflections_write);
 545
 546         Matrix<double> img;
 547         img.attach_to_buffer(&attr_Reflections_write,
 548                              attr.get_w_dim_x(), attr.get_w_dim_y());
 549
 550         if(_hklAdapter)
 551                 _hklAdapter->set_sample_reflections(img);
 552 }
 553
 554 //+----------------------------------------------------------------------------
 555 //
 556 // method :             DiffractometerDevice::read_ComputedAngles
 557 //
 558 // description :        Extract real attribute values for ComputedAngles acquisition result.
 559 //
 560 //-----------------------------------------------------------------------------
 561 void DiffractometerDevice::read_ComputedAngles(Tango::Attribute &attr)
 562 {
 563         DEBUG_STREAM << "DiffractometerDevice::read_ComputedAngles(Tango::Attribute &attr) entering... "<< endl;
 564
 565         if(_hklAdapter){
 566                 Matrix<double> const & img = _hklAdapter->get_angles();
 567                 attr.set_value(img.data, img.xdim, img.ydim);
 568         }
 569 }
 570
 571 //+----------------------------------------------------------------------------
 572 //
 573 // method :             DiffractometerDevice::read_ReflectionsAngles
 574 //
 575 // description :        Extract real attribute values for ReflectionsAngles acquisition result.
 576 //
 577 //-----------------------------------------------------------------------------
 578 void DiffractometerDevice::read_ReflectionsAngles(Tango::Attribute &attr)
 579 {
 580         DEBUG_STREAM << "DiffractometerDevice::read_ReflectionsAngles(Tango::Attribute &attr) entering... "<< endl;
 581
 582         if (_hklAdapter){
 583                 Matrix<double> const & img = _hklAdapter->get_reflections_angles();
 584                 attr.set_value(img.data, img.xdim, img.ydim);
 585         }
 586 }
 587
 588 //+----------------------------------------------------------------------------
 589 //
 590 // method :             DiffractometerDevice::read_AStar
 591 //
 592 // description :        Extract real attribute values for AStar acquisition result.
 593 //
 594 //-----------------------------------------------------------------------------
 595 void DiffractometerDevice::read_AStar(Tango::Attribute &attr)
 596 {
 597         DEBUG_STREAM << "DiffractometerDevice::read_AStar(Tango::Attribute &attr) entering... "<< endl;
 598         attr.set_value(attr_AStar_read);
 599 }
 600
 601 //+----------------------------------------------------------------------------
 602 //
 603 // method :             DiffractometerDevice::read_BStar
 604 //
 605 // description :        Extract real attribute values for BStar acquisition result.
 606 //
 607 //-----------------------------------------------------------------------------
 608 void DiffractometerDevice::read_BStar(Tango::Attribute &attr)
 609 {
 610         DEBUG_STREAM << "DiffractometerDevice::read_BStar(Tango::Attribute &attr) entering... "<< endl;
 611         attr.set_value(attr_BStar_read);
 612 }
 613
 614 //+----------------------------------------------------------------------------
 615 //
 616 // method :             DiffractometerDevice::read_CStar
 617 //
 618 // description :        Extract real attribute values for CStar acquisition result.
 619 //
 620 //-----------------------------------------------------------------------------
 621 void DiffractometerDevice::read_CStar(Tango::Attribute &attr)
 622 {
 623         DEBUG_STREAM << "DiffractometerDevice::read_CStar(Tango::Attribute &attr) entering... "<< endl;
 624         attr.set_value(attr_CStar_read);
 625 }
 626
 627 //+----------------------------------------------------------------------------
 628 //
 629 // method :             DiffractometerDevice::read_AlphaStar
 630 //
 631 // description :        Extract real attribute values for AlphaStar acquisition result.
 632 //
 633 //-----------------------------------------------------------------------------
 634 void DiffractometerDevice::read_AlphaStar(Tango::Attribute &attr)
 635 {
 636         DEBUG_STREAM << "DiffractometerDevice::read_AlphaStar(Tango::Attribute &attr) entering... "<< endl;
 637         attr.set_value(attr_AlphaStar_read);
 638 }
 639
 640 //+----------------------------------------------------------------------------
 641 //
 642 // method :             DiffractometerDevice::read_BetaStar
 643 //
 644 // description :        Extract real attribute values for BetaStar acquisition result.
 645 //
 646 //-----------------------------------------------------------------------------
 647 void DiffractometerDevice::read_BetaStar(Tango::Attribute &attr)
 648 {
 649         DEBUG_STREAM << "DiffractometerDevice::read_BetaStar(Tango::Attribute &attr) entering... "<< endl;
 650         attr.set_value(attr_BetaStar_read);
 651 }
 652
 653 //+----------------------------------------------------------------------------
 654 //
 655 // method :             DiffractometerDevice::read_GammaStar
 656 //
 657 // description :        Extract real attribute values for GammaStar acquisition result.
 658 //
 659 //-----------------------------------------------------------------------------
 660 void DiffractometerDevice::read_GammaStar(Tango::Attribute &attr)
 661 {
 662         DEBUG_STREAM << "DiffractometerDevice::read_GammaStar(Tango::Attribute &attr) entering... "<< endl;
 663         attr.set_value(attr_GammaStar_read);
 664 }
 665
 666 //+----------------------------------------------------------------------------
 667 //
 668 // method :             DiffractometerDevice::read_A
 669 //
 670 // description :        Extract real attribute values for A acquisition result.
 671 //
 672 //-----------------------------------------------------------------------------
 673 void DiffractometerDevice::read_A(Tango::Attribute &attr)
 674 {
 675         DEBUG_STREAM << "DiffractometerDevice::read_A(Tango::Attribute &attr) entering... "<< endl;
 676         attr.set_value(attr_A_read);
 677 }
 678
 679 //+----------------------------------------------------------------------------
 680 //
 681 // method :             DiffractometerDevice::read_B
 682 //
 683 // description :        Extract real attribute values for B acquisition result.
 684 //
 685 //-----------------------------------------------------------------------------
 686 void DiffractometerDevice::read_B(Tango::Attribute &attr)
 687 {
 688         DEBUG_STREAM << "DiffractometerDevice::read_B(Tango::Attribute &attr) entering... "<< endl;
 689         attr.set_value(attr_B_read);
 690 }
 691
 692 //+----------------------------------------------------------------------------
 693 //
 694 // method :             DiffractometerDevice::read_C
 695 //
 696 // description :        Extract real attribute values for C acquisition result.
 697 //
 698 //-----------------------------------------------------------------------------
 699 void DiffractometerDevice::read_C(Tango::Attribute &attr)
 700 {
 701         DEBUG_STREAM << "DiffractometerDevice::read_C(Tango::Attribute &attr) entering... "<< endl;
 702         attr.set_value(attr_C_read);
 703 }
 704
 705 //+----------------------------------------------------------------------------
 706 //
 707 // method :             DiffractometerDevice::read_Alpha
 708 //
 709 // description :        Extract real attribute values for Alpha acquisition result.
 710 //
 711 //-----------------------------------------------------------------------------
 712 void DiffractometerDevice::read_Alpha(Tango::Attribute &attr)
 713 {
 714         DEBUG_STREAM << "DiffractometerDevice::read_Alpha(Tango::Attribute &attr) entering... "<< endl;
 715         attr.set_value(attr_Alpha_read);
 716 }
 717
 718 //+----------------------------------------------------------------------------
 719 //
 720 // method :             DiffractometerDevice::read_Beta
 721 //
 722 // description :        Extract real attribute values for Beta acquisition result.
 723 //
 724 //-----------------------------------------------------------------------------
 725 void DiffractometerDevice::read_Beta(Tango::Attribute &attr)
 726 {
 727         DEBUG_STREAM << "DiffractometerDevice::read_Beta(Tango::Attribute &attr) entering... "<< endl;
 728         attr.set_value(attr_Beta_read);
 729 }
 730
 731 //+----------------------------------------------------------------------------
 732 //
 733 // method :             DiffractometerDevice::read_Gamma
 734 //
 735 // description :        Extract real attribute values for Gamma acquisition result.
 736 //
 737 //-----------------------------------------------------------------------------
 738 void DiffractometerDevice::read_Gamma(Tango::Attribute &attr)
 739 {
 740         DEBUG_STREAM << "DiffractometerDevice::read_Gamma(Tango::Attribute &attr) entering... "<< endl;
 741         attr.set_value(attr_Gamma_read);
 742 }
 743
 744 //+----------------------------------------------------------------------------
 745 //
 746 // method :             DiffractometerDevice::read_UB
 747 //
 748 // description :        Extract real attribute values for UB acquisition result.
 749 //
 750 //-----------------------------------------------------------------------------
 751 void DiffractometerDevice::read_UB(Tango::Attribute &attr)
 752 {
 753         DEBUG_STREAM << "DiffractometerDevice::read_UB(Tango::Attribute &attr) entering... "<< endl;
 754
 755         if(_hklAdapter){
 756                 Matrix<double> const & img = _hklAdapter->get_sample_ub();
 757                 attr.set_value(img.data, img.xdim, img.ydim);
 758         }
 759 }
 760
 761 //+----------------------------------------------------------------------------
 762 //
 763 // method :             DiffractometerDevice::read_Ux
 764 //
 765 // description :        Extract real attribute values for Ux acquisition result.
 766 //
 767 //-----------------------------------------------------------------------------
 768 void DiffractometerDevice::read_Ux(Tango::Attribute &attr)
 769 {
 770         DEBUG_STREAM << "DiffractometerDevice::read_Ux(Tango::Attribute &attr) entering... "<< endl;
 771
 772         if(_hklAdapter)
 773                 attr.set_value(&_hklAdapter->get_sample_Ux());
 774 }
 775
 776 //+----------------------------------------------------------------------------
 777 //
 778 // method :             DiffractometerDevice::write_Ux
 779 //
 780 // description :        Write Ux attribute values to hardware.
 781 //
 782 //-----------------------------------------------------------------------------
 783 void DiffractometerDevice::write_Ux(Tango::WAttribute &attr)
 784 {
 785         DEBUG_STREAM << "DiffractometerDevice::write_Ux(Tango::WAttribute &attr) entering... "<< endl;
 786         double Ux;
 787
 788         attr.get_write_value(Ux);
 789         if (_hklAdapter){
 790                 _hklAdapter->set_sample_Ux(Ux);
 791                 attr_Ux_write = Ux;
 792         }
 793 }
 794
 795 //+----------------------------------------------------------------------------
 796 //
 797 // method :             DiffractometerDevice::read_Uy
 798 //
 799 // description :        Extract real attribute values for Uy acquisition result.
 800 //
 801 //-----------------------------------------------------------------------------
 802 void DiffractometerDevice::read_Uy(Tango::Attribute &attr)
 803 {
 804         DEBUG_STREAM << "DiffractometerDevice::read_Uy(Tango::Attribute &attr) entering... "<< endl;
 805         if(_hklAdapter)
 806                 attr.set_value(&_hklAdapter->get_sample_Uy());
 807 }
 808
 809 //+----------------------------------------------------------------------------
 810 //
 811 // method :             DiffractometerDevice::write_Uy
 812 //
 813 // description :        Write Uy attribute values to hardware.
 814 //
 815 //-----------------------------------------------------------------------------
 816 void DiffractometerDevice::write_Uy(Tango::WAttribute &attr)
 817 {
 818         DEBUG_STREAM << "DiffractometerDevice::write_Uy(Tango::WAttribute &attr) entering... "<< endl;
 819         double Uy;
 820
 821         attr.get_write_value(Uy);
 822         if (_hklAdapter){
 823                 _hklAdapter->set_sample_Uy(Uy);
 824                 attr_Uy_write = Uy;
 825         }
 826 }
 827
 828 //+----------------------------------------------------------------------------
 829 //
 830 // method :             DiffractometerDevice::read_Uz
 831 //
 832 // description :        Extract real attribute values for Uz acquisition result.
 833 //
 834 //-----------------------------------------------------------------------------
 835 void DiffractometerDevice::read_Uz(Tango::Attribute &attr)
 836 {
 837         DEBUG_STREAM << "DiffractometerDevice::read_Uz(Tango::Attribute &attr) entering... "<< endl;
 838         if(_hklAdapter)
 839                 attr.set_value(&_hklAdapter->get_sample_Uz());
 840 }
 841
 842 //+----------------------------------------------------------------------------
 843 //
 844 // method :             DiffractometerDevice::write_Uz
 845 //
 846 // description :        Write Uz attribute values to hardware.
 847 //
 848 //-----------------------------------------------------------------------------
 849 void DiffractometerDevice::write_Uz(Tango::WAttribute &attr)
 850 {
 851         DEBUG_STREAM << "DiffractometerDevice::write_Uz(Tango::WAttribute &attr) entering... "<< endl;
 852         double Uz;
 853
 854         attr.get_write_value(Uz);
 855         if (_hklAdapter){
 856                 _hklAdapter->set_sample_Uz(Uz);
 857                 attr_Uz_write = Uz;
 858         }
 859 }
 860
 861
 862 //+----------------------------------------------------------------------------
 863 //
 864 // method :             DiffractometerDevice::read_Simulated
 865 //
 866 // description :        Extract real attribute values for Simulated acquisition result.
 867 //
 868 //-----------------------------------------------------------------------------
 869 void DiffractometerDevice::read_Simulated(Tango::Attribute &attr)
 870 {
 871         DEBUG_STREAM << "DiffractometerDevice::read_Simulated(Tango::Attribute &attr) entering... "<< endl;
 872
 873         if(_hklAdapter)
 874                 *attr_Simulated_read = _hklAdapter->simulated;
 875         attr.set_value(attr_Simulated_read);
 876 }
 877
 878 //+----------------------------------------------------------------------------
 879 //
 880 // method :             DiffractometerDevice::write_Simulated
 881 //
 882 // description :        Write Simulated attribute values to hardware.
 883 //
 884 //-----------------------------------------------------------------------------
 885 void DiffractometerDevice::write_Simulated(Tango::WAttribute &attr)
 886 {
 887         DEBUG_STREAM << "DiffractometerDevice::write_Simulated(Tango::WAttribute &attr) entering... "<< endl;
 888         attr.get_write_value(attr_Simulated_write);
 889
 890         if (_hklAdapter)
 891                 _hklAdapter->set_simulated(attr_Simulated_write);
 892 }
 893
 894 //+----------------------------------------------------------------------------
 895 //
 896 // method :             DiffractometerDevice::read_H
 897 //
 898 // description :        Extract real attribute values for H acquisition result.
 899 //
 900 //-----------------------------------------------------------------------------
 901 void DiffractometerDevice::read_H(Tango::Attribute &attr)
 902 {
 903         DEBUG_STREAM << "DiffractometerDevice::read_H(Tango::Attribute &attr) entering... "<< endl;
 904
 905         attr.set_value(attr_H_read);
 906 }
 907
 908 //+----------------------------------------------------------------------------
 909 //
 910 // method :             DiffractometerDevice::write_H
 911 //
 912 // description :        Write H attribute values to hardware.
 913 //
 914 //-----------------------------------------------------------------------------
 915 void DiffractometerDevice::write_H(Tango::WAttribute &attr)
 916 {
 917         DEBUG_STREAM << "DiffractometerDevice::write_H(Tango::WAttribute &attr) entering... "<< endl;
 918
 919         double h;
 920         attr.get_write_value(h);
 921
 922         // if not during a simultaneous write
 923         if (!_write_attributes_hkl_together) {
 924                 this->compute_angles(h, attr_K_write, attr_L_write);
 925                 // If calculation OK then set write point
 926                 attr_H_write = h;
 927         }else
 928                 attr_H_write = h;
 929 }
 930
 931 //+----------------------------------------------------------------------------
 932 //
 933 // method :             DiffractometerDevice::read_K
 934 //
 935 // description :        Extract real attribute values for K acquisition result.
 936 //
 937 //-----------------------------------------------------------------------------
 938 void DiffractometerDevice::read_K(Tango::Attribute &attr)
 939 {
 940         DEBUG_STREAM << "DiffractometerDevice::read_K(Tango::Attribute &attr) entering... "<< endl;
 941
 942         attr.set_value(attr_K_read);
 943 }
 944
 945 //+----------------------------------------------------------------------------
 946 //
 947 // method :             DiffractometerDevice::write_K
 948 //
 949 // description :        Write K attribute values to hardware.
 950 //
 951 //-----------------------------------------------------------------------------
 952 void DiffractometerDevice::write_K(Tango::WAttribute &attr)
 953 {
 954         DEBUG_STREAM << "DiffractometerDevice::write_K(Tango::WAttribute &attr) entering... "<< endl;
 955
 956         double k;
 957
 958         attr.get_write_value(k);
 959
 960         if (!_write_attributes_hkl_together) {
 961                 this->compute_angles(attr_H_write, k, attr_L_write);
 962                 //Now that attribute values are OK, set them
 963                 attr_K_write = k;
 964         }else
 965                 attr_K_write = k;
 966 }
 967
 968 //+----------------------------------------------------------------------------
 969 //
 970 // method :             DiffractometerDevice::read_L
 971 //
 972 // description :        Extract real attribute values for L acquisition result.
 973 //
 974 //-----------------------------------------------------------------------------
 975 void DiffractometerDevice::read_L(Tango::Attribute &attr)
 976 {
 977         DEBUG_STREAM << "DiffractometerDevice::read_L(Tango::Attribute &attr) entering... "<< endl;
 978
 979         attr.set_value(attr_L_read);
 980 }
 981
 982 //+----------------------------------------------------------------------------
 983 //
 984 // method :             DiffractometerDevice::write_L
 985 //
 986 // description :        Write L attribute values to hardware.
 987 //
 988 //-----------------------------------------------------------------------------
 989 void DiffractometerDevice::write_L(Tango::WAttribute &attr)
 990 {
 991         DEBUG_STREAM << "DiffractometerDevice::write_L(Tango::WAttribute &attr) entering... "<< endl;
 992
 993         double l;
 994
 995         attr.get_write_value(l);
 996
 997         if (!_write_attributes_hkl_together) {
 998                 this->compute_angles(attr_H_write, attr_K_write, l);
 999                 //Now that attribute values are OK, set them
1000                 attr_L_write = l;
1001         }else
1002                 attr_L_write = l;
1003 }
1004
1005 //+----------------------------------------------------------------------------
1006 //
1007 // method :             DiffractometerDevice::read_Mode
1008 //
1009 // description :        Extract real attribute values for Mode acquisition result.
1010 //
1011 //-----------------------------------------------------------------------------
1012 void DiffractometerDevice::read_Mode(Tango::Attribute &attr)
1013 {
1014         DEBUG_STREAM << "DiffractometerDevice::read_Mode(Tango::Attribute &attr) entering... "<< endl;
1015
1016         if(_hklAdapter){
1017                 if(*attr_Mode_read) delete[] *attr_Mode_read;
1018                 *attr_Mode_read = CORBA::string_dup(_hklAdapter->read_mode());
1019         }
1020         attr.set_value(attr_Mode_read);
1021 }
1022
1023 //+----------------------------------------------------------------------------
1024 //
1025 // method :             DiffractometerDevice::write_Mode
1026 //
1027 // description :        Write Mode attribute values to hardware.
1028 //
1029 //-----------------------------------------------------------------------------
1030 void DiffractometerDevice::write_Mode(Tango::WAttribute &attr)
1031 {
1032         DEBUG_STREAM << "DiffractometerDevice::write_Mode(Tango::WAttribute &attr) entering... "<< endl;
1033
1034         attr.get_write_value(attr_Mode_write);
1035         if(_hklAdapter)
1036                 _hklAdapter->write_mode(attr_Mode_write);
1037 }
1038
1039 //+----------------------------------------------------------------------------
1040 //
1041 // method :             DiffractometerDevice::read_Crystal
1042 //
1043 // description :        Extract real attribute values for Crystal acquisition result.
1044 //
1045 //-----------------------------------------------------------------------------
1046 void DiffractometerDevice::read_Crystal(Tango::Attribute &attr)
1047 {
1048         DEBUG_STREAM << "DiffractometerDevice::read_Crystal(Tango::Attribute &attr) entering... "<< endl;
1049
1050         if(*attr_Crystal_read) delete [] *attr_Crystal_read;
1051
1052         if (_hklAdapter)
1053                 *attr_Crystal_read = CORBA::string_dup(_hklAdapter->get_sample_name());
1054         else
1055                 *attr_Crystal_read = CORBA::string_dup("");
1056         attr.set_value(attr_Crystal_read);
1057 }
1058
1059 //+----------------------------------------------------------------------------
1060 //
1061 // method :             DiffractometerDevice::write_Crystal
1062 //
1063 // description :        Write Crystal attribute values to hardware.
1064 //
1065 //-----------------------------------------------------------------------------
1066 void DiffractometerDevice::write_Crystal(Tango::WAttribute &attr)
1067 {
1068         DEBUG_STREAM << "DiffractometerDevice::write_Crystal(Tango::WAttribute &attr) entering... "<< endl;
1069
1070         attr.get_write_value(attr_Crystal_write);
1071         if(_hklAdapter)
1072                 _hklAdapter->set_current_sample(attr_Crystal_write);
1073 }
1074
1075 //+----------------------------------------------------------------------------
1076 //
1077 // method :             DiffractometerDevice::read_WaveLength
1078 //
1079 // description :        Extract real attribute values for WaveLength acquisition result.
1080 //
1081 //-----------------------------------------------------------------------------
1082 void DiffractometerDevice::read_WaveLength(Tango::Attribute &attr)
1083 {
1084         DEBUG_STREAM << "DiffractometerDevice::read_WaveLength(Tango::Attribute &attr) entering... "<< endl;
1085
1086         if(_hklAdapter)
1087                 attr.set_value(&_hklAdapter->get_lambda());
1088 }
1089
1090 //+----------------------------------------------------------------------------
1091 //
1092 // method :             DiffractometerDevice::write_WaveLength
1093 //
1094 // description :        Write WaveLength attribute values to hardware.
1095 //
1096 //-----------------------------------------------------------------------------
1097 void DiffractometerDevice::write_WaveLength(Tango::WAttribute &attr)
1098 {
1099         DEBUG_STREAM << "DiffractometerDevice::write_WaveLength(Tango::WAttribute &attr) entering... "<< endl;
1100
1101         attr.get_write_value(attr_WaveLength_write);
1102
1103         if (_hklAdapter) {
1104                 _hklAdapter->set_lambda(attr_WaveLength_write);
1105                 if (_hklAdapter->simulated)
1106                         *attr_WaveLength_read = attr_WaveLength_write;
1107         }
1108 }
1109
1110 //+----------------------------------------------------------------------------
1111 //
1112 // method :             DiffractometerDevice::read_ModeNames
1113 //
1114 // description :        Extract real attribute values for ModeNames acquisition result.
1115 //
1116 //-----------------------------------------------------------------------------
1117 void DiffractometerDevice::read_ModeNames(Tango::Attribute &attr)
1118 {
1119         DEBUG_STREAM << "DiffractometerDevice::read_ModeNames(Tango::Attribute &attr) entering... "<< endl;
1120
1121         if(_hklAdapter){
1122                 Matrix<char *> const & img = _hklAdapter->get_mode_names();
1123                 attr.set_value(img.data, img.xdim);
1124         }
1125 }
1126
1127 //+----------------------------------------------------------------------------
1128 //
1129 // method :             DiffractometerDevice::read_CrystalNames
1130 //
1131 // description :        Extract real attribute values for CrystalNames acquisition result.
1132 //
1133 //-----------------------------------------------------------------------------
1134 void DiffractometerDevice::read_CrystalNames(Tango::Attribute &attr)
1135 {
1136         DEBUG_STREAM << "DiffractometerDevice::read_CrystalNames(Tango::Attribute &attr) entering... "<< endl;
1137
1138         std::vector<std::string> names;
1139
1140         if (_hklAdapter)
1141                 names = _hklAdapter->get_samples_names();
1142
1143         _crystal_names_dev_varstring_array << names;
1144         attr.set_value(_crystal_names_dev_varstring_array.get_buffer(),
1145                        _crystal_names_dev_varstring_array.length());
1146 }
1147
1148 //+----------------------------------------------------------------------------
1149 //
1150 // method :             DiffractometerDevice::read_CrystalReflections
1151 //
1152 // description :        Extract real attribute values for CrystalReflections acquisition result.
1153 //
1154 //-----------------------------------------------------------------------------
1155 void DiffractometerDevice::read_CrystalReflections(Tango::Attribute &attr)
1156 {
1157         DEBUG_STREAM << "DiffractometerDevice::read_CrystalReflections(Tango::Attribute &attr) entering... "<< endl;
1158
1159         if(_hklAdapter){
1160                 Matrix<double> const & img = _hklAdapter->get_sample_reflections();
1161                 attr.set_value(img.data, img.xdim, img.ydim);
1162         }
1163 }
1164
1165 //+------------------------------------------------------------------
1166 /**
1167  *      method: DiffractometerDevice::abort
1168  *
1169  *      description:    method to execute "Abort"
1170  *      Stops the movement of all axis driven by the Diffractometer
1171  *
1172  *
1173  */
1174 //+------------------------------------------------------------------
1175 void DiffractometerDevice::abort()
1176 {
1177         DEBUG_STREAM << "DiffractometerDevice::abort(): entering... !" << endl;
1178
1179         //      Add your own code to control device here
1180         try
1181         {
1182                 _hklAdapter->stop_all_axis();
1183         }
1184         catch (Tango::DevFailed& e )
1185         {
1186                 ERROR_STREAM << e ;
1187         }
1188 }
1189
1190 //+------------------------------------------------------------------
1191 /**
1192  *      method: DiffractometerDevice::add_new_crystal
1193  *
1194  *      description:    method to execute "AddNewCrystal"
1195  *      Create a new crystal
1196  *
1197  * @param       argin   Name of the new crystal
1198  *
1199  */
1200 //+------------------------------------------------------------------
1201 void DiffractometerDevice::add_new_crystal(Tango::DevString argin)
1202 {
1203         DEBUG_STREAM << "DiffractometerDevice::add_new_crystal(): entering... !" << endl;
1204
1205         //      Add your own code to control device here
1206
1207         /* POGO rename SampleNew */
1208
1209         if (_hklAdapter){
1210                 _hklAdapter->add_new_sample(argin);
1211                 this->save();
1212         }
1213 }
1214
1215 //+------------------------------------------------------------------
1216 /**
1217  *      method: DiffractometerDevice::add_reflection
1218  *
1219  *      description:    method to execute "AddReflection"
1220  *      This commands requires the definition of 1 reflection defined by (h,k,l ) coordinates.
1221  *      This coodinates are associated with the current angles configuration.
1222  *
1223  *      TODO: d�taill� le commentaire
1224  *      reflections i.e : h, k, l, relevance, enable/disable
1225  *
1226  * @param       argin   reflections i.e :  h, k, l, relevance, enable/disable
1227  *
1228  */
1229 //+------------------------------------------------------------------
1230 void DiffractometerDevice::add_reflection(const Tango::DevVarDoubleArray *argin)
1231 {
1232         DEBUG_STREAM << "DiffractometerDevice::add_reflection(): entering... !" << endl;
1233
1234         //      Add your own code to control device here
1235
1236         /* POGO rename SampleReflectionAdd */
1237         if (_hklAdapter){
1238                 _hklAdapter->add_reflection();
1239                 this->save();
1240         }
1241 }
1242
1243 //+------------------------------------------------------------------
1244 /**
1245  *      method: DiffractometerDevice::affine_crystal
1246  *
1247  *      description:    method to execute "AffineCrystal"
1248  *      Compute affinement for the current crystal with available list of reflection.
1249  *
1250  * @param       argin   name of the crystal to fit
1251  * @return      the fitness of the crystal after the affinement.
1252  *
1253  */
1254 //+------------------------------------------------------------------
1255 Tango::DevDouble DiffractometerDevice::affine_crystal(Tango::DevString argin)
1256 {
1257         Tango::DevDouble        argout ;
1258         DEBUG_STREAM << "DiffractometerDevice::affine_crystal(): entering... !" << endl;
1259
1260         //      Add your own code to control device here
1261
1262         /* POGO rename SampleAffinement */
1263
1264         if(_hklAdapter){
1265                 argout = _hklAdapter->affine_sample(argin);
1266                 this->refresh_crystal_parameters();
1267                 this->save();
1268         }
1269
1270         return argout;
1271 }
1272
1273 //+------------------------------------------------------------------
1274 /**
1275  *      method: DiffractometerDevice::configure_crystal
1276  *
1277  *      description:    method to execute "ConfigureCrystal"
1278  *      Defines crystal lattice parameters.
1279  *      This information is mandatory for angles calculations.
1280  *      Angles units are degrees
1281  *
1282  * @param       argin   Crystal parameters : alpha,beta,gamma, A,B,C
1283  *
1284  */
1285 //+------------------------------------------------------------------
1286 void DiffractometerDevice::configure_crystal(const Tango::DevVarDoubleArray *argin)
1287 {
1288         DEBUG_STREAM << "DiffractometerDevice::configure_crystal(): entering... !" << endl;
1289
1290         //      Add your own code to control device here
1291
1292         /* POGO rename SampleConfiguration */
1293
1294         if(_hklAdapter){
1295                 _hklAdapter->set_lattice(argin);
1296                 this->refresh_crystal_parameters();
1297                 this->save();
1298         }
1299 }
1300
1301 //+------------------------------------------------------------------
1302 /**
1303  *      method: DiffractometerDevice::copy_current_crystal_as
1304  *
1305  *      description:    method to execute "CopyCurrentCrystalAs"
1306  *      Copy the current crytal as another name
1307  *
1308  * @param       argin
1309  *
1310  */
1311 //+------------------------------------------------------------------
1312 void DiffractometerDevice::copy_current_crystal_as(Tango::DevString argin)
1313 {
1314         DEBUG_STREAM << "DiffractometerDevice::copy_current_crystal_as(): entering... !" << endl;
1315
1316         //      Add your own code to control device here
1317
1318         /* POGO rename SampleCopy */
1319
1320         if(_hklAdapter){
1321                 _hklAdapter->copy_sample_as(argin);
1322                 this->refresh_crystal_parameters();
1323                 this->save();
1324         }
1325 }
1326
1327 //+------------------------------------------------------------------
1328 /**
1329  *      method: DiffractometerDevice::delete_current_crystal
1330  *
1331  *      description:    method to execute "DeleteCurrentCrystal"
1332  *      Delete the current from this device
1333  *
1334  *
1335  */
1336 //+------------------------------------------------------------------
1337 void DiffractometerDevice::delete_current_crystal()
1338 {
1339         DEBUG_STREAM << "DiffractometerDevice::delete_current_crystal(): entering... !" << endl;
1340
1341         //      Add your own code to control device here
1342
1343         /* POGO rename SampleDelete */
1344
1345         if(_hklAdapter){
1346                 _hklAdapter->del_sample();
1347                 this->refresh_crystal_parameters();
1348                 this->save();
1349         }
1350 }
1351
1352 //+------------------------------------------------------------------
1353 /**
1354  *      method: DiffractometerDevice::get_affinement_iteration
1355  *
1356  *      description:    method to execute "GetAffinementIteration"
1357  *      This commands redefine the maximum of iteration for an affinement.
1358  *
1359  *      Arg in :
1360  *
1361  *      Affinement Name
1362  *
1363  *      Arg out :
1364  *
1365  *      Iteration value of the last calculation
1366  *
1367  * @param       argin   Affinement name
1368  * @return      Iteration value of the last calculation
1369  *
1370  */
1371 //+------------------------------------------------------------------
1372 Tango::DevLong DiffractometerDevice::get_affinement_iteration(Tango::DevString argin)
1373 {
1374         Tango::DevLong  argout ;
1375         DEBUG_STREAM << "DiffractometerDevice::get_affinement_iteration(): entering... !" << endl;
1376
1377         /* TO DELETE */
1378
1379         return argout;
1380 }
1381
1382 //+------------------------------------------------------------------
1383 /**
1384  *      method: DiffractometerDevice::get_affinement_list
1385  *
1386  *      description:    method to execute "GetAffinementList"
1387  *      This commands returns the list of Affinement names.
1388  *
1389  * @return      List of Affinement names
1390  *
1391  */
1392 //+------------------------------------------------------------------
1393 Tango::DevVarStringArray *DiffractometerDevice::get_affinement_list()
1394 {
1395         //      POGO has generated a method core with argout allocation.
1396         //      If you would like to use a static reference without copying,
1397         //      See "TANGO Device Server Programmer's Manual"
1398         //              (chapter : Writing a TANGO DS / Exchanging data)
1399         //------------------------------------------------------------
1400         Tango::DevVarStringArray        *argout  = new Tango::DevVarStringArray();
1401
1402         /* TO DELETE */
1403
1404         return argout;
1405 }
1406
1407 //+------------------------------------------------------------------
1408 /**
1409  *      method: DiffractometerDevice::get_affinement_max_iteration
1410  *
1411  *      description:    method to execute "GetAffinementMaxIteration"
1412  *      This commands redefine the maximum of iteration for an affinement.
1413  *
1414  *      Arg in :
1415  *
1416  *      Affinement Name
1417  *
1418  *      Arg out :
1419  *
1420  *      Value of the maximum
1421  *
1422  * @param       argin   Affinement name
1423  * @return      Value of iteration max
1424  *
1425  */
1426 //+------------------------------------------------------------------
1427 Tango::DevLong DiffractometerDevice::get_affinement_max_iteration(Tango::DevString argin)
1428 {
1429         Tango::DevLong  argout ;
1430         DEBUG_STREAM << "DiffractometerDevice::get_affinement_max_iteration(): entering... !" << endl;
1431
1432         //      Add your own code to control device here
1433
1434         /* TO DELETE */
1435
1436         return argout;
1437 }
1438
1439 //+------------------------------------------------------------------
1440 /**
1441  *      method: DiffractometerDevice::get_crystal_names
1442  *
1443  *      description:    method to execute "GetCrystalNames"
1444  *      Return all crystals names registed into the device
1445  *
1446  * @return      all crystals names registed
1447  *
1448  */
1449 //+------------------------------------------------------------------
1450 Tango::DevVarStringArray *DiffractometerDevice::get_crystal_names()
1451 {
1452         //      POGO has generated a method core with argout allocation.
1453         //      If you would like to use a static reference without copying,
1454         //      See "TANGO Device Server Programmer's Manual"
1455         //              (chapter : Writing a TANGO DS / Exchanging data)
1456         //------------------------------------------------------------
1457         Tango::DevVarStringArray        *argout  = new Tango::DevVarStringArray();
1458         argout->length(1);
1459         (*argout)[0] = CORBA::string_dup("dummy");
1460         DEBUG_STREAM << "DiffractometerDevice::get_crystal_names(): entering... !" << endl;
1461
1462         /* POGO TO DELETE */
1463         if(_hklAdapter)
1464                 *argout << _hklAdapter->get_samples_names();
1465
1466         return argout;
1467 }
1468
1469 //+------------------------------------------------------------------
1470 /**
1471  *      method: DiffractometerDevice::get_mode_description
1472  *
1473  *      description:    method to execute "GetModeDescription"
1474  *
1475  * @param       argin   mode
1476  * @return      description
1477  *
1478  */
1479 //+------------------------------------------------------------------
1480 Tango::DevString DiffractometerDevice::get_mode_description(Tango::DevString argin)
1481 {
1482         //      POGO has generated a method core with argout allocation.
1483         //      If you would like to use a static reference without copying,
1484         //      See "TANGO Device Server Programmer's Manual"
1485         //              (chapter : Writing a TANGO DS / Exchanging data)
1486         //------------------------------------------------------------
1487         Tango::DevString        argout  = NULL;
1488         DEBUG_STREAM << "DiffractometerDevice::get_mode_description(): entering... !" << endl;
1489
1490         //      Add your own code to control device here
1491
1492         /* POGO TO DELETE */
1493         argout = CORBA::string_dup("toto");
1494
1495         return argout;
1496 }
1497
1498 //+------------------------------------------------------------------
1499 /**
1500  *      method: DiffractometerDevice::get_mode_parameters_names
1501  *
1502  *      description:    method to execute "GetModeParametersNames"
1503  *
1504  * @return      Parameters names of the current mode
1505  *
1506  */
1507 //+------------------------------------------------------------------
1508 Tango::DevVarStringArray *DiffractometerDevice::get_mode_parameters_names()
1509 {
1510         //      POGO has generated a method core with argout allocation.
1511         //      If you would like to use a static reference without copying,
1512         //      See "TANGO Device Server Programmer's Manual"
1513         //              (chapter : Writing a TANGO DS / Exchanging data)
1514         //------------------------------------------------------------
1515         Tango::DevVarStringArray        *argout  = new Tango::DevVarStringArray();
1516         DEBUG_STREAM << "DiffractometerDevice::get_mode_parameters_names(): entering... !" << endl;
1517
1518         //      Add your own code to control device here
1519
1520         /* POGO TO DELETE */
1521         if(_hklAdapter){
1522                 size_t i;
1523                 Matrix<char *> & img = _hklAdapter->get_mode_parameters_names();
1524                 argout->length(img.xdim);
1525                 for(i=0; i<img.xdim; ++i)
1526                         (*argout)[i] = CORBA::string_dup(img.data[i]);
1527         }
1528
1529         return argout;
1530 }
1531
1532 //+------------------------------------------------------------------
1533 /**
1534  *      method: DiffractometerDevice::get_mode_parameters_values
1535  *
1536  *      description:    method to execute "GetModeParametersValues"
1537  *      Double : values of parameters
1538  *
1539  * @return      String : Names of parameters ; Double : values of parameters
1540  *
1541  */
1542 //+------------------------------------------------------------------
1543 Tango::DevVarDoubleStringArray *DiffractometerDevice::get_mode_parameters_values()
1544 {
1545         //      POGO has generated a method core with argout allocation.
1546         //      If you would like to use a static reference without copying,
1547         //      See "TANGO Device Server Programmer's Manual"
1548         //              (chapter : Writing a TANGO DS / Exchanging data)
1549         //------------------------------------------------------------
1550         Tango::DevVarDoubleStringArray  *argout  = new Tango::DevVarDoubleStringArray();
1551         DEBUG_STREAM << "DiffractometerDevice::get_mode_parameters_values(): entering... !" << endl;
1552
1553         //      Add your own code to control device here
1554
1555         /* POGO TO DELETE */
1556         if(_hklAdapter)
1557                 _hklAdapter->get_mode_parameters_values(argout);
1558
1559         return argout;
1560 }
1561
1562 //+------------------------------------------------------------------
1563 /**
1564  *      method: DiffractometerDevice::get_mode_parameter_value
1565  *
1566  *      description:    method to execute "GetModeParameterValue"
1567  *
1568  * @param       argin   name of parameter
1569  * @return      value of this parameter
1570  *
1571  */
1572 //+------------------------------------------------------------------
1573 Tango::DevDouble DiffractometerDevice::get_mode_parameter_value(Tango::DevString argin)
1574 {
1575         Tango::DevDouble        argout ;
1576         DEBUG_STREAM << "DiffractometerDevice::get_mode_parameter_value(): entering... !" << endl;
1577
1578         //      Add your own code to control device here
1579
1580         /* POGO TO DELETE */
1581
1582         return argout;
1583 }
1584
1585 //+------------------------------------------------------------------
1586 /**
1587  *      method: DiffractometerDevice::get_reflection
1588  *
1589  *      description:    method to execute "GetReflection"
1590  *
1591  * @param       argin   index of reflection
1592  * @return      H, K, L, Relevance, Affinement Enabled
1593  *
1594  */
1595 //+------------------------------------------------------------------
1596 Tango::DevVarDoubleArray *DiffractometerDevice::get_reflection(Tango::DevShort argin)
1597 {
1598         //      POGO has generated a method core with argout allocation.
1599         //      If you would like to use a static reference without copying,
1600         //      See "TANGO Device Server Programmer's Manual"
1601         //              (chapter : Writing a TANGO DS / Exchanging data)
1602         //------------------------------------------------------------
1603         Tango::DevVarDoubleArray        *argout  = new Tango::DevVarDoubleArray();
1604         DEBUG_STREAM << "DiffractometerDevice::get_reflection(): entering... !" << endl;
1605
1606         //      Add your own code to control device here
1607
1608         /* POGO replace by a Reflections attribut read/write */
1609         if(_hklAdapter)
1610                 _hklAdapter->get_sample_reflection(argin, argout);
1611
1612         return argout;
1613 }
1614
1615 //+------------------------------------------------------------------
1616 /**
1617  *      method: DiffractometerDevice::get_reflection_size
1618  *
1619  *      description:    method to execute "GetReflectionSize"
1620  *      Return the number of reflection of the current crystal
1621  *
1622  * @return      Number of reflection in current crytal
1623  *
1624  */
1625 //+------------------------------------------------------------------
1626 Tango::DevUShort DiffractometerDevice::get_reflection_size()
1627 {
1628         Tango::DevUShort        argout ;
1629         DEBUG_STREAM << "DiffractometerDevice::get_reflection_size(): entering... !" << endl;
1630
1631         //      Add your own code to control device here
1632
1633         /* POGO TO DELETE */
1634
1635         return argout;
1636 }
1637
1638 //+------------------------------------------------------------------
1639 /**
1640  *      method: DiffractometerDevice::goto_reflection
1641  *
1642  *      description:    method to execute "GotoReflection"
1643  *      Go to axis values of the given reflection
1644  *
1645  * @param       argin   reflection number
1646  *
1647  */
1648 //+------------------------------------------------------------------
1649 void DiffractometerDevice::goto_reflection(Tango::DevShort argin)
1650 {
1651         DEBUG_STREAM << "DiffractometerDevice::goto_reflection(): entering... !" << endl;
1652
1653         //      Add your own code to control device here
1654
1655         /* POGO replace by a SampleReflectionAxisGoTo */
1656 }
1657
1658 //+------------------------------------------------------------------
1659 /**
1660  *      method: DiffractometerDevice::load
1661  *
1662  *      description:    method to execute "Load"
1663  *      Load all crystals
1664  *
1665  *
1666  */
1667 //+------------------------------------------------------------------
1668 void DiffractometerDevice::load()
1669 {
1670         DEBUG_STREAM << "DiffractometerDevice::load(): entering... !" << endl;
1671
1672         //      Add your own code to control device here
1673
1674         /* TODO MOVE to the DiffractometerDeviceExtra */
1675         /* POGO remove the command */
1676
1677         /*
1678         // Get the Crystal Attributes properties.
1679         Tango::DbData properties;
1680         properties.push_back(Tango::DbDatum("CurrentCrystal"));
1681         this->get_db_device()->get_attribute_property(properties);
1682
1683         // Get the number of properties
1684         unsigned long nb_crystal = 0;
1685         properties[0] >> nb_crystal;
1686
1687         if (nb_crystal > 0) {
1688                 _diffractometer->samples().clear();
1689                 unsigned long i, j;
1690
1691                 for(i=1; i<=nb_crystal; i++) {
1692                         // The name of the property name is the name of a crystal.
1693                         const std::string & name = properties[i].name;
1694                         hkl::Sample * sample;
1695                         sample = _diffractometer->samples().add(name, hkl::SAMPLE_MONOCRYSTAL);
1696                         if (sample)
1697                                 _diffractometer->samples().set_current(name);
1698
1699                         // Extract the lines store in the property
1700                         std::vector<std::string> lines;
1701                         properties[i] >> lines;
1702
1703                         for(j=0; j<lines.size(); j++) {
1704                                 char *line = strdup(lines[j].c_str());
1705                                 char *last;
1706                                 char *key = strtok_r(line, "=", &last);
1707
1708                                 if(!strcmp(key,"wavelength")) {
1709                                         double lambda = atof(strtok_r(NULL, ";", &last));
1710                                         if(lambda <= 0.0)
1711                                                 lambda = 1.54;
1712                                         _diffractometer->geometry()->get_source().setWaveLength(lambda);
1713                                 } else if (!strcmp(key,"lattice")) {
1714                                         double a = atof(strtok_r(NULL, ";", &last));
1715                                         double b = atof(strtok_r(NULL, ";", &last));
1716                                         double c = atof(strtok_r(NULL, ";", &last));
1717                                         double alpha = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
1718                                         double beta = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
1719                                         double gamma = atof(strtok_r(NULL, ";", &last)) * HKL_DEGTORAD;
1720
1721                                         hkl::Lattice & lattice = sample->lattice();
1722                                         lattice.a().set_current(a);
1723                                         lattice.b().set_current(b);
1724                                         lattice.c().set_current(c);
1725                                         lattice.alpha().set_current(alpha);
1726                                         lattice.beta().set_current(beta);
1727                                         lattice.gamma().set_current(gamma);
1728                                 } else if (!strcmp(key,"reflection")) {
1729                                         unsigned int idx = 0;
1730                                         hkl::AxeList const & axes = _diffractometer->geometry()->get_axes();
1731
1732                                         double h  = atof(strtok_r(NULL, ";", &last));
1733                                         double k  = atof(strtok_r(NULL, ";", &last));
1734                                         double l  = atof(strtok_r(NULL, ";", &last));
1735                                         // int relevance = values.nextIntToken();
1736                                         // no more need of this relevance but extract never the less
1737                                         strtok_r(NULL, ";", &last);
1738                                         bool flag = atoi(strtok_r(NULL, ";", &last)) > 0;
1739                                         while(key = strtok_r(NULL, ";", &last))
1740                                                 axes[idx++]->set_current(atof(key) * HKL_DEGTORAD);
1741
1742                                         // Create reflection
1743                                         hkl::Reflection & reflection = sample->reflections().add(hkl::svector(h, k, l));
1744                                         reflection.flag() = flag;
1745                                 }
1746                                 free(line);
1747                                 // End of key research
1748                         }// End for each parameters
1749                 }// End for each property
1750
1751                 this->refresh_crystal_parameters();
1752         }
1753         */
1754 }
1755
1756 //+------------------------------------------------------------------
1757 /**
1758  *      method: DiffractometerDevice::remove_reflection
1759  *
1760  *      description:    method to execute "RemoveReflection"
1761  *      This commands removes reflection from the current cristal.
1762  *
1763  * @param       argin   index of reflection to remove
1764  *
1765  */
1766 //+------------------------------------------------------------------
1767 void DiffractometerDevice::remove_reflection(Tango::DevShort argin)
1768 {
1769         DEBUG_STREAM << "DiffractometerDevice::remove_reflection(): entering... !" << endl;
1770
1771         //      Add your own code to control device here
1772
1773         /* POGO rename SampleReflectionDelete */
1774         if(_hklAdapter){
1775                 _hklAdapter->del_reflection(argin);
1776                 this->refresh_crystal_parameters();
1777                 this->save();
1778         }
1779 }
1780
1781 //+------------------------------------------------------------------
1782 /**
1783  *      method: DiffractometerDevice::save
1784  *
1785  *      description:    method to execute "Save"
1786  *      Save all crystals
1787  *
1788  *
1789  */
1790 //+------------------------------------------------------------------
1791 void DiffractometerDevice::save()
1792 {
1793         DEBUG_STREAM << "DiffractometerDevice::save(): entering... !" << endl;
1794
1795         //      Add your own code to control device here
1796
1797         /*
1798         // Step 1 : clean all properties
1799         // FP Le mieux serait sans doute de ne pas effacer les propriétés d'attribut
1800         // avant d'avoir crée correctement un data_put.
1801         Tango::DbData current_crystal_prop;
1802         current_crystal_prop.push_back(Tango::DbDatum("CurrentCrystal"));
1803         this->get_db_device()->get_attribute_property(current_crystal_prop);
1804         long number_of_prop = 0;
1805         current_crystal_prop[0] >> number_of_prop ;
1806         if( number_of_prop > 0)
1807                 this->get_db_device()->delete_attribute_property(current_crystal_prop);
1808
1809         // Step 2 : get the Crystal properties
1810         Tango::DbData data_put;
1811         Tango::DbDatum attribute("CurrentCrystal");
1812         // Put number of properties (= nb of samples)
1813         attribute << (long)_diffractometer->samples().size();
1814         data_put.push_back(attribute);
1815         // Create each property
1816         hkl::SampleList::iterator it = _diffractometer->samples().begin();
1817         hkl::SampleList::iterator end = _diffractometer->samples().end();
1818         while (it != end) {
1819                 hkl::Sample * sample = *it;
1820                 std::vector<std::string> lines;
1821                 char line[256];
1822
1823                 // Get Wavelength
1824                 double wavelength = _diffractometer->geometry()->get_source().get_waveLength().get_value();
1825                 snprintf(line, 255, "wavelength=%f", wavelength);
1826                 lines.push_back(line);
1827
1828                 // get its lattices values
1829                 hkl::Lattice & lattice = sample->lattice();
1830                 double a = lattice.a().get_current().get_value();
1831                 double b = lattice.b().get_current().get_value();
1832                 double c = lattice.c().get_current().get_value();
1833                 double alpha = lattice.alpha().get_current().get_value() * HKL_RADTODEG;
1834                 double beta = lattice.beta().get_current().get_value() * HKL_RADTODEG;
1835                 double gamma = lattice.gamma().get_current().get_value() * HKL_RADTODEG;
1836
1837                 snprintf(line, 255, "lattice=%f;%f;%f;%f;%f;%f",
1838                                 a, b, c, alpha, beta, gamma);
1839                 lines.push_back(line);
1840
1841                 // get reflection
1842                 unsigned int i, j;
1843                 hkl::ReflectionList & reflections = sample->reflections();
1844                 for(i=0; i<reflections.size(); i++) {
1845                         hkl::Reflection * reflection = reflections[i];
1846                         hkl::svector const & hkl = reflection->get_hkl();
1847                         hkl::AxeList const & axes = reflection->get_geometry().get_axes();
1848                         snprintf(line, 255, "reflection=%f;%f;%f;%d;%d",
1849                                         hkl.x(), hkl.y(), hkl.z(),
1850                                         1, reflection->flag());
1851                         // Extract values of each axes
1852                         for(j=0; j<axes.size(); j++) {
1853                                 char pos[256];
1854                                 double rad = axes[j]->get_current().get_value() * HKL_RADTODEG;
1855                                 snprintf(pos, 255, ";%f", rad);
1856                                 strncat(line, pos, 255);
1857                         }
1858
1859                         lines.push_back(line);
1860                 }
1861
1862                 // Try to create property
1863                 // Get crystal name
1864                 Tango::DbDatum property((*it)->get_name());
1865                 property << lines;
1866                 data_put.push_back(property);
1867                 ++it;
1868         }
1869
1870         //update database for this property
1871         this->get_db_device()->put_attribute_property(data_put);
1872         */
1873 }
1874
1875 //+------------------------------------------------------------------
1876 /**
1877  *      method: DiffractometerDevice::set_affinement_max_iteration
1878  *
1879  *      description:    method to execute "SetAffinementMaxIteration"
1880  *      This commands redefine the maximum of iteration for an affinement.
1881  *      index = index of reflection
1882  *      h = h value
1883  *      k = k value
1884  *      l = l valuee
1885  *      relevance = relevance value of this reflection
1886  *      affinement enabled = if true this reflection is associated with Affinement calculation
1887  *
1888  * @param       argin   Affinement name, Value of iteration max
1889  *
1890  */
1891 //+------------------------------------------------------------------
1892 void DiffractometerDevice::set_affinement_max_iteration(const Tango::DevVarStringArray *argin)
1893 {
1894         DEBUG_STREAM << "DiffractometerDevice::set_affinement_max_iteration(): entering... !" << endl;
1895
1896         //      Add your own code to control device here
1897
1898         /* POGO TO DELETE */
1899 }
1900
1901 //+------------------------------------------------------------------
1902 /**
1903  *      method: DiffractometerDevice::set_crystal_parameter_values
1904  *
1905  *      description:    method to execute "SetCrystalParameterValues"
1906  *      Double : min value, max value, affinement enable
1907  *
1908  * @param       argin   String : Name of parameter ; Double : min value, max value, affinement enable
1909  *
1910  */
1911 //+------------------------------------------------------------------
1912 void DiffractometerDevice::set_crystal_parameter_values(const Tango::DevVarDoubleStringArray *argin)
1913 {
1914         DEBUG_STREAM << "DiffractometerDevice::set_crystal_parameter_values(): entering... !" << endl;
1915
1916         //      Add your own code to control device here
1917
1918         // check Parameters
1919         if(_hklAdapter)
1920                 _hklAdapter->set_sample_parameter_values(argin);
1921 }
1922
1923 //+------------------------------------------------------------------
1924 /**
1925  *      method: DiffractometerDevice::set_hkl
1926  *
1927  *      description:    method to execute "SetHKL"
1928  *      This command will set the triplet (h,k,l
1929  *
1930  * @param       argin   h,k,l values
1931  *
1932  */
1933 //+------------------------------------------------------------------
1934 void DiffractometerDevice::set_hkl(const Tango::DevVarDoubleArray *argin)
1935 {
1936         DEBUG_STREAM << "DiffractometerDevice::set_hkl(): entering... !" << endl;
1937
1938         //      Add your own code to control device here
1939
1940         if(argin->length() != 3)
1941                 TANGO_EXCEPTION_THROW("DATA_OUT_OF_RANGE", "set_hkl did not receive the exact amount of parameters: h, k, l");
1942
1943         // try to set up hkl.
1944         this->compute_angles((*argin)[0], (*argin)[1], (*argin)[2]);
1945 }
1946
1947 //+------------------------------------------------------------------
1948 /**
1949  *      method: DiffractometerDevice::set_mode_parameters_values
1950  *
1951  *      description:    method to execute "SetModeParametersValues"
1952  *      Double : value of parameter
1953  *
1954  * @param       argin   String : name of parameter ; Double : value of parameter
1955  *
1956  */
1957 //+------------------------------------------------------------------
1958 void DiffractometerDevice::set_mode_parameters_values(const Tango::DevVarDoubleStringArray *argin)
1959 {
1960         DEBUG_STREAM << "DiffractometerDevice::set_mode_parameters_values(): entering... !" << endl;
1961
1962         //      Add your own code to control device here
1963
1964         // Check if argin is like (key,value)
1965         if(_hklAdapter)
1966                 _hklAdapter->set_mode_parameters_values(argin);
1967 }
1968
1969 //+------------------------------------------------------------------
1970 /**
1971  *      method: DiffractometerDevice::set_reflection
1972  *
1973  *      description:    method to execute "SetReflection"
1974  *      This commands redefine the parameters of 1 reflection of the current cristal.
1975  *      index = index of reflection
1976  *      h = h value
1977  *      k = k value
1978  *      l = l valuee
1979  *      relevance = relevance value of this reflection
1980  *      affinement enabled = if true this reflection is associated with Affinement calculation
1981  *
1982  * @param       argin   reflections i.e :  index, h, k, l, relevance, affinement enabled
1983  *
1984  */
1985 //+------------------------------------------------------------------
1986 void DiffractometerDevice::set_reflection(const Tango::DevVarDoubleArray *argin)
1987 {
1988         DEBUG_STREAM << "DiffractometerDevice::set_reflection(): entering... !" << endl;
1989
1990         //      Add your own code to control device here
1991
1992         /* POGO TO DELETE */
1993         if(_hklAdapter)
1994                 _hklAdapter->set_sample_reflection(argin);
1995 }
1996
1997 //+------------------------------------------------------------------
1998 /**
1999  *      method: DiffractometerDevice::copy_reflection_to
2000  *
2001  *      description:    method to execute "CopyReflectionTo"
2002  *      Copy one reflection from the current crystal to another crystal
2003  *
2004  * @param       argin   Double: Reflection number of the current crystal String : Name of the crystal where copy this reflection
2005  *
2006  */
2007 //+------------------------------------------------------------------
2008 void DiffractometerDevice::copy_reflection_to(const Tango::DevVarDoubleStringArray *argin)
2009 {
2010         DEBUG_STREAM << "DiffractometerDevice::copy_reflection_to(): entering... !" << endl;
2011
2012         //      Add your own code to control device here
2013
2014         /* POGO TO DELETE */
2015 }
2016
2017 //+------------------------------------------------------------------
2018 /**
2019  *      method: DiffractometerDevice::dev_state
2020  *
2021  *      description:    method to execute "State"
2022  *      This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
2023  *
2024  * @return      State Code
2025  *
2026  */
2027 //+------------------------------------------------------------------
2028 Tango::DevState DiffractometerDevice::dev_state()
2029 {
2030         Tango::DevState argout = DeviceImpl::dev_state();
2031         DEBUG_STREAM << "DiffractometerDevice::dev_state(): entering... !" << endl;
2032
2033         //      Add your own code to control device here
2034
2035         std::string status;
2036
2037         if (_hklAdapter)
2038                 _hklAdapter->getDiffractometerStateAndStatus(argout, status);
2039         else {
2040                 argout = Tango::FAULT;
2041                 status = "Diffractometer core not yet initialized !!!!";
2042         }
2043         this->set_status(status);
2044         this->set_state(argout);
2045
2046         return argout;
2047 }
2048
2049 //+------------------------------------------------------------------
2050 /**
2051  *      method: DiffractometerDevice::get_crystal_parameter_values
2052  *
2053  *      description:    method to execute "GetCrystalParameterValues"
2054  *      Return all values of a parameter for the current crystal
2055  *
2056  * @param       argin   Name of parameter (see getParametersNames for the complete list of parameters)
2057  * @return      In the order : minimum value, maximum value, affinement enable
2058  *
2059  */
2060 //+------------------------------------------------------------------
2061 Tango::DevVarDoubleStringArray *DiffractometerDevice::get_crystal_parameter_values(Tango::DevString argin)
2062 {
2063         //      POGO has generated a method core with argout allocation.
2064         //      If you would like to use a static reference without copying,
2065         //      See "TANGO Device Server Programmer's Manual"
2066         //              (chapter : Writing a TANGO DS / Exchanging data)
2067         //------------------------------------------------------------
2068         Tango::DevVarDoubleStringArray  *argout  = new Tango::DevVarDoubleStringArray();
2069         argout->dvalue.length(3);
2070         argout->dvalue[0] = 0.0;
2071         argout->dvalue[1] = 0.0;
2072         argout->dvalue[2] = 0.0;
2073         argout->svalue.length(1);
2074         argout->svalue[0] = CORBA::string_dup(argin);
2075         DEBUG_STREAM << "DiffractometerDevice::get_crystal_parameter_values(): entering... !" << endl;
2076
2077         //      Add your own code to control device here
2078         if(_hklAdapter)
2079                 _hklAdapter->get_sample_parameter_values(argout);
2080
2081         return argout;
2082 }
2083
2084 //+------------------------------------------------------------------
2085 /**
2086  *      method: DiffractometerDevice::compute_u
2087  *
2088  *      description:    method to execute "ComputeU"
2089  *      Compute Matrix U from two reflections
2090  *
2091  * @param       argin   a two elements array with the index of reflection to use
2092  *
2093  */
2094 //+------------------------------------------------------------------
2095 void DiffractometerDevice::compute_u(const Tango::DevVarLongArray *argin)
2096 {
2097         DEBUG_STREAM << "DiffractometerDevice::compute_u(): entering... !" << endl;
2098
2099         //      Add your own code to control device here
2100         if(_hklAdapter){
2101                 _hklAdapter->compute_u(argin);
2102                 this->save();
2103         }
2104 }
2105
2106 //+------------------------------------------------------------------
2107 /**
2108  *      method: DiffractometerDevice::get_axes_names
2109  *
2110  *      description:    method to execute "GetAxesNames"
2111  *      this method return the names of the dynamic attributes created from the hkl axes names
2112  *      kappa -> AxisKappa etc...
2113  *
2114  * @return      namers of the axes
2115  *
2116  */
2117 //+------------------------------------------------------------------
2118 Tango::DevVarStringArray *DiffractometerDevice::get_axes_names()
2119 {
2120         //      POGO has generated a method core with argout allocation.
2121         //      If you would like to use a static reference without copying,
2122         //      See "TANGO Device Server Programmer's Manual"
2123         //              (chapter : Writing a TANGO DS / Exchanging data)
2124         //------------------------------------------------------------
2125         Tango::DevVarStringArray        *argout  = new Tango::DevVarStringArray();
2126         unsigned int len = _dynamic_attributes.size();
2127         argout->length(len);
2128         DEBUG_STREAM << "DiffractometerDevice::get_axes_names(): entering... !" << endl;
2129
2130         //      Add your own code to control device here
2131         for(unsigned int i=0; i<len; ++i)
2132                 (*argout)[i] = CORBA::string_dup(_dynamic_attributes[i]->get_name().c_str());
2133         return argout;
2134 }
2135
2136 //+------------------------------------------------------------------
2137 /**
2138  *      method: DiffractometerDevice::computed_angles_clear
2139  *
2140  *      description:    method to execute "ComputedAnglesClear"
2141  *      Clears the attribute ComputedAngles.
2142  *      Useful to get a fresh view of calculations already made
2143  *
2144  *
2145  */
2146 //+------------------------------------------------------------------
2147 void DiffractometerDevice::computed_angles_clear()
2148 {
2149         DEBUG_STREAM << "DiffractometerDevice::computed_angles_clear(): entering... !" << endl;
2150
2151         //      Add your own code to control device here
2152         _computedAngles_size = 0;
2153         if(attr_ComputedAngles_read) {
2154                 delete [] attr_ComputedAngles_read;
2155                 attr_ComputedAngles_read = NULL;
2156         }
2157
2158 }
2159
2160 //+------------------------------------------------------------------
2161 /**
2162  *      method: DiffractometerDevice::computed_angles_hkllist
2163  *
2164  *      description:    method to execute "ComputedAnglesHKLList"
2165  *      this commande  works only in simulated mode.
2166  *      It computhe [-hmax: hmax] etc.. angles computations.
2167  *
2168  * @param       argin   hmax, kmax, lmax
2169  *
2170  */
2171 //+------------------------------------------------------------------
2172 void DiffractometerDevice::computed_angles_hkllist(const Tango::DevVarDoubleArray *argin)
2173 {
2174         DEBUG_STREAM << "DiffractometerDevice::computed_angles_hkllist(): entering... !" << endl;
2175
2176         //      Add your own code to control device here
2177
2178         if((argin->length() != 3) && (argin->length() != 6))
2179                 TANGO_EXCEPTION_THROW("DATA_OUT_OF_RANGE", "computed_angles_hkllist did not receive the exact amount of parameters: hmax, kmax, lmax");
2180
2181         // Parameters are OK
2182         if (!_hklAdapter->simulated)
2183                 return;
2184
2185         double h, k, l;
2186         double hmax = fabs((*argin)[0]);
2187         double kmax = fabs((*argin)[1]);
2188         double lmax = fabs((*argin)[2]);
2189         double dh, dk, dl;
2190         if (argin->length() == 6) {
2191                 dh = fabs((*argin)[3]);
2192                 dk = fabs((*argin)[4]);
2193                 dl = fabs((*argin)[5]);
2194         } else
2195                 dh = dk = dl = 1.;
2196         h = -hmax;
2197         while(h <= hmax) {
2198                 k = -kmax;
2199                 while(k <= kmax) {
2200                         l = -lmax;
2201                         while(l <= lmax) {
2202                                 try {
2203                                         this->compute_angles(h, k, l);
2204                                 }
2205                                 catch(...)
2206                                 {}
2207                                 l += dl;
2208                         }
2209                         k += dk;
2210                 }
2211                 h += dh;
2212         }
2213 }
2214
2215
2216 //+------------------------------------------------------------------
2217 /**
2218  *      method: DiffractometerDevice::goto_computed_angles
2219  *
2220  *      description:    method to execute "GotoComputedAngles"
2221  *
2222  * @param       argin   the idx of the computed angles
2223  *
2224  */
2225 //+------------------------------------------------------------------
2226 void DiffractometerDevice::goto_computed_angles(Tango::DevShort argin)
2227 {
2228         DEBUG_STREAM << "DiffractometerDevice::goto_computed_angles(): entering... !" << endl;
2229
2230         //      Add your own code to control device here
2231
2232 }
2233
2234
2235
2236 }       //      namespace