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