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

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Home