src/PseudoAxesAdapter.cpp

   1 #include "TangoHKLAdapter.h"
   2 #include "PseudoAxes.h"
   3 #include "PseudoAxesAttrib.h"
   4 #include "PseudoAxesAdapter.h"
   5 #include "Diffractometer.h"
   6
   7 namespace Diffractometer_ns
   8 {
   9
  10         PseudoAxesAdapter::PseudoAxesAdapter(TangoHKLAdapter *hklAdapter, size_t idx,
  11                                              HklPseudoAxisEngine *engine_r,
  12                                              HklPseudoAxisEngine *engine_w):
  13                 _hklAdapter(hklAdapter),
  14                 _engine_r(engine_r),
  15                 _engine_w(engine_w),
  16                 _idx(idx)
  17         {
  18                 size_t i;
  19                 size_t len;
  20
  21                 len = HKL_LIST_LEN(_engine_r->pseudoAxes);
  22                 _read.resize(len, 1);
  23                 _write.resize(len, 1);
  24
  25                 // update the _mode_names
  26                 len = HKL_LIST_LEN(_engine_r->modes);
  27                 _mode_names.resize(len, 1);
  28                 for(i=0; i<len; ++i)
  29                         _mode_names.data[i] = const_cast<char *>(_engine_r->modes[i]->name);
  30
  31                 // update the _pseudo_axis_names and create the dynamic attributes
  32                 len = HKL_LIST_LEN(_engine_r->pseudoAxes);
  33                 _pseudo_axis_names.resize(len , 1);
  34                 for(i=0; i<len; ++i){
  35                         Tango::Attr *att;
  36                         const char *name;
  37
  38                         name = ((HklParameter *)(_engine_r->pseudoAxes[i]))->name;
  39                         _pseudo_axis_names.data[i] = const_cast<char *>(name);
  40                         att = new PseudoAxesAxisAttrib(name, *this, i);
  41                         _dynamic_attribute_pseudo_axes_axis.push_back(att);
  42                 }
  43
  44                 // compute the proxy name
  45                 _proxy_name = _hklAdapter->get_device()->get_name();
  46                 _proxy_name += "-sim-";
  47                 _proxy_name += _engine_r->name;
  48
  49                 this->update_axes_i(_engine_r);
  50
  51                 // update the state and status
  52                 _state = Tango::STANDBY;
  53                 _status = "READY";
  54
  55                 _device = NULL;
  56         }
  57
  58         PseudoAxesAdapter::~PseudoAxesAdapter(void)
  59         {
  60                 size_t i;
  61
  62                 for(i=0; i<_dynamic_attribute_pseudo_axes_axis.size(); ++i)
  63                         delete _dynamic_attribute_pseudo_axes_axis[i];
  64         }
  65
  66         PseudoAxesConfig PseudoAxesAdapter::get_config(void)
  67         {
  68                 return _hklAdapter->pseudo_axes_get_config(_idx);
  69         }
  70
  71         char const * PseudoAxesAdapter::get_name(void) const
  72         {
  73                 return _hklAdapter->diffractometer()->engines_r->engines[_idx]->name;
  74         }
  75
  76         void PseudoAxesAdapter::write(Matrix<double> const & write) throw (Tango::DevFailed)
  77         {
  78                 _hklAdapter->pseudo_axes_write(_idx, write);
  79         }
  80
  81         void PseudoAxesAdapter::set_axis_value(size_t idx, double value)
  82         {
  83                 _write.data[idx] = value;
  84                 this->write(_write);
  85         }
  86
  87         Tango::DevString *PseudoAxesAdapter::get_mode(void)
  88         {
  89                 return _hklAdapter->pseudo_axes_get_mode(_idx);
  90         }
  91
  92         void PseudoAxesAdapter::set_mode(const Tango::DevString name)
  93         {
  94                 _hklAdapter->pseudo_axes_set_mode(_idx, name);
  95         }
  96
  97         Tango::DevBoolean PseudoAxesAdapter::get_initialized(void)
  98         {
  99                 return _hklAdapter->pseudo_axes_get_initialized(_idx);
 100         }
 101
 102         void PseudoAxesAdapter::set_initialized(const Tango::DevBoolean initialized)
 103         {
 104                 _hklAdapter->pseudo_axes_set_initialized(_idx, initialized);
 105         }
 106
 107         Matrix<char *> & PseudoAxesAdapter::get_mode_parameters_names(void)
 108         {
 109                 return _hklAdapter->pseudo_axes_get_mode_parameters_names(_idx);
 110         }
 111
 112         Matrix<double> const & PseudoAxesAdapter::get_mode_parameters(void)
 113         {
 114                 return _hklAdapter->pseudo_axes_get_mode_parameters(_idx);
 115         }
 116
 117         void PseudoAxesAdapter::set_mode_parameters(Matrix<double> const & values)
 118         {
 119                 _hklAdapter->pseudo_axes_set_mode_parameters(_idx, values);
 120         }
 121
 122         void PseudoAxesAdapter::init(void)
 123         {
 124                 _hklAdapter->pseudo_axes_init(_idx);
 125         }
 126
 127         void PseudoAxesAdapter::add_dynamic_attributes(void)
 128         {
 129                 _hklAdapter->pseudo_axes_add_dynamic_attributes(_idx);
 130         }
 131
 132         void PseudoAxesAdapter::remove_dynamic_attributes(void)
 133         {
 134                 _hklAdapter->pseudo_axes_remove_dynamic_attributes(_idx);
 135         }
 136
 137         void PseudoAxesAdapter::load(void)
 138         {
 139                 this->load_1();
 140         }
 141
 142         /******************/
 143         /* private method */
 144         /******************/
 145
 146         void PseudoAxesAdapter::update_axes_i(HklPseudoAxisEngine *engine)
 147         {
 148                 size_t i, j;
 149                 size_t len;
 150                 char const **names;
 151
 152                 // fill the _axes with the right AxisAdapters
 153                 std::vector<AxisAdapter> & axes = _hklAdapter->get_axes();
 154                 len = HKL_LIST_LEN(engine->mode->axes_names);
 155                 names = engine->mode->axes_names;
 156                 _axes.clear();
 157                 for(i=0; i<len; ++i)
 158                         for(j=0; j<axes.size(); ++j){
 159                                 AxisAdapter & axis = axes[j];
 160                                 if(axis.get_name() == names[i]) {
 161                                         _axes.push_back(&axis);
 162                                         continue;
 163                                 }
 164                         }
 165         }
 166
 167         void PseudoAxesAdapter::update(void)
 168         {
 169                 std::string status_extra;
 170
 171                 _status = "PseudoAxes status: ";
 172
 173                 // now compute the state and status
 174                 if(!_hklAdapter->_auto_update_from_proxies)
 175                         _state = Tango::STANDBY;
 176                 else{
 177                         size_t i;
 178
 179                         _state = Tango::STANDBY;
 180                         for(i=0;i<_axes.size();++i) {
 181                                 AxisAdapter const * axis = _axes[i];
 182                                 ::compose_state(_state, axis->get_state());
 183                                 if (axis->get_state() != Tango::STANDBY)
 184                                         status_extra += "\n" + axis->get_proxy_name() + " is in " + Tango::DevStateName[axis->get_state()];
 185                         }
 186                 }
 187                 _status += Tango::DevStateName[_state];
 188                 _status += status_extra;
 189         }
 190
 191         void PseudoAxesAdapter::save(void)
 192         {
 193                 Tango::DbData mode_prop;
 194                 Tango::DbData data_put;
 195                 HklPseudoAxisEngine *engine;
 196                 size_t i, j, len;
 197
 198                 // first erase the old mode properties
 199                 mode_prop.push_back(Tango::DbDatum("Mode"));
 200                 _device->get_db_device()->get_attribute_property(mode_prop);
 201                 long number_of_prop = 0;
 202                 mode_prop[0] >> number_of_prop ;
 203                 if(number_of_prop > 0)
 204                         _device->get_db_device()->delete_attribute_property(mode_prop);
 205
 206                 // Step 2 : create the Mode properties
 207                 engine = _hklAdapter->diffractometer()->engines_r->engines[_idx];
 208                 Tango::DbDatum properties("Mode");
 209                 // Put number of properties (= nb of samples + 1)
 210                 len = HKL_LIST_LEN(engine->modes);
 211                 properties << (long)(len);
 212                 data_put.push_back(properties);
 213
 214                 for(i=0; i<len; ++i){
 215                         HklPseudoAxisEngineMode *mode;
 216                         std::vector<std::string> lines;
 217                         char line[256];
 218
 219                         // the mode
 220                         mode = engine->modes[i];
 221                         for(j=0; j<HKL_LIST_LEN(mode->parameters); ++j){
 222                                 char const *name;
 223                                 double value;
 224
 225                                 name = mode->parameters[j].name;
 226                                 value = hkl_parameter_get_value_unit(&mode->parameters[j]);
 227                                 snprintf(line, 255, "%s=%f", name, value);
 228                                 lines.push_back(line);
 229                         }
 230
 231                         // Try to create property
 232                         // Get crystal name
 233                         Tango::DbDatum property(mode->name);
 234                         property << lines;
 235                         data_put.push_back(property);
 236                 }
 237
 238                 //update database for this property
 239                 _device->get_db_device()->put_attribute_property(data_put);
 240         }
 241
 242         void PseudoAxesAdapter::load_1(void)
 243         {
 244                 unsigned long nb_properties;
 245
 246                 // Get the Crystal Attributes properties.
 247                 Tango::DbData properties;
 248                 properties.push_back(Tango::DbDatum("Mode"));
 249                 _device->get_db_device()->get_attribute_property(properties);
 250
 251                 // the first one is the number of properties
 252                 properties[0] >> nb_properties;
 253
 254                 if (nb_properties > 1) {
 255                         size_t i;
 256                         HklPseudoAxisEngine *engine_r, *engine_w, *engine_r_real, *engine_w_real;
 257
 258                         engine_r = _hklAdapter->diffractometer()->engines_r->engines[_idx];
 259                         engine_w = _hklAdapter->diffractometer()->engines_w->engines[_idx];
 260                         engine_r_real = _hklAdapter->diffractometer()->engines_r_real->engines[_idx];
 261                         engine_w_real = _hklAdapter->diffractometer()->engines_w_real->engines[_idx];
 262
 263                         for(i=1; i<=nb_properties; ++i) {
 264                                 size_t idx_m, j, len;
 265                                 char const *name;
 266                                 std::vector<std::string> lines;
 267
 268                                 // first find the PseudoAxisEngineMode idx from its name
 269                                 name = properties[i].name.c_str();
 270                                 len = HKL_LIST_LEN(engine_r->modes);
 271                                 for(idx_m=0; idx_m<len; ++idx_m)
 272                                         if(!strcmp(name, engine_r->modes[idx_m]->name))
 273                                                 break;
 274                                 if(idx_m>=len) // did not find the right mode name
 275                                         continue;
 276
 277                                 // Extract the mode parameters from the properties
 278                                 properties[i] >> lines;
 279
 280                                 // extract the parameters values
 281                                 for(j=0; j<lines.size(); j++) {
 282                                         size_t idx_p;
 283
 284                                         char *line = strdup(lines[j].c_str());
 285                                         char *last;
 286                                         char *key = strtok_r(line, "=", &last);
 287
 288                                         for(idx_p=0; idx_p<len; ++idx_p)
 289                                                 if(!strcmp(key, engine_r->modes[idx_m]->parameters[idx_p].name))
 290                                                         break;
 291                                         if(idx_p < len){
 292                                                 double value;
 293
 294                                                 value = atof(strtok_r(NULL,";", &last));
 295                                                 hkl_parameter_set_value_unit(&engine_r->modes[idx_m]->parameters[idx_p], value);
 296                                                 hkl_parameter_set_value_unit(&engine_w->modes[idx_m]->parameters[idx_p], value);
 297                                                 hkl_parameter_set_value_unit(&engine_r_real->modes[idx_m]->parameters[idx_p], value);
 298                                                 hkl_parameter_set_value_unit(&engine_w_real->modes[idx_m]->parameters[idx_p], value);
 299                                         }
 300                                         free(line);
 301                                 }
 302                         }// End for each property
 303                 }
 304         }
 305 }