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/hkl-geometry-factory.h>
  12 #include <hkl/hkl-pseudoaxis-factory.h>
  13
  14 #include "AxisAdapter.h"
  15 //#include "PseudoAxisAdapter.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 DiffractometerDevice_ns {
  29
  30         // forward declaration
  31         class DiffractometerDevice;
  32
  33         struct HklDiffractometer {
  34                 HklGeometry *geometry_r;
  35                 HklGeometry *geometry_w;
  36                 HklDetector detector;
  37                 HklSampleList *samples;
  38                 HklPseudoAxisEngineList *engines_r;
  39                 HklPseudoAxisEngineList *engines_w;
  40         };
  41
  42         struct PseudoAxisAdapter {
  43                 std::string _devicename;
  44                 Tango::Group *_group;
  45                 HklPseudoAxis *_pseudo_r;
  46                 HklPseudoAxis *_pseudo_w;
  47                 double _read;
  48                 double _write;
  49                 std::vector<AxisAdapter *> _axes;
  50                 Tango::DevState _state;
  51                 std::string _status;
  52         };
  53
  54         struct HKLBuffer {
  55                 double h_r; // read part of position value
  56                 double h_w; // write part of position value
  57                 double k_r; // read part of position value
  58                 double k_w; // write part of position value
  59                 double l_r; // read part of position value
  60                 double l_w; // write part of position value
  61         };
  62
  63         /**
  64          *
  65          * Class which associates a Diffractometer with the PseudoAxis
  66          */
  67         class TangoHKLAdapter
  68         {
  69                 public :
  70                         bool simulated;
  71                         bool ready;
  72
  73                         TangoHKLAdapter(DiffractometerDevice *_device, HklGeometryType type);
  74
  75                         virtual ~TangoHKLAdapter(void);
  76
  77                         // Diffractometer Part
  78                         virtual HklDiffractometer *diffractometer(void);
  79
  80                         HKLBuffer const & get_HKLBuffer(void) const;
  81
  82                         void getDiffractometerStateAndStatus(Tango::DevState & the_state,
  83                                                              std::string & the_status);
  84
  85                         bool internal_compute_angles(double h, double k,
  86                                                      double l, std::string & status);
  87
  88                         void goto_reflection(short reflection_number);
  89
  90                         void set_simulated(bool simulated);
  91
  92                         void connect_all_proxies(void);
  93
  94                         void update(void);
  95
  96                         /**********/
  97                         /* source */
  98                         /**********/
  99
 100                         double & get_lambda(void) {return _lambda;}
 101
 102                         void set_lambda(double lambda);
 103
 104                         /************/
 105                         /* hkl part */
 106                         /************/
 107
 108                         Matrix<double> & get_angles(void) {omni_mutex_lock lock(_lock); return _angles;}
 109
 110                         short & get_angles_idx(void);
 111
 112                         void set_angles_idx(short idx);
 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(int idx, double value);
 202
 203                         void stop_all_axis(void);
 204
 205                         /*******************/
 206                         /* PseudoAxes 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                 protected :
 218
 219                         omni_mutex _lock;
 220                         HklDiffractometer *_diffractometer;
 221                         std::vector<AxisAdapter> _axes;
 222                         std::vector<PseudoAxisAdapter *> _pseudoAxes;
 223                         HKLBuffer _hklBuffer;
 224                         Tango::Group *_proxies;
 225                         Tango::AttributeProxy *_lambdaAttributeProxy;
 226                         bool _wrong_nb_of_axis_proxies;
 227
 228                         void update_lambda(void);
 229
 230                         void update_angles(void);
 231
 232                         void update_reflections_angles(void);
 233
 234                         void update_sample_reflections(void);
 235
 236                         void update_ub(void);
 237
 238                         void update_ux_uy_uz(void);
 239
 240                         void update_mode_names(void);
 241
 242                         void update_mode_parameters_names(void);
 243
 244                         void update_axisBuffers_from_library(void);
 245
 246                         void update_axisBuffers_from_proxies(void);
 247
 248                         void update_HKLBuffer_from_library(void);
 249
 250                         void update_pseudo_axis_buffers_from_library(void);
 251
 252                         void update_library_from_axisBuffers(void);
 253
 254                         void update_proxies_from_axisBuffers(void);
 255
 256                         void update_proxies_from_pseudoAxesBuffer(PseudoAxisAdapter *buffer);
 257
 258                 private :
 259
 260                         DiffractometerDevice *_device;
 261                         HklGeometryType _type;
 262                         Duration duration;
 263                         double _lambda;
 264                         Matrix<double> _angles;
 265                         Matrix<char *> _mode_names;
 266                         Matrix<char *> _mode_parameters_names;
 267                         short _angles_idx;
 268
 269                         // sample part
 270                         Matrix<double> _reflections_angles;
 271                         Matrix<double> _sample_reflections;
 272                         Matrix<double> _ub;
 273                         double _ux;
 274                         double _uy;
 275                         double _uz;
 276
 277                         void pseudo_axis_related_axes_update(PseudoAxisAdapter *buffer);
 278         };
 279
 280 }
 281
 282 // given the state compute the new state using the axe state.
 283 extern void compose_state(Tango::DevState & state, Tango::DevState const & axe_state);
 284 //extern std::string hkl_axes_consign_as_string(HklAxis const **axes, size_t axes_len);
 285
 286 #endif// _TangoHKLAdapter_H