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