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