* move the PseudoAxesAdapter update code in the PseudoAxesAdapter class.
[diffractometer.git] / src / PseudoAxesAdapter.cpp
blobf4afc7962f774c4669c146835ce26d9f98287fab
1 #include "TangoHKLAdapter.h"
2 #include "PseudoAxes.h"
3 #include "PseudoAxesAttrib.h"
4 #include "PseudoAxesAdapter.h"
5 #include "Diffractometer.h"
7 namespace Diffractometer_ns
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)
18 size_t i;
19 size_t len;
21 len = HKL_LIST_LEN(_engine_r->pseudoAxes);
22 _read.resize(len, 1);
23 _write.resize(len, 1);
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);
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;
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);
44 // compute the proxy name
45 _proxy_name = _hklAdapter->get_device()->get_name();
46 _proxy_name += "-sim-";
47 _proxy_name += _engine_r->name;
49 this->update_axes_i(_engine_r);
51 // update the state and status
52 _state = Tango::STANDBY;
53 _status = "READY";
55 _device = NULL;
58 PseudoAxesAdapter::~PseudoAxesAdapter(void)
60 size_t i;
62 for(i=0; i<_dynamic_attribute_pseudo_axes_axis.size(); ++i)
63 delete _dynamic_attribute_pseudo_axes_axis[i];
66 PseudoAxesConfig PseudoAxesAdapter::get_config(void)
68 return _hklAdapter->pseudo_axes_get_config(_idx);
71 char const * PseudoAxesAdapter::get_name(void) const
73 return _hklAdapter->diffractometer()->engines_r->engines[_idx]->name;
76 void PseudoAxesAdapter::write(Matrix<double> const & write) throw (Tango::DevFailed)
78 _hklAdapter->pseudo_axes_write(_idx, write);
81 void PseudoAxesAdapter::set_axis_value(size_t idx, double value)
83 _write.data[idx] = value;
84 this->write(_write);
87 Tango::DevString *PseudoAxesAdapter::get_mode(void)
89 return _hklAdapter->pseudo_axes_get_mode(_idx);
92 void PseudoAxesAdapter::set_mode(const Tango::DevString name)
94 _hklAdapter->pseudo_axes_set_mode(_idx, name);
97 Tango::DevBoolean PseudoAxesAdapter::get_initialized(void)
99 return _hklAdapter->pseudo_axes_get_initialized(_idx);
102 void PseudoAxesAdapter::set_initialized(const Tango::DevBoolean initialized)
104 _hklAdapter->pseudo_axes_set_initialized(_idx, initialized);
107 Matrix<char *> & PseudoAxesAdapter::get_mode_parameters_names(void)
109 return _hklAdapter->pseudo_axes_get_mode_parameters_names(_idx);
112 Matrix<double> const & PseudoAxesAdapter::get_mode_parameters(void)
114 return _hklAdapter->pseudo_axes_get_mode_parameters(_idx);
117 void PseudoAxesAdapter::set_mode_parameters(Matrix<double> const & values)
119 _hklAdapter->pseudo_axes_set_mode_parameters(_idx, values);
122 void PseudoAxesAdapter::init(void)
124 _hklAdapter->pseudo_axes_init(_idx);
127 void PseudoAxesAdapter::add_dynamic_attributes(void)
129 _hklAdapter->pseudo_axes_add_dynamic_attributes(_idx);
132 void PseudoAxesAdapter::remove_dynamic_attributes(void)
134 _hklAdapter->pseudo_axes_remove_dynamic_attributes(_idx);
137 void PseudoAxesAdapter::load(void)
139 this->load_1();
142 /******************/
143 /* private method */
144 /******************/
146 void PseudoAxesAdapter::update_axes_i(HklPseudoAxisEngine *engine)
148 size_t i, j;
149 size_t len;
150 char const **names;
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;
167 void PseudoAxesAdapter::update(void)
169 size_t i, len;
170 std::string status_extra;
172 // update the read part.
173 len = HKL_LIST_LEN(_engine_r->pseudoAxes);
174 for(i=0; i<len; ++i){
175 _read.data[i] = hkl_parameter_get_value_unit((HklParameter *)_engine_r->pseudoAxes[i]);
176 _write.data[i] = hkl_parameter_get_value_unit((HklParameter *)_engine_w->pseudoAxes[i]);
180 _status = "PseudoAxes status: ";
182 // now compute the state and status
183 if(!_hklAdapter->_auto_update_from_proxies)
184 _state = Tango::STANDBY;
185 else{
186 _state = Tango::STANDBY;
187 for(i=0;i<_axes.size();++i) {
188 AxisAdapter const * axis = _axes[i];
189 ::compose_state(_state, axis->get_state());
190 if (axis->get_state() != Tango::STANDBY)
191 status_extra += "\n" + axis->get_proxy_name() + " is in " + Tango::DevStateName[axis->get_state()];
194 _status += Tango::DevStateName[_state];
195 _status += status_extra;
198 void PseudoAxesAdapter::save(void)
200 Tango::DbData mode_prop;
201 Tango::DbData data_put;
202 HklPseudoAxisEngine *engine;
203 size_t i, j, len;
205 // first erase the old mode properties
206 mode_prop.push_back(Tango::DbDatum("Mode"));
207 _device->get_db_device()->get_attribute_property(mode_prop);
208 long number_of_prop = 0;
209 mode_prop[0] >> number_of_prop ;
210 if(number_of_prop > 0)
211 _device->get_db_device()->delete_attribute_property(mode_prop);
213 // Step 2 : create the Mode properties
214 engine = _hklAdapter->diffractometer()->engines_r->engines[_idx];
215 Tango::DbDatum properties("Mode");
216 // Put number of properties (= nb of samples + 1)
217 len = HKL_LIST_LEN(engine->modes);
218 properties << (long)(len);
219 data_put.push_back(properties);
221 for(i=0; i<len; ++i){
222 HklPseudoAxisEngineMode *mode;
223 std::vector<std::string> lines;
224 char line[256];
226 // the mode
227 mode = engine->modes[i];
228 for(j=0; j<HKL_LIST_LEN(mode->parameters); ++j){
229 char const *name;
230 double value;
232 name = mode->parameters[j].name;
233 value = hkl_parameter_get_value_unit(&mode->parameters[j]);
234 snprintf(line, 255, "%s=%f", name, value);
235 lines.push_back(line);
238 // Try to create property
239 // Get crystal name
240 Tango::DbDatum property(mode->name);
241 property << lines;
242 data_put.push_back(property);
245 //update database for this property
246 _device->get_db_device()->put_attribute_property(data_put);
249 void PseudoAxesAdapter::load_1(void)
251 unsigned long nb_properties;
253 // Get the Crystal Attributes properties.
254 Tango::DbData properties;
255 properties.push_back(Tango::DbDatum("Mode"));
256 _device->get_db_device()->get_attribute_property(properties);
258 // the first one is the number of properties
259 properties[0] >> nb_properties;
261 if (nb_properties > 1) {
262 size_t i;
263 HklPseudoAxisEngine *engine_r, *engine_w, *engine_r_real, *engine_w_real;
265 engine_r = _hklAdapter->diffractometer()->engines_r->engines[_idx];
266 engine_w = _hklAdapter->diffractometer()->engines_w->engines[_idx];
267 engine_r_real = _hklAdapter->diffractometer()->engines_r_real->engines[_idx];
268 engine_w_real = _hklAdapter->diffractometer()->engines_w_real->engines[_idx];
270 for(i=1; i<=nb_properties; ++i) {
271 size_t idx_m, j, len;
272 char const *name;
273 std::vector<std::string> lines;
275 // first find the PseudoAxisEngineMode idx from its name
276 name = properties[i].name.c_str();
277 len = HKL_LIST_LEN(engine_r->modes);
278 for(idx_m=0; idx_m<len; ++idx_m)
279 if(!strcmp(name, engine_r->modes[idx_m]->name))
280 break;
281 if(idx_m>=len) // did not find the right mode name
282 continue;
284 // Extract the mode parameters from the properties
285 properties[i] >> lines;
287 // extract the parameters values
288 for(j=0; j<lines.size(); j++) {
289 size_t idx_p;
291 char *line = strdup(lines[j].c_str());
292 char *last;
293 char *key = strtok_r(line, "=", &last);
295 for(idx_p=0; idx_p<len; ++idx_p)
296 if(!strcmp(key, engine_r->modes[idx_m]->parameters[idx_p].name))
297 break;
298 if(idx_p < len){
299 double value;
301 value = atof(strtok_r(NULL,";", &last));
302 hkl_parameter_set_value_unit(&engine_r->modes[idx_m]->parameters[idx_p], value);
303 hkl_parameter_set_value_unit(&engine_w->modes[idx_m]->parameters[idx_p], value);
304 hkl_parameter_set_value_unit(&engine_r_real->modes[idx_m]->parameters[idx_p], value);
305 hkl_parameter_set_value_unit(&engine_w_real->modes[idx_m]->parameters[idx_p], value);
307 free(line);
309 }// End for each property