src/TangoHKLAdapter.h

   1 #ifndef __TANGOHKLADAPTER_H__
   2 #define __TANGOHKLADAPTER_H__
   3
   4 #include <map>
   5 #include <vector>
   6 #include <string>
   7 #include <tango.h>
   8
   9 #include <Duration.h>
  10
  11 #include <hkl.h>
  12
  13 #include "AxisAdapter.h"
  14 #include "PseudoAxisAdapter.h"
  15 #include "PseudoAxesAdapter.h"
  16 #include "Matrix.h"
  17
  18 #if ( _MSC_VER && _MSC_VER <= 1200 )
  19 // Ce pragma ne devrait pas être dans ce fichier car le warning ne s'affiche
  20 // que si l'on compile une version DEBUG de la librairie.
  21 // Il faut utiliser l'option de compilation \wd4786 mais elle n'est présente
  22 // qu'à partir de VC++7
  23 # pragma warning (disable : 4786)
  24 #endif
  25
  26 #define NO_SOFTWARE_LIMITS -999999
  27
  28 namespace Diffractometer_ns {
  29
  30         // forward declaration
  31         class Diffractometer;
  32
  33         struct HklDiffractometer {
  34                 HklGeometry *geometry_r;
  35                 HklGeometry *geometry_w;
  36                 HklGeometry *geometry_r_real;
  37                 HklGeometry *geometry_w_real;
  38                 HklDetector detector;
  39                 HklDetector detector_real;
  40                 HklSampleList *samples;
  41                 HklPseudoAxisEngineList *engines_r;
  42                 HklPseudoAxisEngineList *engines_w;
  43                 HklPseudoAxisEngineList *engines_r_real;
  44                 HklPseudoAxisEngineList *engines_w_real;
  45         };
  46
  47         struct HKLBuffer {
  48                 double h_r; // read part of position value
  49                 double h_w; // write part of position value
  50                 double k_r; // read part of position value
  51                 double k_w; // write part of position value
  52                 double l_r; // read part of position value
  53                 double l_w; // write part of position value
  54         };
  55
  56         /**
  57          *
  58          * Class which associates a Diffractometer with the PseudoAxis
  59          */
  60         class TangoHKLAdapter
  61         {
  62         public :
  63                 bool simulated;
  64                 bool ready;
  65
  66                 TangoHKLAdapter(Diffractometer *_device, HklGeometryType type);
  67
  68                 virtual ~TangoHKLAdapter(void);
  69
  70                 Diffractometer *get_device(void) {return _device;}
  71
  72                 // Diffractometer Part
  73                 HklDiffractometer* & diffractometer(void) {return _diffractometer;}
  74
  75                 HKLBuffer const & get_HKLBuffer(void) const {return _hklBuffer;}
  76
  77                 Tango::DevState const & get_state(void) const {return _state;}
  78
  79                 std::string const & get_status(void) const {return _status;}
  80
  81                 bool internal_compute_angles(double h, double k,
  82                                              double l, std::string & status);
  83
  84                 void goto_reflection(short reflection_number);
  85
  86                 void set_simulated(bool simulated);
  87
  88                 void connect_all_proxies(void);
  89
  90                 void update(void);
  91
  92                 /**********/
  93                 /* source */
  94                 /**********/
  95
  96                 double & get_lambda(void) {return _lambda;}
  97
  98                 void set_lambda(double lambda);
  99
 100                 /************/
 101                 /* hkl part */
 102                 /************/
 103
 104                 Matrix<double> & get_angles(void) {omni_mutex_lock lock(_lock); return _angles;}
 105
 106                 short & get_angles_idx(void);
 107
 108                 void set_angles_idx(short idx);
 109
 110                 void load(void);
 111
 112                 void save(void);
 113
 114                 /***************/
 115                 /* sample part */
 116                 /***************/
 117
 118                 char const *get_sample_name(void);
 119
 120                 void set_current_sample(char const * name);
 121
 122                 void get_sample_lattices(double * a, double * b, double * c,
 123                                          double * alpha, double * beta, double * gamma,
 124                                          double * a_star, double * b_star, double * c_star,
 125                                          double * alpha_star, double * beta_star, double * gamma_star);
 126
 127                 Matrix<double> & get_sample_ub(void) {omni_mutex_lock lock(_lock); return _ub;}
 128
 129                 double & get_sample_Ux(void) {return _ux;}
 130
 131                 void set_sample_Ux(double ux);
 132
 133                 double & get_sample_Uy(void) {return _uy;}
 134
 135                 void set_sample_Uy(double uy);
 136
 137                 double & get_sample_Uz(void) {return _uz;}
 138
 139                 void set_sample_Uz(double uz);
 140
 141                 void add_new_sample(std::string const & name);
 142
 143                 void copy_sample_as(Tango::DevString copy_name);
 144
 145                 void del_sample(void);
 146
 147                 void set_lattice(const Tango::DevVarDoubleArray *argin);
 148
 149                 void add_reflection(void);
 150
 151                 void del_reflection(Tango::DevShort argin);
 152
 153                 // to remove in favour of get_sample_reflections
 154                 void get_sample_reflection(int idx, Tango::DevVarDoubleArray *argout);
 155
 156                 // to remove in favour of set_sample_reflections
 157                 void set_sample_reflection(const Tango::DevVarDoubleArray *argin);
 158
 159                 Matrix<double> & get_sample_reflections(void) {omni_mutex_lock lock(_lock); return _sample_reflections;}
 160
 161                 void set_sample_reflections(Matrix<double> const & img);
 162
 163                 double affine_sample(std::string name);
 164
 165                 std::vector<std::string> get_samples_names(void);
 166
 167                 void get_sample_parameter_values(Tango::DevVarDoubleStringArray *argout);
 168
 169                 void set_sample_parameter_values(Tango::DevVarDoubleStringArray const *argin);
 170
 171                 void compute_u(const Tango::DevVarLongArray *argin);
 172
 173                 Matrix<double> & get_reflections_angles(void) {omni_mutex_lock lock(_lock); return _reflections_angles;}
 174
 175                 /*****************/
 176                 /* hkl mode part */
 177                 /*****************/
 178
 179                 char const *read_mode(void);
 180
 181                 void write_mode(Tango::DevString argin);
 182
 183                 Matrix<char *> & get_mode_names(void) {omni_mutex_lock lock(_lock); return _mode_names;}
 184
 185                 Matrix<char *> & get_mode_parameters_names(void){omni_mutex_lock lock(_lock); return _mode_parameters_names;}
 186
 187                 void get_mode_parameters_values(Tango::DevVarDoubleStringArray *argout);
 188
 189                 void set_mode_parameters_values(const Tango::DevVarDoubleStringArray *argin);
 190
 191                 /*************/
 192                 /* axes part */
 193                 /*************/
 194
 195                 const std::vector<AxisAdapter> & get_axes(void) const {return _axes;}
 196
 197                 std::vector<AxisAdapter> & get_axes(void) {return _axes;}
 198
 199                 void read_axis(int idx, double & read, double & write);
 200
 201                 void write_axis(AxisAdapter & adapter, double value);
 202
 203                 void stop_all_axis(void);
 204
 205                 /*******************/
 206                 /* PseudoAxis Part */
 207                 /*******************/
 208
 209                 std::vector<std::string> pseudo_axis_get_names(void);
 210
 211                 void pseudo_axis_init(PseudoAxisAdapter *buffer, bool init);
 212
 213                 PseudoAxisAdapter *pseudo_axis_buffer_new(char const *name);
 214
 215                 void pseudo_axis_write(PseudoAxisAdapter *buffer, double value);
 216
 217                 Tango::DevString *pseudo_axis_get_mode(PseudoAxisAdapter const *buffer);
 218
 219                 void pseudo_axis_set_mode(PseudoAxisAdapter *buffer, Tango::DevString const & mode);
 220
 221                 void pseudo_axis_get_mode_parameters(PseudoAxisAdapter *buffer, Tango::DevVarDoubleStringArray *argout);
 222
 223                 void pseudo_axis_set_mode_parameters(PseudoAxisAdapter *buffer, const Tango::DevVarDoubleStringArray *argin);
 224
 225                 /*******************/
 226                 /* PseudoAxes Part */
 227                 /*******************/
 228
 229                 std::vector<PseudoAxesAdapter *> & pseudo_axes(void) {return _pseudoAxesAdapters;}
 230
 231                 PseudoAxesAdapter *pseudo_axes_adapter_get_by_name(std::string const & name);
 232
 233                 Matrix<char *> const & get_pseudo_axes_proxies(void) {omni_mutex_lock lock(_lock); return _pseudo_axes_proxies;}
 234
 235                 void pseudo_axes_write(size_t idx, Matrix<double> const & write);
 236
 237                 Tango::DevString *pseudo_axes_get_mode(size_t idx);
 238
 239                 void pseudo_axes_set_mode(size_t idx, const Tango::DevString name);
 240
 241                 Matrix<char *> & pseudo_axes_get_mode_parameters_names(size_t idx);
 242
 243                 Matrix<double> const & pseudo_axes_get_mode_parameters(size_t idx);
 244
 245                 void pseudo_axes_set_mode_parameters(size_t idx, Matrix<double> const & values);
 246
 247                 void pseudo_axes_init(size_t idx);
 248
 249                 void pseudo_axes_create_and_start_devices(void);
 250
 251                 void pseudo_axes_stop_and_remove_devices(void);
 252
 253                 /**********************/
 254                 /* Dynamic attributes */
 255                 /**********************/
 256
 257                 void create_axes_dynamic_attributes(void);
 258
 259                 void add_dynamic_attributes_to_device(void);
 260
 261                 void delete_dynamic_attributes(void);
 262
 263                 Matrix<char *> const & get_dynamic_attribute_axes_names(void) const {return _dynamic_attribute_axes_names;}
 264
 265         protected :
 266
 267                 omni_mutex _lock;
 268                 HklDiffractometer *_diffractometer;
 269                 std::vector<AxisAdapter> _axes;
 270                 std::vector<PseudoAxisAdapter *> _pseudoAxisAdapters;
 271                 std::vector<PseudoAxesAdapter *> _pseudoAxesAdapters;
 272                 HKLBuffer _hklBuffer;
 273                 Tango::Group *_proxies;
 274                 Tango::AttributeProxy *_lambdaAttributeProxy;
 275                 bool _wrong_nb_of_axis_proxies;
 276
 277                 void update_lambda(void);
 278
 279                 void update_angles(void);
 280
 281                 void update_reflections_angles(void);
 282
 283                 void update_sample_reflections(void);
 284
 285                 void update_ub(void);
 286
 287                 void update_ux_uy_uz(void);
 288
 289                 void update_mode_names(void);
 290
 291                 void update_mode_parameters_names(void);
 292
 293                 void update_axis_adapters(void);
 294
 295                 void update_HKLBuffer_from_hkl(void);
 296
 297                 void update_pseudo_axis_adapters_from_hkl(void);
 298
 299                 void update_pseudo_axes_adapters_from_hkl(void);
 300
 301                 void update_hkl_from_axis_adapters(void);
 302
 303                 void update_proxies_from_axis_adapters(void);
 304
 305                 void update_proxies_from_pseudo_axis_adapters(PseudoAxisAdapter *adapter);
 306
 307                 void update_state_and_status(void);
 308
 309                 void load_1(void);
 310
 311                 /* axis part */
 312                 void write_axis_i(AxisAdapter & axis, double value);
 313
 314         private :
 315
 316                 Diffractometer *_device;
 317                 std::string _status;
 318                 Tango::DevState _state;
 319                 HklGeometryType _type;
 320                 Duration duration;
 321                 double _lambda;
 322                 Matrix<double> _angles;
 323                 Matrix<char *> _mode_names;
 324                 Matrix<char *> _mode_parameters_names;
 325                 Matrix<char *> _pseudo_axes_proxies;
 326                 short _angles_idx;
 327
 328                 // sample part
 329                 Matrix<double> _reflections_angles;
 330                 Matrix<double> _sample_reflections;
 331                 Matrix<double> _ub;
 332                 double _ux;
 333                 double _uy;
 334                 double _uz;
 335
 336                 // dynamic attributes part
 337                 std::vector<Tango::Attr *> _dynamic_attribute_axes;
 338                 Matrix<char *> _dynamic_attribute_axes_names;
 339         };
 340 }
 341
 342 // given the state compute the new state using the axe state.
 343 extern void compose_state(Tango::DevState & state, Tango::DevState const & axe_state);
 344
 345 #endif// _TangoHKLAdapter_H