All Classes Namespaces Functions Variables Typedefs Enumerations
casadiXML.h
1 #ifndef _MBXMLUTILS_CASADIXML_H_
2 #define _MBXMLUTILS_CASADIXML_H_
3 
4 #include <mbxmlutilshelper/dom.h>
5 #include <map>
6 #include <casadi/casadi.hpp>
7 #include <xercesc/dom/DOMDocument.hpp>
8 #include <xercesc/dom/DOMElement.hpp>
9 #include <xercesc/dom/DOMImplementationRegistry.hpp>
10 #include <xercesc/dom/DOMImplementation.hpp>
11 #include <boost/lexical_cast.hpp>
12 
13 namespace casadi {
14 
15 const MBXMLUtils::NamespaceURI CASADI("http://www.mbsim-env.de/MBXMLUtils/CasADi");
16 
17 inline xercesc::DOMElement *convertCasADiToXML_SXElem(const SXElem &s, std::map<SXNode*, int> &nodes, xercesc::DOMDocument *doc) {
18  // add the node of s to the list of all nodes (creates a integer id for newly added nodes)
19  std::string idStr;
20  std::pair<std::map<SXNode*, int>::iterator, bool> ret=nodes.insert(std::make_pair(s.get(), nodes.size()));
21  // if the node of s already exists in the list of all nodes write a reference to this node to XML
22  if(ret.second==false) {
23  xercesc::DOMElement *e=MBXMLUtils::D(doc)->createElement(CASADI%"SXElemRef");
24  std::stringstream str;
25  str<<ret.first->second;
26  MBXMLUtils::E(e)->setAttribute("refid", str.str());
27  return e;
28  }
29  // if the node of s does not exist in the list of all nodes set the id of this node
30  std::stringstream str;
31  str<<ret.first->second;
32  idStr=str.str();
33 
34  // add s to XML dependent on the type of s
35  xercesc::DOMElement *e;
36  if(s.is_symbolic()) {
37  e=MBXMLUtils::D(doc)->createElement(CASADI%"SymbolicSX");
38  e->insertBefore(doc->createTextNode(MBXMLUtils::X()%s.name()), NULL);
39  }
40  else if(s.is_zero())
41  e=MBXMLUtils::D(doc)->createElement(CASADI%"ZeroSX");
42  else if(s.is_one())
43  e=MBXMLUtils::D(doc)->createElement(CASADI%"OneSX");
44  else if(s.is_minus_one())
45  e=MBXMLUtils::D(doc)->createElement(CASADI%"MinusOneSX");
46  else if(s.isInf())
47  e=MBXMLUtils::D(doc)->createElement(CASADI%"InfSX");
48  else if(s.isMinusInf())
49  e=MBXMLUtils::D(doc)->createElement(CASADI%"MinusInfSX");
50  else if(s.isNan())
51  e=MBXMLUtils::D(doc)->createElement(CASADI%"NanSX");
52  else if(s.is_integer()) {
53  e=MBXMLUtils::D(doc)->createElement(CASADI%"IntegerSX");
54  std::stringstream str;
55  str<<static_cast<int>(s);
56  e->insertBefore(doc->createTextNode(MBXMLUtils::X()%str.str()), NULL);
57  }
58  else if(s.is_constant()) {
59  e=MBXMLUtils::D(doc)->createElement(CASADI%"RealtypeSX");
60  std::stringstream str;
61  str.precision(18);
62  str<<static_cast<double>(s);
63  e->insertBefore(doc->createTextNode(MBXMLUtils::X()%str.str()), NULL);
64  }
65  else if(s.hasDep() && s.n_dep()==2) {
66  e=MBXMLUtils::D(doc)->createElement(CASADI%"BinarySX");
67  std::stringstream str;
68  str<<s.op();
69  MBXMLUtils::E(e)->setAttribute("op", str.str());
70  e->insertBefore(convertCasADiToXML_SXElem(s.dep(0), nodes, doc), NULL);
71  e->insertBefore(convertCasADiToXML_SXElem(s.dep(1), nodes, doc), NULL);
72  }
73  else if(s.hasDep() && s.n_dep()==1) {
74  e=MBXMLUtils::D(doc)->createElement(CASADI%"UnarySX");
75  std::stringstream str;
76  str<<s.op();
77  MBXMLUtils::E(e)->setAttribute("op", str.str());
78  e->insertBefore(convertCasADiToXML_SXElem(s.dep(0), nodes, doc), NULL);
79  }
80  else
81  throw std::runtime_error("Unknown SXElem type in convertCasADiToXML_SXElem");
82 
83  // write also the id of a newly node to XML
84  MBXMLUtils::E(e)->setAttribute("id", idStr);
85  return e;
86 }
87 
88 inline xercesc::DOMElement* convertCasADiToXML_SX(const SX &m, std::map<SXNode*, int> &nodes, xercesc::DOMDocument *doc) {
89  // write each row of m to XML enclosed by a <row> element and each element in such rows to this element
90  xercesc::DOMElement *e=MBXMLUtils::D(doc)->createElement(CASADI%"SX");
91  for(int r=0; r<m.size1(); r++) {
92  xercesc::DOMElement *row=MBXMLUtils::D(doc)->createElement(CASADI%"row");
93  e->insertBefore(row, NULL);
94  for(int c=0; c<m.size2(); c++)
95  row->insertBefore(convertCasADiToXML_SXElem(m(r, c).scalar(), nodes, doc), NULL);
96  }
97  return e;
98 }
99 
100 inline xercesc::DOMElement* convertCasADiToXML(const std::pair<std::vector<casadi::SX>, std::vector<casadi::SX>> &f, xercesc::DOMDocument *doc) {
101  // write each input to XML enclosed by a <inputs> element
102  std::map<SXNode*, int> nodes;
103  xercesc::DOMElement *e=MBXMLUtils::D(doc)->createElement(CASADI%"Function");
104  xercesc::DOMElement *input=MBXMLUtils::D(doc)->createElement(CASADI%"inputs");
105  e->insertBefore(input, NULL);
106  for(size_t i=0; i<f.first.size(); i++)
107  input->insertBefore(convertCasADiToXML_SX(f.first[i], nodes, doc), NULL);
108  // write each output to XML enclosed by a <outputs> element
109  xercesc::DOMElement *output=MBXMLUtils::D(doc)->createElement(CASADI%"outputs");
110  e->insertBefore(output, NULL);
111  for(size_t i=0; i<f.second.size(); i++)
112  output->insertBefore(convertCasADiToXML_SX(f.second[i], nodes, doc), NULL);
113 
114  return e;
115 }
116 
117 inline SXElem createCasADiSXFromXML(xercesc::DOMElement *e, std::map<int, SXNode*> &nodes) {
118  // creata an SXElem dependent on the type
119  SXElem sxelement;
120  if(MBXMLUtils::E(e)->getTagName()==CASADI%"BinarySX") {
121  int op = boost::lexical_cast<int>(MBXMLUtils::E(e)->getAttribute("op").c_str());
122  xercesc::DOMElement *ee=e->getFirstElementChild();
123  SXElem dep0(createCasADiSXFromXML(ee, nodes));
124  ee=ee->getNextElementSibling();
125  SXElem dep1(createCasADiSXFromXML(ee, nodes));
126  sxelement=SXElem::binary(op, dep0, dep1);
127  }
128  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"UnarySX") {
129  int op = boost::lexical_cast<int>(MBXMLUtils::E(e)->getAttribute("op").c_str());
130  xercesc::DOMElement *ee=e->getFirstElementChild();
131  SXElem dep=createCasADiSXFromXML(ee, nodes);
132  sxelement=SXElem::unary(op, dep);
133  }
134  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"SymbolicSX") {
135  sxelement=SXElem::sym(MBXMLUtils::X()%MBXMLUtils::E(e)->getFirstTextChild()->getData());
136  }
137  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"RealtypeSX") {
138  std::stringstream str(MBXMLUtils::X()%MBXMLUtils::E(e)->getFirstTextChild()->getData());
139  double value;
140  str>>value;
141  sxelement=value;
142  }
143  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"IntegerSX") {
144  std::stringstream str(MBXMLUtils::X()%MBXMLUtils::E(e)->getFirstTextChild()->getData());
145  int value;
146  str>>value;
147  sxelement=value;
148  }
149  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"ZeroSX")
150  sxelement=casadi_limits<SXElem>::zero;
151  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"OneSX")
152  sxelement=casadi_limits<SXElem>::one;
153  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"MinusOneSX")
154  sxelement=casadi_limits<SXElem>::minus_one;
155  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"InfSX")
156  sxelement=casadi_limits<SXElem>::inf;
157  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"MinusInfSX")
158  sxelement=casadi_limits<SXElem>::minus_inf;
159  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"NanSX")
160  sxelement=casadi_limits<SXElem>::nan;
161  // reference elements must be handled specially: return the referenced node instead of creating a new one
162  else if(MBXMLUtils::E(e)->getTagName()==CASADI%"SXElemRef") {
163  int refid = boost::lexical_cast<int>(MBXMLUtils::E(e)->getAttribute("refid").c_str());
164  sxelement=SXElem::create(nodes[refid]);
165  return sxelement;
166  }
167  else
168  throw std::runtime_error("Unknown XML element named "+MBXMLUtils::X()%e->getTagName()+" in createCasADiSXFromXML");
169 
170  // insert a newly created SXElem (node) to the list of all nodes
171  int id = boost::lexical_cast<int>(MBXMLUtils::E(e)->getAttribute("id").c_str());
172  nodes.insert(std::make_pair(id, sxelement.get()));
173  return sxelement;
174 }
175 
176 inline SX createCasADiSXMatrixFromXML(xercesc::DOMElement *e, std::map<int, SXNode*> &nodes) {
177  // loop over all rows
178  std::vector<std::vector<SXElem> > ret;
179  xercesc::DOMElement *row=e->getFirstElementChild();
180  while(row) {
181  // loop over all elements in a row
182  std::vector<SXElem> stdrow;
183  xercesc::DOMElement *ele=row->getFirstElementChild();
184  while(ele) {
185  stdrow.push_back(createCasADiSXFromXML(ele, nodes));
186  ele=ele->getNextElementSibling();
187  }
188  ret.push_back(stdrow);
189  row=row->getNextElementSibling();
190  }
191 
192  SX m=SX::zeros(ret.size(), ret[0].size());
193  for(size_t c=0; c<ret[0].size(); ++c)
194  for(size_t r=0; r<ret.size(); ++r)
195  m(r,c)=ret[r][c];
196 
197  return m;
198 }
199 
200 inline std::pair<std::vector<SX>, std::vector<SX>> createCasADiFunctionFromXML(xercesc::DOMElement *e) {
201  // create a Function
202  std::map<int, SXNode*> nodes;
203  if(MBXMLUtils::E(e)->getTagName()==CASADI%"Function") {
204  // get all inputs
205  std::vector<SX> in;
206  xercesc::DOMElement *input=e->getFirstElementChild();
207  xercesc::DOMElement *inputEle=input->getFirstElementChild();
208  while(inputEle) {
209  in.push_back(createCasADiSXMatrixFromXML(inputEle, nodes));
210  inputEle=inputEle->getNextElementSibling();
211  }
212  // get all outputs
213  std::vector<SX> out;
214  xercesc::DOMElement *output=input->getNextElementSibling();
215  xercesc::DOMElement *outputEle=output->getFirstElementChild();
216  while(outputEle) {
217  out.push_back(createCasADiSXMatrixFromXML(outputEle, nodes));
218  outputEle=outputEle->getNextElementSibling();
219  }
220 
221  return make_pair(in, out);
222  }
223  else
224  throw std::runtime_error("Unknown XML element named "+MBXMLUtils::X()%e->getTagName()+" in createCasADiFunctionFromXML.");
225 }
226 
227 }
228 
229 #endif
Helper class to easily construct full qualified XML names (FQN) using XML namespace prefixes...
Definition: dom.h:91
Definition: dom.h:41

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML