JSBSim Flight Dynamics Model 1.2.2 (22 Mar 2025)
An Open Source Flight Dynamics and Control Software Library in C++
Loading...
Searching...
No Matches
FGXMLElement.cpp
1/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2
3 Author: Jon Berndt
4 Date started: 09/28/2004
5 Purpose: XML element class
6 Called by: FGXMLParse
7
8 ------------- Copyright (C) 2001 Jon S. Berndt (jon@jsbsim.org) -------------
9
10 This program is free software; you can redistribute it and/or modify it under
11 the terms of the GNU Lesser General Public License as published by the Free
12 Software Foundation; either version 2 of the License, or (at your option) any
13 later version.
14
15 This program is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
18 details.
19
20 You should have received a copy of the GNU Lesser General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc., 59
22 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23
24 Further information about the GNU Lesser General Public License can also be
25 found on the world wide web at http://www.gnu.org.
26
27%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
28INCLUDES
29%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
30
31#include <iostream>
32#include <sstream> // for assembling the error messages / what of exceptions.
33#include <stdexcept> // using domain_error, invalid_argument, and length_error.
34
35#include "FGXMLElement.h"
36#include "FGJSBBase.h"
37#include "input_output/string_utilities.h"
38
39using namespace std;
40
41/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
42FORWARD DECLARATIONS
43%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
44
45namespace JSBSim {
46
47bool Element::converterIsInitialized = false;
48map <string, map <string, double> > Element::convert;
49
50/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
51CLASS IMPLEMENTATION
52%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
53
54Element::Element(const string& nm)
55{
56 name = nm;
57 parent = 0L;
58 element_index = 0;
59 line_number = -1;
60
61 if (!converterIsInitialized) {
62 converterIsInitialized = true;
63 // convert ["from"]["to"] = factor, so: from * factor = to
64 // Length
65 convert["M"]["FT"] = 3.2808399;
66 convert["FT"]["M"] = 1.0/convert["M"]["FT"];
67 convert["CM"]["FT"] = 0.032808399;
68 convert["FT"]["CM"] = 1.0/convert["CM"]["FT"];
69 convert["KM"]["FT"] = 3280.8399;
70 convert["FT"]["KM"] = 1.0/convert["KM"]["FT"];
71 convert["FT"]["IN"] = 12.0;
72 convert["IN"]["FT"] = 1.0/convert["FT"]["IN"];
73 convert["IN"]["M"] = convert["IN"]["FT"] * convert["FT"]["M"];
74 convert["M"]["IN"] = convert["M"]["FT"] * convert["FT"]["IN"];
75 // Area
76 convert["M2"]["FT2"] = convert["M"]["FT"]*convert["M"]["FT"];
77 convert["FT2"]["M2"] = 1.0/convert["M2"]["FT2"];
78 convert["CM2"]["FT2"] = convert["CM"]["FT"]*convert["CM"]["FT"];
79 convert["FT2"]["CM2"] = 1.0/convert["CM2"]["FT2"];
80 convert["M2"]["IN2"] = convert["M"]["IN"]*convert["M"]["IN"];
81 convert["IN2"]["M2"] = 1.0/convert["M2"]["IN2"];
82 convert["FT2"]["IN2"] = 144.0;
83 convert["IN2"]["FT2"] = 1.0/convert["FT2"]["IN2"];
84 // Volume
85 convert["IN3"]["CC"] = 16.387064;
86 convert["CC"]["IN3"] = 1.0/convert["IN3"]["CC"];
87 convert["FT3"]["IN3"] = 1728.0;
88 convert["IN3"]["FT3"] = 1.0/convert["FT3"]["IN3"];
89 convert["M3"]["FT3"] = 35.3146667;
90 convert["FT3"]["M3"] = 1.0/convert["M3"]["FT3"];
91 convert["LTR"]["IN3"] = 61.0237441;
92 convert["IN3"]["LTR"] = 1.0/convert["LTR"]["IN3"];
93 convert["GAL"]["FT3"] = 0.133681;
94 convert["FT3"]["GAL"] = 1.0/convert["GAL"]["FT3"];
95 convert["IN3"]["GAL"] = convert["IN3"]["FT3"]*convert["FT3"]["GAL"];
96 convert["LTR"]["GAL"] = convert["LTR"]["IN3"]*convert["IN3"]["GAL"];
97 convert["M3"]["GAL"] = 1000.*convert["LTR"]["GAL"];
98 convert["CC"]["GAL"] = convert["CC"]["IN3"]*convert["IN3"]["GAL"];
99 // Mass & Weight
100 convert["LBS"]["KG"] = 0.45359237;
101 convert["KG"]["LBS"] = 1.0/convert["LBS"]["KG"];
102 convert["SLUG"]["KG"] = 14.59390;
103 convert["KG"]["SLUG"] = 1.0/convert["SLUG"]["KG"];
104 // Moments of Inertia
105 convert["SLUG*FT2"]["KG*M2"] = 1.35594;
106 convert["KG*M2"]["SLUG*FT2"] = 1.0/convert["SLUG*FT2"]["KG*M2"];
107 // Angles
108 convert["RAD"]["DEG"] = 180.0/M_PI;
109 convert["DEG"]["RAD"] = 1.0/convert["RAD"]["DEG"];
110 // Angular rates
111 convert["RAD/SEC"]["DEG/SEC"] = convert["RAD"]["DEG"];
112 convert["DEG/SEC"]["RAD/SEC"] = 1.0/convert["RAD/SEC"]["DEG/SEC"];
113 // Spring force
114 convert["LBS/FT"]["N/M"] = 14.5939;
115 convert["N/M"]["LBS/FT"] = 1.0/convert["LBS/FT"]["N/M"];
116 // Damping force
117 convert["LBS/FT/SEC"]["N/M/SEC"] = 14.5939;
118 convert["N/M/SEC"]["LBS/FT/SEC"] = 1.0/convert["LBS/FT/SEC"]["N/M/SEC"];
119 // Damping force (Square Law)
120 convert["LBS/FT2/SEC2"]["N/M2/SEC2"] = 47.880259;
121 convert["N/M2/SEC2"]["LBS/FT2/SEC2"] = 1.0/convert["LBS/FT2/SEC2"]["N/M2/SEC2"];
122 // Power
123 convert["WATTS"]["HP"] = 0.001341022;
124 convert["HP"]["WATTS"] = 1.0/convert["WATTS"]["HP"];
125 // Force
126 convert["N"]["LBS"] = 0.22482;
127 convert["LBS"]["N"] = 1.0/convert["N"]["LBS"];
128 // Velocity
129 convert["KTS"]["FT/SEC"] = 1.6878098571;
130 convert["FT/SEC"]["KTS"] = 1.0/convert["KTS"]["FT/SEC"];
131 convert["M/S"]["FT/S"] = 3.2808399;
132 convert["M/S"]["KTS"] = convert["M/S"]["FT/S"]/convert["KTS"]["FT/SEC"];
133 convert["M/SEC"]["FT/SEC"] = 3.2808399;
134 convert["FT/S"]["M/S"] = 1.0/convert["M/S"]["FT/S"];
135 convert["M/SEC"]["FT/SEC"] = 3.2808399;
136 convert["FT/SEC"]["M/SEC"] = 1.0/convert["M/SEC"]["FT/SEC"];
137 convert["KM/SEC"]["FT/SEC"] = 3280.8399;
138 convert["FT/SEC"]["KM/SEC"] = 1.0/convert["KM/SEC"]["FT/SEC"];
139 // Torque
140 convert["FT*LBS"]["N*M"] = 1.35581795;
141 convert["N*M"]["FT*LBS"] = 1/convert["FT*LBS"]["N*M"];
142 // Valve
143 convert["M4*SEC/KG"]["FT4*SEC/SLUG"] = convert["M"]["FT"]*convert["M"]["FT"]*
144 convert["M"]["FT"]*convert["M"]["FT"]/convert["KG"]["SLUG"];
145 convert["FT4*SEC/SLUG"]["M4*SEC/KG"] =
146 1.0/convert["M4*SEC/KG"]["FT4*SEC/SLUG"];
147 // Pressure
148 convert["INHG"]["PSF"] = 70.7180803;
149 convert["PSF"]["INHG"] = 1.0/convert["INHG"]["PSF"];
150 convert["ATM"]["INHG"] = 29.9246899;
151 convert["INHG"]["ATM"] = 1.0/convert["ATM"]["INHG"];
152 convert["PSI"]["INHG"] = 2.03625437;
153 convert["INHG"]["PSI"] = 1.0/convert["PSI"]["INHG"];
154 convert["INHG"]["PA"] = 3386.0; // inches Mercury to pascals
155 convert["PA"]["INHG"] = 1.0/convert["INHG"]["PA"];
156 convert["LBS/FT2"]["N/M2"] = 14.5939/convert["FT"]["M"];
157 convert["N/M2"]["LBS/FT2"] = 1.0/convert["LBS/FT2"]["N/M2"];
158 convert["LBS/FT2"]["PA"] = convert["LBS/FT2"]["N/M2"];
159 convert["PA"]["LBS/FT2"] = 1.0/convert["LBS/FT2"]["PA"];
160 // Mass flow
161 convert["KG/MIN"]["LBS/MIN"] = convert["KG"]["LBS"];
162 convert["KG/SEC"]["LBS/SEC"] = convert["KG"]["LBS"];
163 convert ["N/SEC"]["LBS/SEC"] = 0.224808943;
164 convert ["LBS/SEC"]["N/SEC"] = 1.0/convert ["N/SEC"]["LBS/SEC"];
165 // Fuel Consumption
166 convert["LBS/HP*HR"]["KG/KW*HR"] = 0.6083;
167 convert["KG/KW*HR"]["LBS/HP*HR"] = 1.0/convert["LBS/HP*HR"]["KG/KW*HR"];
168 // Density
169 convert["KG/L"]["LBS/GAL"] = 8.3454045;
170 convert["LBS/GAL"]["KG/L"] = 1.0/convert["KG/L"]["LBS/GAL"];
171 // Gravitational
172 convert["FT3/SEC2"]["M3/SEC2"] = convert["FT3"]["M3"];
173 convert["M3/SEC2"]["FT3/SEC2"] = convert["M3"]["FT3"];
174
175 // Length
176 convert["M"]["M"] = 1.00;
177 convert["KM"]["KM"] = 1.00;
178 convert["FT"]["FT"] = 1.00;
179 convert["IN"]["IN"] = 1.00;
180 // Area
181 convert["M2"]["M2"] = 1.00;
182 convert["FT2"]["FT2"] = 1.00;
183 // Volume
184 convert["IN3"]["IN3"] = 1.00;
185 convert["CC"]["CC"] = 1.0;
186 convert["M3"]["M3"] = 1.0;
187 convert["FT3"]["FT3"] = 1.0;
188 convert["LTR"]["LTR"] = 1.0;
189 convert["GAL"]["GAL"] = 1.0;
190 // Mass & Weight
191 convert["KG"]["KG"] = 1.00;
192 convert["LBS"]["LBS"] = 1.00;
193 // Moments of Inertia
194 convert["KG*M2"]["KG*M2"] = 1.00;
195 convert["SLUG*FT2"]["SLUG*FT2"] = 1.00;
196 // Angles
197 convert["DEG"]["DEG"] = 1.00;
198 convert["RAD"]["RAD"] = 1.00;
199 // Angular rates
200 convert["DEG/SEC"]["DEG/SEC"] = 1.00;
201 convert["RAD/SEC"]["RAD/SEC"] = 1.00;
202 // Spring force
203 convert["LBS/FT"]["LBS/FT"] = 1.00;
204 convert["N/M"]["N/M"] = 1.00;
205 // Damping force
206 convert["LBS/FT/SEC"]["LBS/FT/SEC"] = 1.00;
207 convert["N/M/SEC"]["N/M/SEC"] = 1.00;
208 // Damping force (Square law)
209 convert["LBS/FT2/SEC2"]["LBS/FT2/SEC2"] = 1.00;
210 convert["N/M2/SEC2"]["N/M2/SEC2"] = 1.00;
211 // Power
212 convert["HP"]["HP"] = 1.00;
213 convert["WATTS"]["WATTS"] = 1.00;
214 // Force
215 convert["N"]["N"] = 1.00;
216 // Velocity
217 convert["FT/SEC"]["FT/SEC"] = 1.00;
218 convert["KTS"]["KTS"] = 1.00;
219 convert["M/S"]["M/S"] = 1.0;
220 convert["M/SEC"]["M/SEC"] = 1.0;
221 convert["KM/SEC"]["KM/SEC"] = 1.0;
222 // Torque
223 convert["FT*LBS"]["FT*LBS"] = 1.00;
224 convert["N*M"]["N*M"] = 1.00;
225 // Valve
226 convert["M4*SEC/KG"]["M4*SEC/KG"] = 1.0;
227 convert["FT4*SEC/SLUG"]["FT4*SEC/SLUG"] = 1.0;
228 // Pressure
229 convert["PSI"]["PSI"] = 1.00;
230 convert["PSF"]["PSF"] = 1.00;
231 convert["INHG"]["INHG"] = 1.00;
232 convert["ATM"]["ATM"] = 1.0;
233 convert["PA"]["PA"] = 1.0;
234 convert["N/M2"]["N/M2"] = 1.00;
235 convert["LBS/FT2"]["LBS/FT2"] = 1.00;
236 // Mass flow
237 convert["LBS/SEC"]["LBS/SEC"] = 1.00;
238 convert["KG/MIN"]["KG/MIN"] = 1.0;
239 convert["LBS/MIN"]["LBS/MIN"] = 1.0;
240 convert["N/SEC"]["N/SEC"] = 1.0;
241 // Fuel Consumption
242 convert["LBS/HP*HR"]["LBS/HP*HR"] = 1.0;
243 convert["KG/KW*HR"]["KG/KW*HR"] = 1.0;
244 // Density
245 convert["KG/L"]["KG/L"] = 1.0;
246 convert["LBS/GAL"]["LBS/GAL"] = 1.0;
247 // Gravitational
248 convert["FT3/SEC2"]["FT3/SEC2"] = 1.0;
249 convert["M3/SEC2"]["M3/SEC2"] = 1.0;
250 // Electrical
251 convert["VOLTS"]["VOLTS"] = 1.0;
252 convert["OHMS"]["OHMS"] = 1.0;
253 convert["AMPERES"]["AMPERES"] = 1.0;
254 }
255}
256
257//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
258
259Element::~Element(void)
260{
261 for (unsigned int i = 0; i < children.size(); ++i)
262 children[i]->SetParent(0);
263}
264
265//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
266
267string Element::GetAttributeValue(const string& attr)
268{
269 if (HasAttribute(attr)) return attributes[attr];
270 else return ("");
271}
272
273//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
274
275bool Element::SetAttributeValue(const std::string& key, const std::string& value)
276{
277 bool ret = HasAttribute(key);
278 if (ret)
279 attributes[key] = value;
280
281 return ret;
282}
283
284//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
285
286double Element::GetAttributeValueAsNumber(const string& attr)
287{
288 string attribute = GetAttributeValue(attr);
289
290 if (attribute.empty()) {
291 std::stringstream s;
292 s << ReadFrom() << "Expecting numeric attribute value, but got no data";
293 cerr << s.str() << endl;
294 throw length_error(s.str());
295 }
296 else {
297 double number=0;
298 try {
299 number = atof_locale_c(attribute);
300 } catch (InvalidNumber& e) {
301 std::stringstream s;
302 s << ReadFrom() << e.what();
303 cerr << s.str() << endl;
304 throw BaseException(s.str());
305 }
306
307 return (number);
308 }
309}
310
311//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
312
313Element* Element::GetElement(unsigned int el)
314{
315 if (children.size() > el) {
316 element_index = el;
317 return children[el];
318 }
319 else {
320 element_index = 0;
321 return 0L;
322 }
323}
324
325//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
326
327Element* Element::GetNextElement(void)
328{
329 if (children.size() > element_index+1) {
330 element_index++;
331 return children[element_index];
332 } else {
333 element_index = 0;
334 return 0L;
335 }
336}
337
338//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
339
340string Element::GetDataLine(unsigned int i)
341{
342 if (!data_lines.empty()) return data_lines[i];
343 else return string("");
344}
345
346//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
347
348double Element::GetDataAsNumber(void)
349{
350 if (data_lines.size() == 1) {
351 double number=0;
352 try {
353 number = atof_locale_c(data_lines[0]);
354 } catch (InvalidNumber& e) {
355 std::stringstream s;
356 s << ReadFrom() << e.what();
357 cerr << s.str() << endl;
358 throw BaseException(s.str());
359 }
360
361 return number;
362 } else if (data_lines.empty()) {
363 std::stringstream s;
364 s << ReadFrom() << "Expected numeric value, but got no data";
365 cerr << s.str() << endl;
366 throw length_error(s.str());
367 } else {
368 cerr << ReadFrom() << "Attempting to get single data value in element "
369 << "<" << name << ">" << endl
370 << " from multiple lines:" << endl;
371 for(unsigned int i=0; i<data_lines.size(); ++i)
372 cerr << data_lines[i] << endl;
373 std::stringstream s;
374 s << ReadFrom() << "Attempting to get single data value in element "
375 << "<" << name << ">"
376 << " from multiple lines (" << data_lines.size() << ").";
377 throw length_error(s.str());
378 }
379}
380
381//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
382
383unsigned int Element::GetNumElements(const string& element_name)
384{
385 unsigned int number_of_elements=0;
386 Element* el=FindElement(element_name);
387 while (el) {
388 number_of_elements++;
389 el=FindNextElement(element_name);
390 }
391 return number_of_elements;
392}
393
394//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
395
396Element* Element::FindElement(const string& el)
397{
398 if (el.empty() && children.size() >= 1) {
399 element_index = 1;
400 return children[0];
401 }
402 for (unsigned int i=0; i<children.size(); i++) {
403 if (el == children[i]->GetName()) {
404 element_index = i+1;
405 return children[i];
406 }
407 }
408 element_index = 0;
409 return 0L;
410}
411
412//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
413
414Element* Element::FindNextElement(const string& el)
415{
416 if (el.empty()) {
417 if (element_index < children.size()) {
418 return children[element_index++];
419 } else {
420 element_index = 0;
421 return 0L;
422 }
423 }
424 for (unsigned int i=element_index; i<children.size(); i++) {
425 if (el == children[i]->GetName()) {
426 element_index = i+1;
427 return children[i];
428 }
429 }
430 element_index = 0;
431 return 0L;
432}
433
434//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
435
436double Element::FindElementValueAsNumber(const string& el)
437{
438 Element* element = FindElement(el);
439 if (element) {
440 double value = element->GetDataAsNumber();
441 value = DisperseValue(element, value);
442 return value;
443 } else {
444 std::stringstream s;
445 s << ReadFrom() << "Attempting to get non-existent element " << el;
446 cerr << s.str() << endl;
447 throw length_error(s.str());
448 }
449}
450
451//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
452
453bool Element::FindElementValueAsBoolean(const string& el)
454{
455 Element* element = FindElement(el);
456 if (element) {
457 // check value as an ordinary number
458 double value = element->GetDataAsNumber();
459
460 // now check how it should return data
461 if (value == 0) {
462 return false;
463 } else {
464 return true;
465 }
466 } else {
467 cerr << ReadFrom() << "Attempting to get non-existent element " << el << " ;returning false"
468 << endl;
469 return false;
470 }
471}
472
473//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
474
475string Element::FindElementValue(const string& el)
476{
477 Element* element = FindElement(el);
478 if (element) {
479 return element->GetDataLine();
480 } else {
481 return "";
482 }
483}
484
485//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
486
487double Element::FindElementValueAsNumberConvertTo(const string& el, const string& target_units)
488{
489 Element* element = FindElement(el);
490
491 if (!element) {
492 std::stringstream s;
493 s << ReadFrom() << "Attempting to get non-existent element " << el;
494 cerr << s.str() << endl;
495 throw length_error(s.str());
496 }
497
498 string supplied_units = element->GetAttributeValue("unit");
499
500 if (!supplied_units.empty()) {
501 if (convert.find(supplied_units) == convert.end()) {
502 std::stringstream s;
503 s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
504 << "\" does not exist (typo?).";
505 cerr << s.str() << endl;
506 throw invalid_argument(s.str());
507 }
508 if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
509 std::stringstream s;
510 s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
511 << "\" cannot be converted to " << target_units;
512 cerr << s.str() << endl;
513 throw invalid_argument(s.str());
514 }
515 }
516
517 double value = element->GetDataAsNumber();
518
519 // Sanity check for angular values
520 if ((supplied_units == "RAD") && (fabs(value) > 2 * M_PI)) {
521 cerr << element->ReadFrom() << element->GetName() << " value "
522 << value << " RAD is outside the range [ -2*M_PI RAD ; +2*M_PI RAD ]"
523 << endl;
524 }
525 if ((supplied_units == "DEG") && (fabs(value) > 360.0)) {
526 cerr << element->ReadFrom() << element->GetName() << " value "
527 << value << " DEG is outside the range [ -360 DEG ; +360 DEG ]"
528 << endl;
529 }
530
531
532 if (!supplied_units.empty()) {
533 value *= convert[supplied_units][target_units];
534 }
535
536 if ((target_units == "RAD") && (fabs(value) > 2 * M_PI)) {
537 cerr << element->ReadFrom() << element->GetName() << " value "
538 << value << " RAD is outside the range [ -2*M_PI RAD ; +2*M_PI RAD ]"
539 << endl;
540 }
541 if ((target_units == "DEG") && (fabs(value) > 360.0)) {
542 cerr << element->ReadFrom() << element->GetName() << " value "
543 << value << " DEG is outside the range [ -360 DEG ; +360 DEG ]"
544 << endl;
545 }
546
547 value = DisperseValue(element, value, supplied_units, target_units);
548
549 return value;
550}
551
552//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
553
554double Element::FindElementValueAsNumberConvertFromTo( const string& el,
555 const string& supplied_units,
556 const string& target_units)
557{
558 Element* element = FindElement(el);
559
560 if (!element) {
561 std::stringstream s;
562 s << ReadFrom() << "Attempting to get non-existent element " << el;
563 cerr << s.str() << endl;
564 throw length_error(s.str());
565 }
566
567 if (!supplied_units.empty()) {
568 if (convert.find(supplied_units) == convert.end()) {
569 std::stringstream s;
570 s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
571 << "\" does not exist (typo?).";
572 cerr << s.str() << endl;
573 throw invalid_argument(s.str());
574 }
575 if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
576 std::stringstream s;
577 s << element->ReadFrom() << "Supplied unit: \"" << supplied_units
578 << "\" cannot be converted to " << target_units;
579 cerr << s.str() << endl;
580 throw invalid_argument(s.str());
581 }
582 }
583
584 double value = element->GetDataAsNumber();
585 if (!supplied_units.empty()) {
586 value *= convert[supplied_units][target_units];
587 }
588
589 value = DisperseValue(element, value, supplied_units, target_units);
590
591 return value;
592}
593
594//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
595
596FGColumnVector3 Element::FindElementTripletConvertTo( const string& target_units)
597{
598 FGColumnVector3 triplet;
599 Element* item;
600 double value=0.0;
601 string supplied_units = GetAttributeValue("unit");
602
603 if (!supplied_units.empty()) {
604 if (convert.find(supplied_units) == convert.end()) {
605 std::stringstream s;
606 s << ReadFrom() << "Supplied unit: \"" << supplied_units
607 << "\" does not exist (typo?).";
608 cerr << s.str() << endl;
609 throw invalid_argument(s.str());
610 }
611 if (convert[supplied_units].find(target_units) == convert[supplied_units].end()) {
612 std::stringstream s;
613 s << ReadFrom() << "Supplied unit: \"" << supplied_units
614 << "\" cannot be converted to " << target_units;
615 cerr << s.str() << endl;
616 throw invalid_argument(s.str());
617 }
618 }
619
620 item = FindElement("x");
621 if (!item) item = FindElement("roll");
622 if (item) {
623 value = item->GetDataAsNumber();
624 if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
625 triplet(1) = DisperseValue(item, value, supplied_units, target_units);
626 } else {
627 triplet(1) = 0.0;
628 }
629
630
631 item = FindElement("y");
632 if (!item) item = FindElement("pitch");
633 if (item) {
634 value = item->GetDataAsNumber();
635 if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
636 triplet(2) = DisperseValue(item, value, supplied_units, target_units);
637 } else {
638 triplet(2) = 0.0;
639 }
640
641 item = FindElement("z");
642 if (!item) item = FindElement("yaw");
643 if (item) {
644 value = item->GetDataAsNumber();
645 if (!supplied_units.empty()) value *= convert[supplied_units][target_units];
646 triplet(3) = DisperseValue(item, value, supplied_units, target_units);
647 } else {
648 triplet(3) = 0.0;
649 }
650
651 return triplet;
652}
653
654//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
655
656double Element::DisperseValue(Element *e, double val, const std::string& supplied_units,
657 const std::string& target_units)
658{
659 double value=val;
660
661 bool disperse = false;
662 try {
663 char* num = getenv("JSBSIM_DISPERSE");
664 if (num) {
665 disperse = (atoi(num) == 1); // set dispersions
666 }
667 } catch (...) { // if error set to false
668 disperse = false;
669 std::cerr << "Could not process JSBSIM_DISPERSE environment variable: Assumed NO dispersions." << endl;
670 }
671
672 if (e->HasAttribute("dispersion") && disperse) {
673 double disp = e->GetAttributeValueAsNumber("dispersion");
674 if (!supplied_units.empty()) disp *= convert[supplied_units][target_units];
675 string attType = e->GetAttributeValue("type");
676 RandomNumberGenerator generator;
677
678 if (attType == "gaussian" || attType == "gaussiansigned") {
679 double grn = generator.GetNormalRandomNumber();
680 if (attType == "gaussian")
681 value = val + disp*grn;
682 else // Assume gaussiansigned
683 value = (val + disp*grn)*FGJSBBase::sign(grn);
684 } else if (attType == "uniform" || attType == "uniformsigned") {
685 double urn = generator.GetUniformRandomNumber();
686 if (attType == "uniform")
687 value = val + disp * urn;
688 else // Assume uniformsigned
689 value = (val + disp * urn)*FGJSBBase::sign(urn);
690 } else {
691 std::stringstream s;
692 s << ReadFrom() << "Unknown dispersion type" << attType;
693 cerr << s.str() << endl;
694 throw domain_error(s.str());
695 }
696
697 }
698 return value;
699}
700
701//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
702
703void Element::Print(unsigned int level)
704{
705 unsigned int i, spaces;
706
707 level+=2;
708 for (spaces=0; spaces<=level; spaces++) cout << " "; // format output
709 cout << "Element Name: " << name;
710
711 map<string, string>::iterator it;
712 for (it = attributes.begin(); it != attributes.end(); ++it)
713 cout << " " << it->first << " = " << it->second;
714
715 cout << endl;
716 for (i=0; i<data_lines.size(); i++) {
717 for (spaces=0; spaces<=level; spaces++) cout << " "; // format output
718 cout << data_lines[i] << endl;
719 }
720 for (i=0; i<children.size(); i++) {
721 children[i]->Print(level);
722 }
723}
724
725//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
726
727void Element::AddAttribute(const string& name, const string& value)
728{
729 attributes[name] = value;
730}
731
732//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
733
734void Element::AddData(string d)
735{
736 string::size_type string_start = d.find_first_not_of(" \t");
737 if (string_start != string::npos && string_start > 0) {
738 d.erase(0,string_start);
739 }
740 data_lines.push_back(d);
741}
742
743//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
744
745string Element::ReadFrom(void) const
746{
747 ostringstream message;
748
749 message << endl
750 << "In file " << GetFileName() << ": line " << GetLineNumber()
751 << endl;
752
753 return message.str();
754}
755
756//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
757
758void Element::MergeAttributes(Element* el)
759{
760 map<string, string>::iterator it;
761
762 for (it=el->attributes.begin(); it != el->attributes.end(); ++it) {
763 if (attributes.find(it->first) == attributes.end())
764 attributes[it->first] = it->second;
765 else {
766 if (FGJSBBase::debug_lvl > 0 && (attributes[it->first] != it->second))
767 cout << el->ReadFrom() << " Attribute '" << it->first << "' is overridden in file "
768 << GetFileName() << ": line " << GetLineNumber() << endl
769 << " The value '" << attributes[it->first] << "' will be used instead of '"
770 << it->second << "'." << endl;
771 }
772 }
773}
774
775} // end namespace JSBSim
JSBSim::Element::FindElement
Element * FindElement(const std::string &el="")
Searches for a specified element.
Definition FGXMLElement.cpp:396
JSBSim::Element::GetName
const std::string & GetName(void) const
Retrieves the element name.
Definition FGXMLElement.h:179
JSBSim::Element::SetAttributeValue
bool SetAttributeValue(const std::string &key, const std::string &value)
Modifies an attribute.
Definition FGXMLElement.cpp:275
JSBSim::Element::GetAttributeValueAsNumber
double GetAttributeValueAsNumber(const std::string &key)
Retrieves an attribute value as a double precision real number.
Definition FGXMLElement.cpp:286
JSBSim::Element::FindElementTripletConvertTo
FGColumnVector3 FindElementTripletConvertTo(const std::string &target_units)
Composes a 3-element column vector for the supplied location or orientation.
Definition FGXMLElement.cpp:596
JSBSim::Element::GetElement
Element * GetElement(unsigned int el=0)
Returns a pointer to the element requested by index.
Definition FGXMLElement.cpp:313
JSBSim::Element::Element
Element(const std::string &nm)
Constructor.
Definition FGXMLElement.cpp:54
JSBSim::Element::FindElementValueAsBoolean
bool FindElementValueAsBoolean(const std::string &el="")
Searches for the named element and returns the data belonging to it as a bool.
Definition FGXMLElement.cpp:453
JSBSim::Element::GetAttributeValue
std::string GetAttributeValue(const std::string &key)
Retrieves an attribute.
Definition FGXMLElement.cpp:267
JSBSim::Element::GetLineNumber
int GetLineNumber(void) const
Returns the line number at which the element has been defined.
Definition FGXMLElement.h:230
JSBSim::Element::GetDataLine
std::string GetDataLine(unsigned int i=0)
Gets a line of data belonging to an element.
Definition FGXMLElement.cpp:340
JSBSim::Element::GetFileName
const std::string & GetFileName(void) const
Returns the name of the file in which the element has been read.
Definition FGXMLElement.h:235
JSBSim::Element::GetNumElements
unsigned int GetNumElements(void)
Returns the number of child elements for this element.
Definition FGXMLElement.h:192
JSBSim::Element::MergeAttributes
void MergeAttributes(Element *el)
Merges the attributes of the current element with another element.
Definition FGXMLElement.cpp:758
JSBSim::Element::AddAttribute
void AddAttribute(const std::string &name, const std::string &value)
Stores an attribute belonging to this element.
Definition FGXMLElement.cpp:727
JSBSim::Element::ReadFrom
std::string ReadFrom(void) const
Return a string that contains a description of the location where the current XML element was read fr...
Definition FGXMLElement.cpp:745
JSBSim::Element::FindElementValue
std::string FindElementValue(const std::string &el="")
Searches for the named element and returns the string data belonging to it.
Definition FGXMLElement.cpp:475
JSBSim::Element::Print
void Print(unsigned int level=0)
Prints the element.
Definition FGXMLElement.cpp:703
JSBSim::Element::FindElementValueAsNumberConvertTo
double FindElementValueAsNumberConvertTo(const std::string &el, const std::string &target_units)
Searches for the named element and converts and returns the data belonging to it.
Definition FGXMLElement.cpp:487
JSBSim::Element::FindNextElement
Element * FindNextElement(const std::string &el="")
Searches for the next element as specified.
Definition FGXMLElement.cpp:414
JSBSim::Element::GetDataAsNumber
double GetDataAsNumber(void)
Converts the element data to a number.
Definition FGXMLElement.cpp:348
JSBSim::Element::HasAttribute
bool HasAttribute(const std::string &key)
Determines if an element has the supplied attribute.
Definition FGXMLElement.h:155
JSBSim::Element::SetParent
void SetParent(Element *p)
This function sets the value of the parent class attribute to the supplied Element pointer.
Definition FGXMLElement.h:341
JSBSim::Element::GetNextElement
Element * GetNextElement(void)
Returns a pointer to the next element in the list.
Definition FGXMLElement.cpp:327
JSBSim::Element::FindElementValueAsNumberConvertFromTo
double FindElementValueAsNumberConvertFromTo(const std::string &el, const std::string &supplied_units, const std::string &target_units)
Searches for the named element and converts and returns the data belonging to it.
Definition FGXMLElement.cpp:554
JSBSim::Element::FindElementValueAsNumber
double FindElementValueAsNumber(const std::string &el="")
Searches for the named element and returns the data belonging to it as a number.
Definition FGXMLElement.cpp:436
JSBSim::Element::AddData
void AddData(std::string d)
Stores data belonging to this element.
Definition FGXMLElement.cpp:734
JSBSim::Element::~Element
~Element(void)
Destructor.
Definition FGXMLElement.cpp:259
JSBSim::FGColumnVector3
This class implements a 3 element column vector.
Definition FGColumnVector3.h:66