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 DiffractometerConfig {
  48                 Tango::DevState state;
  49                 std::string status;
  50         };
  51
  52         /**
  53          *
  54          * Class which associates a Diffractometer with the PseudoAxis
  55          */
  56         class TangoHKLAdapter
  57         {
  58         public :
  59                 bool simulated;
  60                 bool ready;
  61
  62                 TangoHKLAdapter(Diffractometer *_device, HklGeometryType type);
  63
  64                 virtual ~TangoHKLAdapter(void);
  65
  66                 Diffractometer *get_device(void) {return _device;}
  67
  68                 // Diffractometer Part
  69                 HklDiffractometer* & diffractometer(void) {return _diffractometer;}
  70
  71                 void get_diffractometer_config(DiffractometerConfig &config);
  72
  73                 void set_simulated(bool simulated);
  74
  75                 void connect_all_proxies(void);
  76
  77                 void update(void);
  78
  79                 /**********/
  80                 /* source */
  81                 /**********/
  82
  83                 double & get_lambda(void) {return _lambda;}
  84
  85                 void set_lambda(double lambda);
  86
  87                 /************/
  88                 /* hkl part */
  89                 /************/
  90
  91                 Matrix<double> & get_angles(void) {omni_mutex_lock lock(_lock); return _angles;}
  92
  93                 short & get_angles_idx(void);
  94
  95                 void set_angles_idx(short idx);
  96
  97                 void load(void);
  98
  99                 void save(void);
 100
 101                 /***************/
 102                 /* sample part */
 103                 /***************/
 104
 105                 char const *get_sample_name(void);
 106
 107                 void set_current_sample(char const * name);
 108
 109                 void get_sample_lattices(double * a, double * b, double * c,
 110                                          double * alpha, double * beta, double * gamma,
 111                                          double * a_star, double * b_star, double * c_star,
 112                                          double * alpha_star, double * beta_star, double * gamma_star);
 113
 114                 void get_sample_fit(bool *afit, bool *bfit, bool *cfit,
 115                                     bool *alphafit, bool *betafit, bool *gammafit,
 116                                     bool *uxfit, bool *uyfit, bool *uzfit);
 117
 118                 Matrix<double> & get_sample_ub(void) {omni_mutex_lock lock(_lock); return _ub;}
 119
 120                 double & get_sample_Ux(void) {return _ux;}
 121
 122                 void set_sample_Ux(double ux);
 123
 124                 double & get_sample_Uy(void) {return _uy;}
 125
 126                 void set_sample_Uy(double uy);
 127
 128                 double & get_sample_Uz(void) {return _uz;}
 129
 130                 void set_sample_Uz(double uz);
 131
 132                 void set_sample_AFit(bool fit);
 133                 void set_sample_BFit(bool fit);
 134                 void set_sample_CFit(bool fit);
 135                 void set_sample_AlphaFit(bool fit);
 136                 void set_sample_BetaFit(bool fit);
 137                 void set_sample_GammaFit(bool fit);
 138                 void set_sample_UxFit(bool fit);
 139                 void set_sample_UyFit(bool fit);
 140                 void set_sample_UzFit(bool fit);
 141
 142                 void add_new_sample(std::string const & name);
 143
 144                 void copy_sample_as(Tango::DevString copy_name);
 145
 146                 void del_sample(void);
 147
 148                 void set_lattice(const Tango::DevVarDoubleArray *argin);
 149
 150                 void add_reflection(void);
 151
 152                 void del_reflection(Tango::DevShort argin);
 153
 154                 Matrix<double> & get_reflections(void) {omni_mutex_lock lock(_lock); return _reflections;}
 155
 156                 void set_reflections(Matrix<double> const & img);
 157
 158                 double affine_sample(std::string name);
 159
 160                 std::vector<std::string> get_samples_names(void);
 161
 162                 void get_sample_parameter_values(Tango::DevVarDoubleStringArray *argout);
 163
 164                 void set_sample_parameter_values(Tango::DevVarDoubleStringArray const *argin);
 165
 166                 void compute_u(const Tango::DevVarLongArray *argin);
 167
 168                 Matrix<double> & get_reflections_angles(void) {omni_mutex_lock lock(_lock); return _reflections_angles;}
 169
 170                 /*************/
 171                 /* axes part */
 172                 /*************/
 173
 174                 const std::vector<AxisAdapter> & get_axes(void) const {return _axes;}
 175
 176                 std::vector<AxisAdapter> & get_axes(void) {return _axes;}
 177
 178                 void read_axis(int idx, double & read, double & write);
 179
 180                 void write_axis(AxisAdapter & adapter, double value);
 181
 182                 void stop_all_axis(void);
 183
 184                 /*******************/
 185                 /* PseudoAxis Part */
 186                 /*******************/
 187
 188                 std::vector<std::string> pseudo_axis_get_names(void);
 189
 190                 void pseudo_axis_init(PseudoAxisAdapter *buffer, bool init);
 191
 192                 PseudoAxisAdapter *pseudo_axis_buffer_new(char const *name);
 193
 194                 void pseudo_axis_write(PseudoAxisAdapter *buffer, double value);
 195
 196                 Tango::DevString *pseudo_axis_get_mode(PseudoAxisAdapter const *buffer);
 197
 198                 void pseudo_axis_set_mode(PseudoAxisAdapter *buffer, Tango::DevString const & mode);
 199
 200                 void pseudo_axis_get_mode_parameters(PseudoAxisAdapter *buffer, Tango::DevVarDoubleStringArray *argout);
 201
 202                 void pseudo_axis_set_mode_parameters(PseudoAxisAdapter *buffer, const Tango::DevVarDoubleStringArray *argin);
 203
 204                 /*******************/
 205                 /* PseudoAxes Part */
 206                 /*******************/
 207
 208                 std::vector<PseudoAxesAdapter *> & pseudo_axes(void) {return _pseudoAxesAdapters;}
 209
 210                 PseudoAxesAdapter *pseudo_axes_adapter_get_by_name(std::string const & name);
 211
 212                 Matrix<char *> const & get_pseudo_axes_proxies(void) {omni_mutex_lock lock(_lock); return _pseudo_axes_proxies;}
 213
 214                 void pseudo_axes_write(size_t idx, Matrix<double> const & write) throw (Tango::DevFailed);
 215
 216                 Tango::DevString *pseudo_axes_get_mode(size_t idx);
 217
 218                 void pseudo_axes_set_mode(size_t idx, const Tango::DevString name);
 219
 220                 Matrix<char *> & pseudo_axes_get_mode_parameters_names(size_t idx);
 221
 222                 Matrix<double> const & pseudo_axes_get_mode_parameters(size_t idx);
 223
 224                 void pseudo_axes_set_mode_parameters(size_t idx, Matrix<double> const & values);
 225
 226                 void pseudo_axes_add_dynamic_attributes(size_t idx);
 227
 228                 void pseudo_axes_remove_dynamic_attributes(size_t idx);
 229
 230                 void pseudo_axes_init(size_t idx);
 231
 232                 void pseudo_axes_create_and_start_devices(void);
 233
 234                 /**********************/
 235                 /* Dynamic attributes */
 236                 /**********************/
 237
 238                 void create_axes_dynamic_attributes(void);
 239
 240                 void add_dynamic_attributes_to_device(void);
 241
 242                 void delete_dynamic_attributes(void);
 243
 244                 Matrix<char *> const & get_dynamic_attribute_axes_names(void) const {return _dynamic_attribute_axes_names;}
 245
 246         protected :
 247
 248                 omni_mutex _lock;
 249                 HklDiffractometer *_diffractometer;
 250                 DiffractometerConfig _diffractometerConfig;
 251                 std::vector<AxisAdapter> _axes;
 252                 std::vector<PseudoAxisAdapter *> _pseudoAxisAdapters;
 253                 std::vector<PseudoAxesAdapter *> _pseudoAxesAdapters;
 254                 Tango::Group *_proxies;
 255                 Tango::AttributeProxy *_lambdaAttributeProxy;
 256                 bool _wrong_nb_of_axis_proxies;
 257
 258                 void update_pseudo_axis_engines(void);
 259
 260                 void update_lambda(void);
 261
 262                 void update_angles(void);
 263
 264                 void update_reflections_angles(void);
 265
 266                 void update_reflections(void);
 267
 268                 void update_ub(void);
 269
 270                 void update_ux_uy_uz(void);
 271
 272                 void update_axis_adapters(void);
 273
 274                 void update_pseudo_axis_adapters_from_hkl(void);
 275
 276                 void update_pseudo_axes_adapters_from_hkl(void);
 277
 278                 void update_hkl_from_axis_adapters(void);
 279
 280                 void update_proxies_from_axis_adapters(void);
 281
 282                 void update_proxies_from_pseudo_axis_adapters(PseudoAxisAdapter *adapter);
 283
 284                 void update_state_and_status(void);
 285
 286                 void load_1(void);
 287
 288                 /* axis part */
 289                 void write_axis_i(AxisAdapter & axis, double value);
 290
 291         private :
 292
 293                 Diffractometer *_device;
 294                 HklGeometryType _type;
 295                 Duration duration;
 296                 double _lambda;
 297                 Matrix<double> _angles;
 298                 Matrix<char *> _pseudo_axes_proxies;
 299                 short _angles_idx;
 300
 301                 // sample part
 302                 Matrix<double> _reflections_angles;
 303                 Matrix<double> _reflections;
 304                 Matrix<double> _ub;
 305                 double _ux;
 306                 double _uy;
 307                 double _uz;
 308                 bool _uxfit;
 309                 bool _uyfit;
 310                 bool _uzfit;
 311
 312                 // dynamic attributes part
 313                 std::vector<Tango::Attr *> _dynamic_attribute_axes;
 314                 Matrix<char *> _dynamic_attribute_axes_names;
 315         };
 316 }
 317
 318 // given the state compute the new state using the axe state.
 319 extern void compose_state(Tango::DevState & state, Tango::DevState const & axe_state);
 320
 321 #endif// _TangoHKLAdapter_H