src/Diffractometer/Diffractometer.cpp

   1 static const char *RcsId = "$Header: /cvsroot/tango-ds/Instrumentation/Diffractometer/src/Diffractometer.cpp,v 1.5 2008/11/28 15:46:32 piccaf Exp $";
   2 //+=============================================================================
   3 //
   4 // file :         Diffractometer.cpp
   5 //
   6 // description :  C++ source for the Diffractometer 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 //                Diffractometer are implemented in this file.
  11 //
  12 // project :      TANGO Device Server
  13 //
  14 // $Author: piccaf $
  15 //
  16 // $Revision: 1.5 $
  17 //
  18 // $Log: Diffractometer.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 //  ComputeU                   |  compute_u()
  62 //  ConfigureCrystal           |  configure_crystal()
  63 //  CopyCurrentCrystalAs       |  copy_current_crystal_as()
  64 //  CopyReflectionTo           |  copy_reflection_to()
  65 //  DeleteCurrentCrystal       |  delete_current_crystal()
  66 //  GetCrystalParameterValues  |  get_crystal_parameter_values()
  67 //  Load                       |  load()
  68 //  RemoveReflection           |  remove_reflection()
  69 //  Save                       |  save()
  70 //  SetCrystalParameterValues  |  set_crystal_parameter_values()
  71 //
  72 //===================================================================
  73
  74
  75 #include <tango.h>
  76 #include <Diffractometer.h>
  77 #include <DiffractometerClass.h>
  78
  79 #include <time.h>
  80 #include <sstream>
  81 #include <algorithm>
  82 #include <cctype>
  83 #include <string>
  84
  85 #include "macros.h"
  86 #include "AxisAttrib.h"
  87 #include "TangoHKLAdapterFactory.h"
  88
  89 namespace Diffractometer_ns
  90 {
  91
  92 //+----------------------------------------------------------------------------
  93 //
  94 // method :             Diffractometer::Diffractometer(string &s)
  95 //
  96 // description :        constructor for simulated Diffractometer
  97 //
  98 // in : - cl : Pointer to the DeviceClass object
  99 //      - s : Device name
 100 //
 101 //-----------------------------------------------------------------------------
 102 Diffractometer::Diffractometer(Tango::DeviceClass *cl,string &s)
 103 :Tango::Device_3Impl(cl,s.c_str())
 104 {
 105         init_device();
 106 }
 107
 108 Diffractometer::Diffractometer(Tango::DeviceClass *cl,const char *s)
 109 :Tango::Device_3Impl(cl,s)
 110 {
 111         init_device();
 112 }
 113
 114 Diffractometer::Diffractometer(Tango::DeviceClass *cl,const char *s,const char *d)
 115 :Tango::Device_3Impl(cl,s,d)
 116 {
 117         init_device();
 118 }
 119 //+----------------------------------------------------------------------------
 120 //
 121 // method :             Diffractometer::delete_device()
 122 //
 123 // description :        will be called at device destruction or at init command.
 124 //
 125 //-----------------------------------------------------------------------------
 126 void Diffractometer::delete_device()
 127 {
 128         //      Delete device's allocated object
 129         this->save();
 130
 131         // Delete device's allocated object
 132         DELETE_SCALAR_ATTRIBUTE(attr_AnglesIdx_read);
 133         DELETE_SCALAR_ATTRIBUTE(attr_WaveLength_read);
 134         DELETE_SCALAR_ATTRIBUTE(attr_AutoUpdateFromProxies_read);
 135         DELETE_SCALAR_ATTRIBUTE(attr_Simulated_read);
 136         DELETE_SCALAR_ATTRIBUTE(attr_A_read);
 137         DELETE_SCALAR_ATTRIBUTE(attr_B_read);
 138         DELETE_SCALAR_ATTRIBUTE(attr_C_read);
 139         DELETE_SCALAR_ATTRIBUTE(attr_Alpha_read);
 140         DELETE_SCALAR_ATTRIBUTE(attr_Beta_read);
 141         DELETE_SCALAR_ATTRIBUTE(attr_Gamma_read);
 142         DELETE_SCALAR_ATTRIBUTE(attr_Ux_read);
 143         DELETE_SCALAR_ATTRIBUTE(attr_Uy_read);
 144         DELETE_SCALAR_ATTRIBUTE(attr_Uz_read);
 145         DELETE_SCALAR_ATTRIBUTE(attr_AStar_read);
 146         DELETE_SCALAR_ATTRIBUTE(attr_BStar_read);
 147         DELETE_SCALAR_ATTRIBUTE(attr_CStar_read);
 148         DELETE_SCALAR_ATTRIBUTE(attr_AlphaStar_read);
 149         DELETE_SCALAR_ATTRIBUTE(attr_BetaStar_read);
 150         DELETE_SCALAR_ATTRIBUTE(attr_GammaStar_read);
 151         DELETE_SCALAR_ATTRIBUTE(attr_AFit_read);
 152         DELETE_SCALAR_ATTRIBUTE(attr_BFit_read);
 153         DELETE_SCALAR_ATTRIBUTE(attr_CFit_read);
 154         DELETE_SCALAR_ATTRIBUTE(attr_AlphaFit_read);
 155         DELETE_SCALAR_ATTRIBUTE(attr_BetaFit_read);
 156         DELETE_SCALAR_ATTRIBUTE(attr_GammaFit_read);
 157         DELETE_SCALAR_ATTRIBUTE(attr_UxFit_read);
 158         DELETE_SCALAR_ATTRIBUTE(attr_UyFit_read);
 159         DELETE_SCALAR_ATTRIBUTE(attr_UzFit_read);
 160
 161         DELETE_DEVSTRING_ATTRIBUTE(attr_Crystal_read);
 162
 163         if(attr_UB_read) {
 164                 delete[] attr_UB_read;
 165                 attr_UB_read = NULL;
 166         }
 167
 168         if(attr_ReflectionsAngles_read) {
 169                 delete [] attr_ReflectionsAngles_read;
 170                 attr_ReflectionsAngles_read = NULL;
 171         }
 172
 173         if(attr_Reflections_read){
 174                 delete[] attr_Reflections_read;
 175                 attr_Reflections_read = NULL;
 176         }
 177
 178         this->remove_dynamic_attributes();
 179
 180         /*
 181          * Do not remove the diffractometer in the delete method
 182          * of the Derived classes to avoid a segmentation fault
 183          * during the save method call. Indeed the Derived class delete
 184          * method is called before this delete method.
 185          */
 186         TangoHKLAdapterFactory::instance()->detach_diffractometer_device(this);
 187 }
 188
 189 //+----------------------------------------------------------------------------
 190 //
 191 // method :             Diffractometer::init_device()
 192 //
 193 // description :        will be called at device initialization.
 194 //
 195 //-----------------------------------------------------------------------------
 196 void Diffractometer::init_device()
 197 {
 198         INFO_STREAM << "Diffractometer::Diffractometer() create device " << device_name << endl;
 199
 200         // Initialise variables to default values
 201         //--------------------------------------------
 202         get_device_property();
 203
 204         CREATE_SCALAR_ATTRIBUTE(attr_AnglesIdx_read, (short)-1);
 205         CREATE_SCALAR_ATTRIBUTE(attr_WaveLength_read, 0.0);
 206         CREATE_SCALAR_ATTRIBUTE(attr_AutoUpdateFromProxies_read, false);
 207         CREATE_SCALAR_ATTRIBUTE(attr_Simulated_read, true);
 208         CREATE_SCALAR_ATTRIBUTE(attr_A_read, 0.0);
 209         CREATE_SCALAR_ATTRIBUTE(attr_B_read, 0.0);
 210         CREATE_SCALAR_ATTRIBUTE(attr_C_read, 0.0);
 211         CREATE_SCALAR_ATTRIBUTE(attr_Alpha_read, 0.0);
 212         CREATE_SCALAR_ATTRIBUTE(attr_Beta_read, 0.0);
 213         CREATE_SCALAR_ATTRIBUTE(attr_Gamma_read, 0.0);
 214         CREATE_SCALAR_ATTRIBUTE(attr_Ux_read, 0.0);
 215         CREATE_SCALAR_ATTRIBUTE(attr_Uy_read, 0.0);
 216         CREATE_SCALAR_ATTRIBUTE(attr_Uz_read, 0.0);
 217         CREATE_SCALAR_ATTRIBUTE(attr_AStar_read);
 218         CREATE_SCALAR_ATTRIBUTE(attr_BStar_read);
 219         CREATE_SCALAR_ATTRIBUTE(attr_CStar_read);
 220         CREATE_SCALAR_ATTRIBUTE(attr_AlphaStar_read);
 221         CREATE_SCALAR_ATTRIBUTE(attr_BetaStar_read);
 222         CREATE_SCALAR_ATTRIBUTE(attr_GammaStar_read);
 223         CREATE_SCALAR_ATTRIBUTE(attr_AFit_read, false);
 224         CREATE_SCALAR_ATTRIBUTE(attr_BFit_read, false);
 225         CREATE_SCALAR_ATTRIBUTE(attr_CFit_read, false);
 226         CREATE_SCALAR_ATTRIBUTE(attr_AlphaFit_read, false);
 227         CREATE_SCALAR_ATTRIBUTE(attr_BetaFit_read, false);
 228         CREATE_SCALAR_ATTRIBUTE(attr_GammaFit_read, false);
 229         CREATE_SCALAR_ATTRIBUTE(attr_UxFit_read, false);
 230         CREATE_SCALAR_ATTRIBUTE(attr_UyFit_read, false);
 231         CREATE_SCALAR_ATTRIBUTE(attr_UzFit_read, false);
 232
 233         CREATE_DEVSTRING_ATTRIBUTE(attr_Crystal_read, 1, "");
 234
 235         attr_UB_read = NULL;
 236         attr_ReflectionsAngles_read = NULL;
 237         attr_Reflections_read = NULL;
 238         attr_AxesNames_read = NULL;
 239
 240         // Device is in FAULT state because it was not yet configured.
 241         this->set_state(Tango::FAULT);
 242         this->set_status("Configure Diffractometer: crystal, wavelength,etc ..");
 243
 244         _type = this->get_type_from_property(diffractometerType);
 245
 246         /*
 247          * this method must be call after get_device_property() as
 248          * TangoHKLAdapter create the axisbuffer from the
 249          * realAxisProxies.
 250          */
 251         _hklAdapter = TangoHKLAdapterFactory::instance()->attach_diffractometer_device(this, _type);
 252         if (!_hklAdapter) {
 253                 this->set_state(Tango::FAULT);
 254                 this->set_status("Fatal can not initialize the hkl library");
 255                 TANGO_EXCEPTION_THROW("Internal Fatal Error", "Device can't get an instance of TangoHKLAdapter");
 256         } else {
 257                 // Restore the Diffractometer state from the last run.
 258                 this->load();
 259
 260                 _hklAdapter->connect_all_proxies();
 261
 262                 // create an start all the PseudoAxes devices.
 263                 _hklAdapter->pseudo_axes_create_and_start_devices();
 264         }
 265 }
 266
 267
 268 //+----------------------------------------------------------------------------
 269 //
 270 // method :             Diffractometer::get_device_property()
 271 //
 272 // description :        Read the device properties from database.
 273 //
 274 //-----------------------------------------------------------------------------
 275 void Diffractometer::get_device_property()
 276 {
 277         //      Initialize your default values here (if not done with  POGO).
 278         //------------------------------------------------------------------
 279
 280         //      Read device properties from database.(Automatic code generation)
 281         //------------------------------------------------------------------
 282         Tango::DbData   dev_prop;
 283         dev_prop.push_back(Tango::DbDatum("TauConstant"));
 284         dev_prop.push_back(Tango::DbDatum("RealAxisProxies"));
 285         dev_prop.push_back(Tango::DbDatum("LambdaAttributeProxy"));
 286         dev_prop.push_back(Tango::DbDatum("DiffractometerType"));
 287
 288         //      Call database and extract values
 289         //--------------------------------------------
 290         if (Tango::Util::instance()->_UseDb==true)
 291                 get_db_device()->get_property(dev_prop);
 292         Tango::DbDatum  def_prop, cl_prop;
 293         DiffractometerClass     *ds_class =
 294                 (static_cast<DiffractometerClass *>(get_device_class()));
 295         int     i = -1;
 296
 297         //      Try to initialize TauConstant from class property
 298         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 299         if (cl_prop.is_empty()==false)  cl_prop  >>  tauConstant;
 300         else {
 301                 //      Try to initialize TauConstant from default device value
 302                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 303                 if (def_prop.is_empty()==false) def_prop  >>  tauConstant;
 304         }
 305         //      And try to extract TauConstant value from database
 306         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  tauConstant;
 307
 308         //      Try to initialize RealAxisProxies from class property
 309         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 310         if (cl_prop.is_empty()==false)  cl_prop  >>  realAxisProxies;
 311         else {
 312                 //      Try to initialize RealAxisProxies from default device value
 313                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 314                 if (def_prop.is_empty()==false) def_prop  >>  realAxisProxies;
 315         }
 316         //      And try to extract RealAxisProxies value from database
 317         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  realAxisProxies;
 318
 319         //      Try to initialize LambdaAttributeProxy from class property
 320         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 321         if (cl_prop.is_empty()==false)  cl_prop  >>  lambdaAttributeProxy;
 322         else {
 323                 //      Try to initialize LambdaAttributeProxy from default device value
 324                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 325                 if (def_prop.is_empty()==false) def_prop  >>  lambdaAttributeProxy;
 326         }
 327         //      And try to extract LambdaAttributeProxy value from database
 328         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  lambdaAttributeProxy;
 329
 330         //      Try to initialize DiffractometerType from class property
 331         cl_prop = ds_class->get_class_property(dev_prop[++i].name);
 332         if (cl_prop.is_empty()==false)  cl_prop  >>  diffractometerType;
 333         else {
 334                 //      Try to initialize DiffractometerType from default device value
 335                 def_prop = ds_class->get_default_device_property(dev_prop[i].name);
 336                 if (def_prop.is_empty()==false) def_prop  >>  diffractometerType;
 337         }
 338         //      And try to extract DiffractometerType value from database
 339         if (dev_prop[i].is_empty()==false)      dev_prop[i]  >>  diffractometerType;
 340
 341
 342
 343         //      End of Automatic code generation
 344         //------------------------------------------------------------------
 345
 346 }
 347 //+----------------------------------------------------------------------------
 348 //
 349 // method :             Diffractometer::always_executed_hook()
 350 //
 351 // description :        method always executed before any command is executed
 352 //
 353 //-----------------------------------------------------------------------------
 354 void Diffractometer::always_executed_hook()
 355 {
 356         if (_hklAdapter)
 357                 _hklAdapter->connect_all_proxies();
 358 }
 359 //+----------------------------------------------------------------------------
 360 //
 361 // method :             Diffractometer::read_attr_hardware
 362 //
 363 // description :        Hardware acquisition for attributes.
 364 //
 365 //-----------------------------------------------------------------------------
 366 void Diffractometer::read_attr_hardware(vector<long> &attr_list)
 367 {
 368         DEBUG_STREAM << "Diffractometer::read_attr_hardware(vector<long> &attr_list) entering... "<< endl;
 369         //      Add your own code here
 370         if (!_hklAdapter)
 371                 return;
 372
 373         _hklAdapter->update();
 374         _hklAdapter->get_diffractometer_config(_config);
 375         _hklAdapter->get_sample_lattices(attr_A_read, attr_B_read, attr_C_read,
 376                                          attr_Alpha_read, attr_Beta_read, attr_Gamma_read,
 377                                          attr_AStar_read, attr_BStar_read, attr_CStar_read,
 378                                          attr_AlphaStar_read, attr_BetaStar_read, attr_GammaStar_read);
 379         _hklAdapter->get_sample_fit(attr_AFit_read, attr_BFit_read, attr_CFit_read,
 380                                     attr_AlphaFit_read, attr_BetaFit_read, attr_GammaFit_read,
 381                                     attr_UxFit_read, attr_UyFit_read, attr_UzFit_read);
 382 }
 383 //+----------------------------------------------------------------------------
 384 //
 385 // method :             Diffractometer::read_AutoUpdateFromProxies
 386 //
 387 // description :        Extract real attribute values for AutoUpdateFromProxies acquisition result.
 388 //
 389 //-----------------------------------------------------------------------------
 390 void Diffractometer::read_AutoUpdateFromProxies(Tango::Attribute &attr)
 391 {
 392         DEBUG_STREAM << "Diffractometer::read_AutoUpdateFromProxies(Tango::Attribute &attr) entering... "<< endl;
 393
 394         if(_hklAdapter)
 395                 *attr_AutoUpdateFromProxies_read = _hklAdapter->get_auto_update_from_proxies();
 396         attr.set_value(attr_AutoUpdateFromProxies_read);
 397 }
 398
 399 //+----------------------------------------------------------------------------
 400 //
 401 // method :             Diffractometer::write_AutoUpdateFromProxies
 402 //
 403 // description :        Write AutoUpdateFromProxies attribute values to hardware.
 404 //
 405 //-----------------------------------------------------------------------------
 406 void Diffractometer::write_AutoUpdateFromProxies(Tango::WAttribute &attr)
 407 {
 408         DEBUG_STREAM << "Diffractometer::write_AutoUpdateFromProxies(Tango::WAttribute &attr) entering... "<< endl;
 409
 410         attr.get_write_value(attr_AutoUpdateFromProxies_write);
 411
 412         if (_hklAdapter)
 413                 _hklAdapter->set_auto_update_from_proxies(attr_AutoUpdateFromProxies_write);
 414 }
 415
 416 //+----------------------------------------------------------------------------
 417 //
 418 // method :             Diffractometer::read_AFit
 419 //
 420 // description :        Extract real attribute values for AFit acquisition result.
 421 //
 422 //-----------------------------------------------------------------------------
 423 void Diffractometer::read_AFit(Tango::Attribute &attr)
 424 {
 425         DEBUG_STREAM << "Diffractometer::read_AFit(Tango::Attribute &attr) entering... "<< endl;
 426         attr.set_value(attr_AFit_read);
 427 }
 428
 429 //+----------------------------------------------------------------------------
 430 //
 431 // method :             Diffractometer::write_AFit
 432 //
 433 // description :        Write AFit attribute values to hardware.
 434 //
 435 //-----------------------------------------------------------------------------
 436 void Diffractometer::write_AFit(Tango::WAttribute &attr)
 437 {
 438         DEBUG_STREAM << "Diffractometer::write_AFit(Tango::WAttribute &attr) entering... "<< endl;
 439         bool fit;
 440
 441         attr.get_write_value(fit);
 442         if (_hklAdapter){
 443                 _hklAdapter->set_sample_AFit(fit);
 444                 this->save();
 445                 attr_AFit_write = fit;
 446         }
 447 }
 448
 449 //+----------------------------------------------------------------------------
 450 //
 451 // method :             Diffractometer::read_BFit
 452 //
 453 // description :        Extract real attribute values for BFit acquisition result.
 454 //
 455 //-----------------------------------------------------------------------------
 456 void Diffractometer::read_BFit(Tango::Attribute &attr)
 457 {
 458         DEBUG_STREAM << "Diffractometer::read_BFit(Tango::Attribute &attr) entering... "<< endl;
 459         attr.set_value(attr_BFit_read);
 460 }
 461
 462 //+----------------------------------------------------------------------------
 463 //
 464 // method :             Diffractometer::write_BFit
 465 //
 466 // description :        Write BFit attribute values to hardware.
 467 //
 468 //-----------------------------------------------------------------------------
 469 void Diffractometer::write_BFit(Tango::WAttribute &attr)
 470 {
 471         DEBUG_STREAM << "Diffractometer::write_BFit(Tango::WAttribute &attr) entering... "<< endl;
 472         bool fit;
 473
 474         attr.get_write_value(fit);
 475         if (_hklAdapter){
 476                 _hklAdapter->set_sample_BFit(fit);
 477                 this->save();
 478                 attr_BFit_write = fit;
 479         }
 480 }
 481
 482 //+----------------------------------------------------------------------------
 483 //
 484 // method :             Diffractometer::read_CFit
 485 //
 486 // description :        Extract real attribute values for CFit acquisition result.
 487 //
 488 //-----------------------------------------------------------------------------
 489 void Diffractometer::read_CFit(Tango::Attribute &attr)
 490 {
 491         DEBUG_STREAM << "Diffractometer::read_CFit(Tango::Attribute &attr) entering... "<< endl;
 492         attr.set_value(attr_CFit_read);
 493 }
 494
 495 //+----------------------------------------------------------------------------
 496 //
 497 // method :             Diffractometer::write_CFit
 498 //
 499 // description :        Write CFit attribute values to hardware.
 500 //
 501 //-----------------------------------------------------------------------------
 502 void Diffractometer::write_CFit(Tango::WAttribute &attr)
 503 {
 504         DEBUG_STREAM << "Diffractometer::write_CFit(Tango::WAttribute &attr) entering... "<< endl;
 505         bool fit;
 506
 507         attr.get_write_value(fit);
 508         if (_hklAdapter){
 509                 _hklAdapter->set_sample_CFit(fit);
 510                 this->save();
 511                 attr_CFit_write = fit;
 512         }
 513 }
 514
 515 //+----------------------------------------------------------------------------
 516 //
 517 // method :             Diffractometer::read_AlphaFit
 518 //
 519 // description :        Extract real attribute values for AlphaFit acquisition result.
 520 //
 521 //-----------------------------------------------------------------------------
 522 void Diffractometer::read_AlphaFit(Tango::Attribute &attr)
 523 {
 524         DEBUG_STREAM << "Diffractometer::read_AlphaFit(Tango::Attribute &attr) entering... "<< endl;
 525         attr.set_value(attr_AlphaFit_read);
 526 }
 527
 528 //+----------------------------------------------------------------------------
 529 //
 530 // method :             Diffractometer::write_AlphaFit
 531 //
 532 // description :        Write AlphaFit attribute values to hardware.
 533 //
 534 //-----------------------------------------------------------------------------
 535 void Diffractometer::write_AlphaFit(Tango::WAttribute &attr)
 536 {
 537         DEBUG_STREAM << "Diffractometer::write_AlphaFit(Tango::WAttribute &attr) entering... "<< endl;
 538         bool fit;
 539
 540         attr.get_write_value(fit);
 541         if (_hklAdapter){
 542                 _hklAdapter->set_sample_AlphaFit(fit);
 543                 this->save();
 544                 attr_AlphaFit_write = fit;
 545         }
 546 }
 547
 548 //+----------------------------------------------------------------------------
 549 //
 550 // method :             Diffractometer::read_BetaFit
 551 //
 552 // description :        Extract real attribute values for BetaFit acquisition result.
 553 //
 554 //-----------------------------------------------------------------------------
 555 void Diffractometer::read_BetaFit(Tango::Attribute &attr)
 556 {
 557         DEBUG_STREAM << "Diffractometer::read_BetaFit(Tango::Attribute &attr) entering... "<< endl;
 558         attr.set_value(attr_BetaFit_read);
 559 }
 560
 561 //+----------------------------------------------------------------------------
 562 //
 563 // method :             Diffractometer::write_BetaFit
 564 //
 565 // description :        Write BetaFit attribute values to hardware.
 566 //
 567 //-----------------------------------------------------------------------------
 568 void Diffractometer::write_BetaFit(Tango::WAttribute &attr)
 569 {
 570         DEBUG_STREAM << "Diffractometer::write_BetaFit(Tango::WAttribute &attr) entering... "<< endl;
 571         bool fit;
 572
 573         attr.get_write_value(fit);
 574         if (_hklAdapter){
 575                 _hklAdapter->set_sample_BetaFit(fit);
 576                 this->save();
 577                 attr_BetaFit_write = fit;
 578         }
 579 }
 580
 581 //+----------------------------------------------------------------------------
 582 //
 583 // method :             Diffractometer::read_GammaFit
 584 //
 585 // description :        Extract real attribute values for GammaFit acquisition result.
 586 //
 587 //-----------------------------------------------------------------------------
 588 void Diffractometer::read_GammaFit(Tango::Attribute &attr)
 589 {
 590         DEBUG_STREAM << "Diffractometer::read_GammaFit(Tango::Attribute &attr) entering... "<< endl;
 591         attr.set_value(attr_GammaFit_read);
 592 }
 593
 594 //+----------------------------------------------------------------------------
 595 //
 596 // method :             Diffractometer::write_GammaFit
 597 //
 598 // description :        Write GammaFit attribute values to hardware.
 599 //
 600 //-----------------------------------------------------------------------------
 601 void Diffractometer::write_GammaFit(Tango::WAttribute &attr)
 602 {
 603         DEBUG_STREAM << "Diffractometer::write_GammaFit(Tango::WAttribute &attr) entering... "<< endl;
 604         bool fit;
 605
 606         attr.get_write_value(fit);
 607         if (_hklAdapter){
 608                 _hklAdapter->set_sample_GammaFit(fit);
 609                 this->save();
 610                 attr_GammaFit_write = fit;
 611         }
 612 }
 613
 614 //+----------------------------------------------------------------------------
 615 //
 616 // method :             Diffractometer::read_UxFit
 617 //
 618 // description :        Extract real attribute values for UxFit acquisition result.
 619 //
 620 //-----------------------------------------------------------------------------
 621 void Diffractometer::read_UxFit(Tango::Attribute &attr)
 622 {
 623         DEBUG_STREAM << "Diffractometer::read_UxFit(Tango::Attribute &attr) entering... "<< endl;
 624         attr.set_value(attr_UxFit_read);
 625 }
 626
 627 //+----------------------------------------------------------------------------
 628 //
 629 // method :             Diffractometer::write_UxFit
 630 //
 631 // description :        Write UxFit attribute values to hardware.
 632 //
 633 //-----------------------------------------------------------------------------
 634 void Diffractometer::write_UxFit(Tango::WAttribute &attr)
 635 {
 636         DEBUG_STREAM << "Diffractometer::write_UxFit(Tango::WAttribute &attr) entering... "<< endl;
 637         bool fit;
 638
 639         attr.get_write_value(fit);
 640         if (_hklAdapter){
 641                 _hklAdapter->set_sample_UxFit(fit);
 642                 this->save();
 643                 attr_UxFit_write = fit;
 644         }
 645 }
 646
 647 //+----------------------------------------------------------------------------
 648 //
 649 // method :             Diffractometer::read_UyFit
 650 //
 651 // description :        Extract real attribute values for UyFit acquisition result.
 652 //
 653 //-----------------------------------------------------------------------------
 654 void Diffractometer::read_UyFit(Tango::Attribute &attr)
 655 {
 656         DEBUG_STREAM << "Diffractometer::read_UyFit(Tango::Attribute &attr) entering... "<< endl;
 657         attr.set_value(attr_UyFit_read);
 658 }
 659
 660 //+----------------------------------------------------------------------------
 661 //
 662 // method :             Diffractometer::write_UyFit
 663 //
 664 // description :        Write UyFit attribute values to hardware.
 665 //
 666 //-----------------------------------------------------------------------------
 667 void Diffractometer::write_UyFit(Tango::WAttribute &attr)
 668 {
 669         DEBUG_STREAM << "Diffractometer::write_UyFit(Tango::WAttribute &attr) entering... "<< endl;
 670         bool fit;
 671
 672         attr.get_write_value(fit);
 673         if (_hklAdapter){
 674                 _hklAdapter->set_sample_UyFit(fit);
 675                 this->save();
 676                 attr_UyFit_write = fit;
 677         }
 678 }
 679
 680 //+----------------------------------------------------------------------------
 681 //
 682 // method :             Diffractometer::read_UzFit
 683 //
 684 // description :        Extract real attribute values for UzFit acquisition result.
 685 //
 686 //-----------------------------------------------------------------------------
 687 void Diffractometer::read_UzFit(Tango::Attribute &attr)
 688 {
 689         DEBUG_STREAM << "Diffractometer::read_UzFit(Tango::Attribute &attr) entering... "<< endl;
 690         attr.set_value(attr_UzFit_read);
 691 }
 692
 693 //+----------------------------------------------------------------------------
 694 //
 695 // method :             Diffractometer::write_UzFit
 696 //
 697 // description :        Write UzFit attribute values to hardware.
 698 //
 699 //-----------------------------------------------------------------------------
 700 void Diffractometer::write_UzFit(Tango::WAttribute &attr)
 701 {
 702         DEBUG_STREAM << "Diffractometer::write_UzFit(Tango::WAttribute &attr) entering... "<< endl;
 703         bool fit;
 704
 705         attr.get_write_value(fit);
 706         if (_hklAdapter){
 707                 _hklAdapter->set_sample_UzFit(fit);
 708                 this->save();
 709                 attr_UzFit_write = fit;
 710         }
 711 }
 712
 713 //+----------------------------------------------------------------------------
 714 //
 715 // method :             Diffractometer::read_pseudoAxesProxies
 716 //
 717 // description :        Extract real attribute values for pseudoAxesProxies acquisition result.
 718 //
 719 //-----------------------------------------------------------------------------
 720 void Diffractometer::read_pseudoAxesProxies(Tango::Attribute &attr)
 721 {
 722         DEBUG_STREAM << "Diffractometer::read_pseudoAxesProxies(Tango::Attribute &attr) entering... "<< endl;
 723         if(_hklAdapter){
 724                 Matrix<char *> const & img = _hklAdapter->get_pseudo_axes_proxies();
 725                 attr.set_value(img.data, img.xdim);
 726         }
 727 }
 728
 729 //+----------------------------------------------------------------------------
 730 //
 731 // method :             Diffractometer::read_AnglesIdx
 732 //
 733 // description :        Extract real attribute values for AnglesIdx acquisition result.
 734 //
 735 //-----------------------------------------------------------------------------
 736 void Diffractometer::read_AnglesIdx(Tango::Attribute &attr)
 737 {
 738         DEBUG_STREAM << "Diffractometer::read_AnglesIdx(Tango::Attribute &attr) entering... "<< endl;
 739
 740         if(_hklAdapter){
 741                 *attr_AnglesIdx_read = _hklAdapter->get_angles_idx();
 742                 attr.set_value(attr_AnglesIdx_read);
 743         }
 744 }
 745
 746 //+----------------------------------------------------------------------------
 747 //
 748 // method :             Diffractometer::write_AnglesIdx
 749 //
 750 // description :        Write AnglesIdx attribute values to hardware.
 751 //
 752 //-----------------------------------------------------------------------------
 753 void Diffractometer::write_AnglesIdx(Tango::WAttribute &attr)
 754 {
 755         DEBUG_STREAM << "Diffractometer::write_AnglesIdx(Tango::WAttribute &attr) entering... "<< endl;
 756
 757         attr.get_write_value(attr_AnglesIdx_write);
 758         if(_hklAdapter)
 759                 _hklAdapter->set_angles_idx(attr_AnglesIdx_write);
 760 }
 761
 762 //+----------------------------------------------------------------------------
 763 //
 764 // method :             Diffractometer::read_AxesNames
 765 //
 766 // description :        Extract real attribute values for AxesNames acquisition result.
 767 //
 768 //-----------------------------------------------------------------------------
 769 void Diffractometer::read_AxesNames(Tango::Attribute &attr)
 770 {
 771         if(_hklAdapter){
 772                 Matrix<char *> const & img = _hklAdapter->get_dynamic_attribute_axes_names();
 773                 attr.set_value(img.data, img.xdim);
 774         }
 775 }
 776
 777 //+----------------------------------------------------------------------------
 778 //
 779 // method :             Diffractometer::read_Angles
 780 //
 781 // description :        Extract real attribute values for Angles acquisition result.
 782 //
 783 //-----------------------------------------------------------------------------
 784 void Diffractometer::read_Angles(Tango::Attribute &attr)
 785 {
 786         DEBUG_STREAM << "Diffractometer::read_Angles(Tango::Attribute &attr) entering... "<< endl;
 787         if(_hklAdapter){
 788                 Matrix<double> const & img = _hklAdapter->get_angles();
 789                 attr.set_value(img.data, img.xdim, img.ydim);
 790         }
 791 }
 792
 793 //+----------------------------------------------------------------------------
 794 //
 795 // method :             Diffractometer::read_AnglesDegenerated
 796 //
 797 // description :        Extract real attribute values for AnglesDegenerated acquisition result.
 798 //
 799 //-----------------------------------------------------------------------------
 800 void Diffractometer::read_AnglesDegenerated(Tango::Attribute &attr)
 801 {
 802         DEBUG_STREAM << "Diffractometer::read_AnglesDegenerated(Tango::Attribute &attr) entering... "<< endl;
 803 }
 804
 805 //+----------------------------------------------------------------------------
 806 //
 807 // method :             Diffractometer::read_AnglesRangeCheck
 808 //
 809 // description :        Extract real attribute values for AnglesRangeCheck acquisition result.
 810 //
 811 //-----------------------------------------------------------------------------
 812 void Diffractometer::read_AnglesRangeCheck(Tango::Attribute &attr)
 813 {
 814         DEBUG_STREAM << "Diffractometer::read_AnglesRangeCheck(Tango::Attribute &attr) entering... "<< endl;
 815 }
 816
 817 //+----------------------------------------------------------------------------
 818 //
 819 // method :             Diffractometer::read_Reflections
 820 //
 821 // description :        Extract real attribute values for Reflections acquisition result.
 822 //
 823 //-----------------------------------------------------------------------------
 824 void Diffractometer::read_Reflections(Tango::Attribute &attr)
 825 {
 826         DEBUG_STREAM << "Diffractometer::read_Reflections(Tango::Attribute &attr) entering... "<< endl;
 827         if(_hklAdapter){
 828                 Matrix<double> const & img = _hklAdapter->get_reflections();
 829                 attr.set_value(img.data, img.xdim, img.ydim);
 830         }
 831 }
 832
 833 //+----------------------------------------------------------------------------
 834 //
 835 // method :             Diffractometer::write_Reflections
 836 //
 837 // description :        Write Reflections attribute values to hardware.
 838 //
 839 //-----------------------------------------------------------------------------
 840 void Diffractometer::write_Reflections(Tango::WAttribute &attr)
 841 {
 842         DEBUG_STREAM << "Diffractometer::write_Reflections(Tango::WAttribute &attr) entering... "<< endl;
 843
 844         const Tango::DevDouble *value;
 845         attr.get_write_value(value);
 846
 847         Matrix<double> img;
 848         img.attach_to_const_buffer(value,
 849                                    attr.get_w_dim_x(), attr.get_w_dim_y());
 850
 851         if(_hklAdapter)
 852                 _hklAdapter->set_reflections(img);
 853 }
 854
 855 //+----------------------------------------------------------------------------
 856 //
 857 // method :             Diffractometer::read_ReflectionsAngles
 858 //
 859 // description :        Extract real attribute values for ReflectionsAngles acquisition result.
 860 //
 861 //-----------------------------------------------------------------------------
 862 void Diffractometer::read_ReflectionsAngles(Tango::Attribute &attr)
 863 {
 864         DEBUG_STREAM << "Diffractometer::read_ReflectionsAngles(Tango::Attribute &attr) entering... "<< endl;
 865
 866         if (_hklAdapter){
 867                 Matrix<double> const & img = _hklAdapter->get_reflections_angles();
 868                 attr.set_value(img.data, img.xdim, img.ydim);
 869         }
 870 }
 871
 872 //+----------------------------------------------------------------------------
 873 //
 874 // method :             Diffractometer::read_AStar
 875 //
 876 // description :        Extract real attribute values for AStar acquisition result.
 877 //
 878 //-----------------------------------------------------------------------------
 879 void Diffractometer::read_AStar(Tango::Attribute &attr)
 880 {
 881         DEBUG_STREAM << "Diffractometer::read_AStar(Tango::Attribute &attr) entering... "<< endl;
 882         attr.set_value(attr_AStar_read);
 883 }
 884
 885 //+----------------------------------------------------------------------------
 886 //
 887 // method :             Diffractometer::read_BStar
 888 //
 889 // description :        Extract real attribute values for BStar acquisition result.
 890 //
 891 //-----------------------------------------------------------------------------
 892 void Diffractometer::read_BStar(Tango::Attribute &attr)
 893 {
 894         DEBUG_STREAM << "Diffractometer::read_BStar(Tango::Attribute &attr) entering... "<< endl;
 895         attr.set_value(attr_BStar_read);
 896 }
 897
 898 //+----------------------------------------------------------------------------
 899 //
 900 // method :             Diffractometer::read_CStar
 901 //
 902 // description :        Extract real attribute values for CStar acquisition result.
 903 //
 904 //-----------------------------------------------------------------------------
 905 void Diffractometer::read_CStar(Tango::Attribute &attr)
 906 {
 907         DEBUG_STREAM << "Diffractometer::read_CStar(Tango::Attribute &attr) entering... "<< endl;
 908         attr.set_value(attr_CStar_read);
 909 }
 910
 911 //+----------------------------------------------------------------------------
 912 //
 913 // method :             Diffractometer::read_AlphaStar
 914 //
 915 // description :        Extract real attribute values for AlphaStar acquisition result.
 916 //
 917 //-----------------------------------------------------------------------------
 918 void Diffractometer::read_AlphaStar(Tango::Attribute &attr)
 919 {
 920         DEBUG_STREAM << "Diffractometer::read_AlphaStar(Tango::Attribute &attr) entering... "<< endl;
 921         attr.set_value(attr_AlphaStar_read);
 922 }
 923
 924 //+----------------------------------------------------------------------------
 925 //
 926 // method :             Diffractometer::read_BetaStar
 927 //
 928 // description :        Extract real attribute values for BetaStar acquisition result.
 929 //
 930 //-----------------------------------------------------------------------------
 931 void Diffractometer::read_BetaStar(Tango::Attribute &attr)
 932 {
 933         DEBUG_STREAM << "Diffractometer::read_BetaStar(Tango::Attribute &attr) entering... "<< endl;
 934         attr.set_value(attr_BetaStar_read);
 935 }
 936
 937 //+----------------------------------------------------------------------------
 938 //
 939 // method :             Diffractometer::read_GammaStar
 940 //
 941 // description :        Extract real attribute values for GammaStar acquisition result.
 942 //
 943 //-----------------------------------------------------------------------------
 944 void Diffractometer::read_GammaStar(Tango::Attribute &attr)
 945 {
 946         DEBUG_STREAM << "Diffractometer::read_GammaStar(Tango::Attribute &attr) entering... "<< endl;
 947         attr.set_value(attr_GammaStar_read);
 948 }
 949
 950 //+----------------------------------------------------------------------------
 951 //
 952 // method :             Diffractometer::read_A
 953 //
 954 // description :        Extract real attribute values for A acquisition result.
 955 //
 956 //-----------------------------------------------------------------------------
 957 void Diffractometer::read_A(Tango::Attribute &attr)
 958 {
 959         DEBUG_STREAM << "Diffractometer::read_A(Tango::Attribute &attr) entering... "<< endl;
 960         attr.set_value(attr_A_read);
 961 }
 962
 963 //+----------------------------------------------------------------------------
 964 //
 965 // method :             Diffractometer::read_B
 966 //
 967 // description :        Extract real attribute values for B acquisition result.
 968 //
 969 //-----------------------------------------------------------------------------
 970 void Diffractometer::read_B(Tango::Attribute &attr)
 971 {
 972         DEBUG_STREAM << "Diffractometer::read_B(Tango::Attribute &attr) entering... "<< endl;
 973         attr.set_value(attr_B_read);
 974 }
 975
 976 //+----------------------------------------------------------------------------
 977 //
 978 // method :             Diffractometer::read_C
 979 //
 980 // description :        Extract real attribute values for C acquisition result.
 981 //
 982 //-----------------------------------------------------------------------------
 983 void Diffractometer::read_C(Tango::Attribute &attr)
 984 {
 985         DEBUG_STREAM << "Diffractometer::read_C(Tango::Attribute &attr) entering... "<< endl;
 986         attr.set_value(attr_C_read);
 987 }
 988
 989 //+----------------------------------------------------------------------------
 990 //
 991 // method :             Diffractometer::read_Alpha
 992 //
 993 // description :        Extract real attribute values for Alpha acquisition result.
 994 //
 995 //-----------------------------------------------------------------------------
 996 void Diffractometer::read_Alpha(Tango::Attribute &attr)
 997 {
 998         DEBUG_STREAM << "Diffractometer::read_Alpha(Tango::Attribute &attr) entering... "<< endl;
 999         attr.set_value(attr_Alpha_read);
1000 }
1001
1002 //+----------------------------------------------------------------------------
1003 //
1004 // method :             Diffractometer::read_Beta
1005 //
1006 // description :        Extract real attribute values for Beta acquisition result.
1007 //
1008 //-----------------------------------------------------------------------------
1009 void Diffractometer::read_Beta(Tango::Attribute &attr)
1010 {
1011         DEBUG_STREAM << "Diffractometer::read_Beta(Tango::Attribute &attr) entering... "<< endl;
1012         attr.set_value(attr_Beta_read);
1013 }
1014
1015 //+----------------------------------------------------------------------------
1016 //
1017 // method :             Diffractometer::read_Gamma
1018 //
1019 // description :        Extract real attribute values for Gamma acquisition result.
1020 //
1021 //-----------------------------------------------------------------------------
1022 void Diffractometer::read_Gamma(Tango::Attribute &attr)
1023 {
1024         DEBUG_STREAM << "Diffractometer::read_Gamma(Tango::Attribute &attr) entering... "<< endl;
1025         attr.set_value(attr_Gamma_read);
1026 }
1027
1028 //+----------------------------------------------------------------------------
1029 //
1030 // method :             Diffractometer::read_UB
1031 //
1032 // description :        Extract real attribute values for UB acquisition result.
1033 //
1034 //-----------------------------------------------------------------------------
1035 void Diffractometer::read_UB(Tango::Attribute &attr)
1036 {
1037         DEBUG_STREAM << "Diffractometer::read_UB(Tango::Attribute &attr) entering... "<< endl;
1038
1039         if(_hklAdapter){
1040                 Matrix<double> const & img = _hklAdapter->get_sample_ub();
1041                 attr.set_value(img.data, img.xdim, img.ydim);
1042         }
1043 }
1044
1045 //+----------------------------------------------------------------------------
1046 //
1047 // method :             Diffractometer::read_Ux
1048 //
1049 // description :        Extract real attribute values for Ux acquisition result.
1050 //
1051 //-----------------------------------------------------------------------------
1052 void Diffractometer::read_Ux(Tango::Attribute &attr)
1053 {
1054         DEBUG_STREAM << "Diffractometer::read_Ux(Tango::Attribute &attr) entering... "<< endl;
1055
1056         if(_hklAdapter)
1057                 attr.set_value(&_hklAdapter->get_sample_Ux());
1058 }
1059
1060 //+----------------------------------------------------------------------------
1061 //
1062 // method :             Diffractometer::write_Ux
1063 //
1064 // description :        Write Ux attribute values to hardware.
1065 //
1066 //-----------------------------------------------------------------------------
1067 void Diffractometer::write_Ux(Tango::WAttribute &attr)
1068 {
1069         DEBUG_STREAM << "Diffractometer::write_Ux(Tango::WAttribute &attr) entering... "<< endl;
1070         double Ux;
1071
1072         attr.get_write_value(Ux);
1073         if (_hklAdapter){
1074                 _hklAdapter->set_sample_Ux(Ux);
1075                 attr_Ux_write = Ux;
1076         }
1077 }
1078
1079 //+----------------------------------------------------------------------------
1080 //
1081 // method :             Diffractometer::read_Uy
1082 //
1083 // description :        Extract real attribute values for Uy acquisition result.
1084 //
1085 //-----------------------------------------------------------------------------
1086 void Diffractometer::read_Uy(Tango::Attribute &attr)
1087 {
1088         DEBUG_STREAM << "Diffractometer::read_Uy(Tango::Attribute &attr) entering... "<< endl;
1089         if(_hklAdapter)
1090                 attr.set_value(&_hklAdapter->get_sample_Uy());
1091 }
1092
1093 //+----------------------------------------------------------------------------
1094 //
1095 // method :             Diffractometer::write_Uy
1096 //
1097 // description :        Write Uy attribute values to hardware.
1098 //
1099 //-----------------------------------------------------------------------------
1100 void Diffractometer::write_Uy(Tango::WAttribute &attr)
1101 {
1102         DEBUG_STREAM << "Diffractometer::write_Uy(Tango::WAttribute &attr) entering... "<< endl;
1103         double Uy;
1104
1105         attr.get_write_value(Uy);
1106         if (_hklAdapter){
1107                 _hklAdapter->set_sample_Uy(Uy);
1108                 attr_Uy_write = Uy;
1109         }
1110 }
1111
1112 //+----------------------------------------------------------------------------
1113 //
1114 // method :             Diffractometer::read_Uz
1115 //
1116 // description :        Extract real attribute values for Uz acquisition result.
1117 //
1118 //-----------------------------------------------------------------------------
1119 void Diffractometer::read_Uz(Tango::Attribute &attr)
1120 {
1121         DEBUG_STREAM << "Diffractometer::read_Uz(Tango::Attribute &attr) entering... "<< endl;
1122         if(_hklAdapter)
1123                 attr.set_value(&_hklAdapter->get_sample_Uz());
1124 }
1125
1126 //+----------------------------------------------------------------------------
1127 //
1128 // method :             Diffractometer::write_Uz
1129 //
1130 // description :        Write Uz attribute values to hardware.
1131 //
1132 //-----------------------------------------------------------------------------
1133 void Diffractometer::write_Uz(Tango::WAttribute &attr)
1134 {
1135         DEBUG_STREAM << "Diffractometer::write_Uz(Tango::WAttribute &attr) entering... "<< endl;
1136         double Uz;
1137
1138         attr.get_write_value(Uz);
1139         if (_hklAdapter){
1140                 _hklAdapter->set_sample_Uz(Uz);
1141                 attr_Uz_write = Uz;
1142         }
1143 }
1144
1145
1146 //+----------------------------------------------------------------------------
1147 //
1148 // method :             Diffractometer::read_Simulated
1149 //
1150 // description :        Extract real attribute values for Simulated acquisition result.
1151 //
1152 //-----------------------------------------------------------------------------
1153 void Diffractometer::read_Simulated(Tango::Attribute &attr)
1154 {
1155         DEBUG_STREAM << "Diffractometer::read_Simulated(Tango::Attribute &attr) entering... "<< endl;
1156
1157         if(_hklAdapter)
1158                 *attr_Simulated_read = !_hklAdapter->get_auto_update_from_proxies();
1159         attr.set_value(attr_Simulated_read);
1160 }
1161
1162 //+----------------------------------------------------------------------------
1163 //
1164 // method :             Diffractometer::write_Simulated
1165 //
1166 // description :        Write Simulated attribute values to hardware.
1167 //
1168 //-----------------------------------------------------------------------------
1169 void Diffractometer::write_Simulated(Tango::WAttribute &attr)
1170 {
1171         DEBUG_STREAM << "Diffractometer::write_Simulated(Tango::WAttribute &attr) entering... "<< endl;
1172         attr.get_write_value(attr_Simulated_write);
1173
1174         if (_hklAdapter)
1175                 _hklAdapter->set_auto_update_from_proxies(!attr_Simulated_write);
1176 }
1177
1178 //+----------------------------------------------------------------------------
1179 //
1180 // method :             Diffractometer::read_Crystal
1181 //
1182 // description :        Extract real attribute values for Crystal acquisition result.
1183 //
1184 //-----------------------------------------------------------------------------
1185 void Diffractometer::read_Crystal(Tango::Attribute &attr)
1186 {
1187         DEBUG_STREAM << "Diffractometer::read_Crystal(Tango::Attribute &attr) entering... "<< endl;
1188
1189         if(*attr_Crystal_read) delete [] *attr_Crystal_read;
1190
1191         if (_hklAdapter)
1192                 *attr_Crystal_read = CORBA::string_dup(_hklAdapter->get_sample_name());
1193         else
1194                 *attr_Crystal_read = CORBA::string_dup("");
1195         attr.set_value(attr_Crystal_read);
1196 }
1197
1198 //+----------------------------------------------------------------------------
1199 //
1200 // method :             Diffractometer::write_Crystal
1201 //
1202 // description :        Write Crystal attribute values to hardware.
1203 //
1204 //-----------------------------------------------------------------------------
1205 void Diffractometer::write_Crystal(Tango::WAttribute &attr)
1206 {
1207         DEBUG_STREAM << "Diffractometer::write_Crystal(Tango::WAttribute &attr) entering... "<< endl;
1208
1209         attr.get_write_value(attr_Crystal_write);
1210         if(_hklAdapter)
1211                 _hklAdapter->set_current_sample(attr_Crystal_write);
1212 }
1213
1214 //+----------------------------------------------------------------------------
1215 //
1216 // method :             Diffractometer::read_WaveLength
1217 //
1218 // description :        Extract real attribute values for WaveLength acquisition result.
1219 //
1220 //-----------------------------------------------------------------------------
1221 void Diffractometer::read_WaveLength(Tango::Attribute &attr)
1222 {
1223         DEBUG_STREAM << "Diffractometer::read_WaveLength(Tango::Attribute &attr) entering... "<< endl;
1224
1225         if(_hklAdapter)
1226                 attr.set_value(&_hklAdapter->get_lambda());
1227 }
1228
1229 //+----------------------------------------------------------------------------
1230 //
1231 // method :             Diffractometer::write_WaveLength
1232 //
1233 // description :        Write WaveLength attribute values to hardware.
1234 //
1235 //-----------------------------------------------------------------------------
1236 void Diffractometer::write_WaveLength(Tango::WAttribute &attr)
1237 {
1238         DEBUG_STREAM << "Diffractometer::write_WaveLength(Tango::WAttribute &attr) entering... "<< endl;
1239
1240         attr.get_write_value(attr_WaveLength_write);
1241
1242         if (_hklAdapter) {
1243                 _hklAdapter->set_lambda(attr_WaveLength_write);
1244                 if (!_hklAdapter->get_auto_update_from_proxies())
1245                         *attr_WaveLength_read = attr_WaveLength_write;
1246         }
1247 }
1248
1249 //+----------------------------------------------------------------------------
1250 //
1251 // method :             Diffractometer::read_CrystalNames
1252 //
1253 // description :        Extract real attribute values for CrystalNames acquisition result.
1254 //
1255 //-----------------------------------------------------------------------------
1256 void Diffractometer::read_CrystalNames(Tango::Attribute &attr)
1257 {
1258         DEBUG_STREAM << "Diffractometer::read_CrystalNames(Tango::Attribute &attr) entering... "<< endl;
1259
1260         std::vector<std::string> names;
1261
1262         if (_hklAdapter)
1263                 names = _hklAdapter->get_samples_names();
1264
1265         _crystal_names_dev_varstring_array << names;
1266         attr.set_value(_crystal_names_dev_varstring_array.get_buffer(),
1267                        _crystal_names_dev_varstring_array.length());
1268 }
1269
1270 //+------------------------------------------------------------------
1271 /**
1272  *      method: Diffractometer::abort
1273  *
1274  *      description:    method to execute "Abort"
1275  *      Stops the movement of all axis driven by the Diffractometer
1276  *
1277  *
1278  */
1279 //+------------------------------------------------------------------
1280 void Diffractometer::abort()
1281 {
1282         DEBUG_STREAM << "Diffractometer::abort(): entering... !" << endl;
1283
1284         //      Add your own code to control device here
1285         try
1286         {
1287                 _hklAdapter->stop_all_axis();
1288         }
1289         catch (Tango::DevFailed& e )
1290         {
1291                 ERROR_STREAM << e ;
1292         }
1293 }
1294
1295 //+------------------------------------------------------------------
1296 /**
1297  *      method: Diffractometer::add_new_crystal
1298  *
1299  *      description:    method to execute "AddNewCrystal"
1300  *      Create a new crystal
1301  *
1302  * @param       argin   Name of the new crystal
1303  *
1304  */
1305 //+------------------------------------------------------------------
1306 void Diffractometer::add_new_crystal(Tango::DevString argin)
1307 {
1308         DEBUG_STREAM << "Diffractometer::add_new_crystal(): entering... !" << endl;
1309
1310         //      Add your own code to control device here
1311
1312         /* POGO rename SampleNew */
1313
1314         if (_hklAdapter){
1315                 _hklAdapter->add_new_sample(argin);
1316                 this->save();
1317         }
1318 }
1319
1320 //+------------------------------------------------------------------
1321 /**
1322  *      method: Diffractometer::add_reflection
1323  *
1324  *      description:    method to execute "AddReflection"
1325  *      This commands requires the definition of 1 reflection defined by (h,k,l ) coordinates.
1326  *      This coodinates are associated with the current angles configuration.
1327  *
1328  *      TODO: d�taill� le commentaire
1329  *      reflections i.e : h, k, l, relevance, enable/disable
1330  *
1331  * @param       argin   reflections i.e :  h, k, l, relevance, enable/disable
1332  *
1333  */
1334 //+------------------------------------------------------------------
1335 void Diffractometer::add_reflection(const Tango::DevVarDoubleArray *argin)
1336 {
1337         DEBUG_STREAM << "Diffractometer::add_reflection(): entering... !" << endl;
1338
1339         //      Add your own code to control device here
1340
1341         /* POGO rename SampleReflectionAdd */
1342         if (_hklAdapter){
1343                 _hklAdapter->add_reflection();
1344                 this->save();
1345         }
1346 }
1347
1348 //+------------------------------------------------------------------
1349 /**
1350  *      method: Diffractometer::affine_crystal
1351  *
1352  *      description:    method to execute "AffineCrystal"
1353  *      Compute affinement for the current crystal with available list of reflection.
1354  *
1355  * @param       argin   name of the crystal to fit
1356  * @return      the fitness of the crystal after the affinement.
1357  *
1358  */
1359 //+------------------------------------------------------------------
1360 Tango::DevDouble Diffractometer::affine_crystal(Tango::DevString argin)
1361 {
1362         Tango::DevDouble        argout ;
1363         DEBUG_STREAM << "Diffractometer::affine_crystal(): entering... !" << endl;
1364
1365         //      Add your own code to control device here
1366
1367         /* POGO rename SampleAffinement */
1368
1369         if(_hklAdapter){
1370                 argout = _hklAdapter->affine_sample(argin);
1371                 this->refresh_crystal_parameters();
1372                 this->save();
1373         }
1374
1375         return argout;
1376 }
1377
1378 //+------------------------------------------------------------------
1379 /**
1380  *      method: Diffractometer::configure_crystal
1381  *
1382  *      description:    method to execute "ConfigureCrystal"
1383  *      Defines crystal lattice parameters.
1384  *      This information is mandatory for angles calculations.
1385  *      Angles units are degrees
1386  *
1387  * @param       argin   Crystal parameters : alpha,beta,gamma, A,B,C
1388  *
1389  */
1390 //+------------------------------------------------------------------
1391 void Diffractometer::configure_crystal(const Tango::DevVarDoubleArray *argin)
1392 {
1393         DEBUG_STREAM << "Diffractometer::configure_crystal(): entering... !" << endl;
1394
1395         //      Add your own code to control device here
1396
1397         /* POGO rename SampleConfiguration */
1398
1399         if(_hklAdapter){
1400                 _hklAdapter->set_lattice(argin);
1401                 this->refresh_crystal_parameters();
1402                 this->save();
1403         }
1404 }
1405
1406 //+------------------------------------------------------------------
1407 /**
1408  *      method: Diffractometer::copy_current_crystal_as
1409  *
1410  *      description:    method to execute "CopyCurrentCrystalAs"
1411  *      Copy the current crytal as another name
1412  *
1413  * @param       argin
1414  *
1415  */
1416 //+------------------------------------------------------------------
1417 void Diffractometer::copy_current_crystal_as(Tango::DevString argin)
1418 {
1419         DEBUG_STREAM << "Diffractometer::copy_current_crystal_as(): entering... !" << endl;
1420
1421         //      Add your own code to control device here
1422
1423         /* POGO rename SampleCopy */
1424
1425         if(_hklAdapter){
1426                 _hklAdapter->copy_sample_as(argin);
1427                 this->refresh_crystal_parameters();
1428                 this->save();
1429         }
1430 }
1431
1432 //+------------------------------------------------------------------
1433 /**
1434  *      method: Diffractometer::delete_current_crystal
1435  *
1436  *      description:    method to execute "DeleteCurrentCrystal"
1437  *      Delete the current from this device
1438  *
1439  *
1440  */
1441 //+------------------------------------------------------------------
1442 void Diffractometer::delete_current_crystal()
1443 {
1444         DEBUG_STREAM << "Diffractometer::delete_current_crystal(): entering... !" << endl;
1445
1446         //      Add your own code to control device here
1447
1448         /* POGO rename SampleDelete */
1449
1450         if(_hklAdapter){
1451                 _hklAdapter->del_sample();
1452                 this->refresh_crystal_parameters();
1453                 this->save();
1454         }
1455 }
1456
1457 //+------------------------------------------------------------------
1458 /**
1459  *      method: Diffractometer::load
1460  *
1461  *      description:    method to execute "Load"
1462  *      Load all crystals
1463  *
1464  *
1465  */
1466 //+------------------------------------------------------------------
1467 void Diffractometer::load()
1468 {
1469         DEBUG_STREAM << "Diffractometer::load(): entering... !" << endl;
1470
1471         //      Add your own code to control device here
1472
1473         // POGO TO DELETE
1474         if(_hklAdapter)
1475                 _hklAdapter->load();
1476 }
1477
1478 //+------------------------------------------------------------------
1479 /**
1480  *      method: Diffractometer::remove_reflection
1481  *
1482  *      description:    method to execute "RemoveReflection"
1483  *      This commands removes reflection from the current cristal.
1484  *
1485  * @param       argin   index of reflection to remove
1486  *
1487  */
1488 //+------------------------------------------------------------------
1489 void Diffractometer::remove_reflection(Tango::DevShort argin)
1490 {
1491         DEBUG_STREAM << "Diffractometer::remove_reflection(): entering... !" << endl;
1492
1493         //      Add your own code to control device here
1494
1495         /* POGO rename SampleReflectionDelete */
1496         if(_hklAdapter){
1497                 _hklAdapter->del_reflection(argin);
1498                 this->refresh_crystal_parameters();
1499                 this->save();
1500         }
1501 }
1502
1503 //+------------------------------------------------------------------
1504 /**
1505  *      method: Diffractometer::save
1506  *
1507  *      description:    method to execute "Save"
1508  *      Save all crystals
1509  *
1510  *
1511  */
1512 //+------------------------------------------------------------------
1513 void Diffractometer::save()
1514 {
1515         DEBUG_STREAM << "Diffractometer::save(): entering... !" << endl;
1516
1517         //      Add your own code to control device here
1518
1519         // POGO TO DELETE
1520         if(_hklAdapter)
1521                 _hklAdapter->save();
1522 }
1523
1524 //+------------------------------------------------------------------
1525 /**
1526  *      method: Diffractometer::set_crystal_parameter_values
1527  *
1528  *      description:    method to execute "SetCrystalParameterValues"
1529  *      Double : min value, max value, affinement enable
1530  *
1531  * @param       argin   String : Name of parameter ; Double : min value, max value, affinement enable
1532  *
1533  */
1534 //+------------------------------------------------------------------
1535 void Diffractometer::set_crystal_parameter_values(const Tango::DevVarDoubleStringArray *argin)
1536 {
1537         DEBUG_STREAM << "Diffractometer::set_crystal_parameter_values(): entering... !" << endl;
1538
1539         //      Add your own code to control device here
1540
1541         // check Parameters
1542         if(_hklAdapter)
1543                 _hklAdapter->set_sample_parameter_values(argin);
1544 }
1545
1546 //+------------------------------------------------------------------
1547 /**
1548  *      method: Diffractometer::copy_reflection_to
1549  *
1550  *      description:    method to execute "CopyReflectionTo"
1551  *      Copy one reflection from the current crystal to another crystal
1552  *
1553  * @param       argin   Double: Reflection number of the current crystal String : Name of the crystal where copy this reflection
1554  *
1555  */
1556 //+------------------------------------------------------------------
1557 void Diffractometer::copy_reflection_to(const Tango::DevVarDoubleStringArray *argin)
1558 {
1559         DEBUG_STREAM << "Diffractometer::copy_reflection_to(): entering... !" << endl;
1560
1561         //      Add your own code to control device here
1562
1563         /* POGO TO DELETE */
1564 }
1565
1566 //+------------------------------------------------------------------
1567 /**
1568  *      method: Diffractometer::dev_state
1569  *
1570  *      description:    method to execute "State"
1571  *      This command gets the device state (stored in its <i>device_state</i> data member) and returns it to the caller.
1572  *
1573  * @return      State Code
1574  *
1575  */
1576 //+------------------------------------------------------------------
1577 Tango::DevState Diffractometer::dev_state()
1578 {
1579         Tango::DevState argout;// = DeviceImpl::dev_state();
1580         DEBUG_STREAM << "Diffractometer::dev_state(): entering... !" << endl;
1581
1582         //      Add your own code to control device here
1583
1584         argout = _config.state;
1585         this->set_state(argout);
1586
1587         return argout;
1588 }
1589
1590 //+------------------------------------------------------------------
1591 /**
1592  *      method: Diffractometer::get_crystal_parameter_values
1593  *
1594  *      description:    method to execute "GetCrystalParameterValues"
1595  *      Return all values of a parameter for the current crystal
1596  *
1597  * @param       argin   Name of parameter (see getParametersNames for the complete list of parameters)
1598  * @return      In the order : minimum value, maximum value, affinement enable
1599  *
1600  */
1601 //+------------------------------------------------------------------
1602 Tango::DevVarDoubleStringArray *Diffractometer::get_crystal_parameter_values(Tango::DevString argin)
1603 {
1604         //      POGO has generated a method core with argout allocation.
1605         //      If you would like to use a static reference without copying,
1606         //      See "TANGO Device Server Programmer's Manual"
1607         //              (chapter : Writing a TANGO DS / Exchanging data)
1608         //------------------------------------------------------------
1609         Tango::DevVarDoubleStringArray  *argout  = new Tango::DevVarDoubleStringArray();
1610         argout->dvalue.length(3);
1611         argout->dvalue[0] = 0.0;
1612         argout->dvalue[1] = 0.0;
1613         argout->dvalue[2] = 0.0;
1614         argout->svalue.length(1);
1615         argout->svalue[0] = CORBA::string_dup(argin);
1616         DEBUG_STREAM << "Diffractometer::get_crystal_parameter_values(): entering... !" << endl;
1617
1618         //      Add your own code to control device here
1619         if(_hklAdapter)
1620                 _hklAdapter->get_sample_parameter_values(argout);
1621
1622         return argout;
1623 }
1624
1625 //+------------------------------------------------------------------
1626 /**
1627  *      method: Diffractometer::compute_u
1628  *
1629  *      description:    method to execute "ComputeU"
1630  *      Compute Matrix U from two reflections
1631  *
1632  * @param       argin   a two elements array with the index of reflection to use
1633  *
1634  */
1635 //+------------------------------------------------------------------
1636 void Diffractometer::compute_u(const Tango::DevVarLongArray *argin)
1637 {
1638         DEBUG_STREAM << "Diffractometer::compute_u(): entering... !" << endl;
1639
1640         //      Add your own code to control device here
1641         if(_hklAdapter){
1642                 _hklAdapter->compute_u(argin);
1643                 this->save();
1644         }
1645 }
1646
1647 //+------------------------------------------------------------------
1648 /**
1649  *      method: Diffractometer::dev_status
1650  *
1651  *      description:    method to execute "Status"
1652  *      This command gets the device status (stored in its <i>device_status</i> data member) and returns it to the caller.
1653  *
1654  * @return      Status description
1655  *
1656  */
1657 //+------------------------------------------------------------------
1658 Tango::ConstDevString Diffractometer::dev_status()
1659 {
1660         //Tango::ConstDevString argout = DeviceImpl::dev_status();
1661         DEBUG_STREAM << "Diffractometer::dev_status(): entering... !" << endl;
1662
1663         //      Add your own code to control device here
1664         this->set_status(_config.status);
1665         return _config.status.c_str();
1666 }
1667
1668
1669
1670
1671 }       //      namespace