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