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