ARTS 2.5.11 (git: 6827797f)
xml_io_array_types.cc
Go to the documentation of this file.
1
2// File description
4
13#include "arts.h"
14#include "xml_io.h"
15
17// Overloaded functions for reading/writing data from/to XML stream
19
20//=== ArrayOfAgenda ===========================================
21
23
28void xml_read_from_stream(istream& is_xml _U_,
29 ArrayOfAgenda& aa _U_,
30 bifstream* pbifs _U_,
31 const Verbosity&) {
32 throw runtime_error("Not supported.");
33}
34
36
42void xml_write_to_stream(ostream& os_xml _U_,
43 const ArrayOfAgenda& aa _U_,
44 bofstream* pbofs _U_,
45 const String& name _U_,
46 const Verbosity&)
47
48{
49 throw runtime_error("ArrayOfAgendas can't be saved.");
50}
51
52//=== ArrayOfArrayOfSpeciesTag ================================================
53
55
60void xml_read_from_stream(istream& is_xml,
61 ArrayOfArrayOfSpeciesTag& aastag,
62 bifstream* pbifs,
63 const Verbosity& verbosity) {
64 ArtsXMLTag tag(verbosity);
65 Index nelem;
66
67 tag.read_from_stream(is_xml);
68 tag.check_name("Array");
69 tag.check_attribute("type", "ArrayOfSpeciesTag");
70
71 tag.get_attribute_value("nelem", nelem);
72 aastag.resize(nelem);
73
74 Index n;
75 try {
76 for (n = 0; n < nelem; n++) {
77 xml_read_from_stream(is_xml, aastag[n], pbifs, verbosity);
78 }
79 } catch (const std::runtime_error& e) {
80 ostringstream os;
81 os << "Error reading ArrayOfArrayOfSpeciesTag: "
82 << "\n Element: " << n << "\n"
83 << e.what();
84 throw runtime_error(os.str());
85 }
86
87 tag.read_from_stream(is_xml);
88 tag.check_name("/Array");
89}
90
92
98void xml_write_to_stream(ostream& os_xml,
99 const ArrayOfArrayOfSpeciesTag& aastag,
100 bofstream* pbofs,
101 const String& name,
102 const Verbosity& verbosity) {
103 ArtsXMLTag open_tag(verbosity);
104 ArtsXMLTag close_tag(verbosity);
105
106 open_tag.set_name("Array");
107 if (name.length()) open_tag.add_attribute("name", name);
108
109 open_tag.add_attribute("type", "ArrayOfSpeciesTag");
110 open_tag.add_attribute("nelem", aastag.nelem());
111
112 open_tag.write_to_stream(os_xml);
113 os_xml << '\n';
114
115 for (Index n = 0; n < aastag.nelem(); n++) {
116 xml_write_to_stream(os_xml, aastag[n], pbofs, "", verbosity);
117 }
118
119 close_tag.set_name("/Array");
120 close_tag.write_to_stream(os_xml);
121
122 os_xml << '\n';
123}
124
125//=== ArrayOfArrayOfString ==========================================================
126
128
133void xml_read_from_stream(istream& is_xml,
134 ArrayOfArrayOfString& aastring,
135 bifstream* pbifs,
136 const Verbosity& verbosity) {
137 ArtsXMLTag tag(verbosity);
138 Index nelem;
139
140 tag.read_from_stream(is_xml);
141 tag.check_name("Array");
142
143 tag.check_attribute("type", "ArrayOfString");
144
145 tag.get_attribute_value("nelem", nelem);
146 aastring.resize(nelem);
147
148 Index n;
149 try {
150 for (n = 0; n < nelem; n++)
151 xml_read_from_stream(is_xml, aastring[n], pbifs, verbosity);
152 } catch (const std::runtime_error& e) {
153 ostringstream os;
154 os << "Error reading ArrayOfArrayOfString: "
155 << "\n Element: " << n << "\n"
156 << e.what();
157 throw runtime_error(os.str());
158 }
159
160 tag.read_from_stream(is_xml);
161 tag.check_name("/Array");
162}
163
165
171void xml_write_to_stream(ostream& os_xml,
172 const ArrayOfArrayOfString& aastring,
173 bofstream* pbofs,
174 const String& name,
175 const Verbosity& verbosity) {
176 ArtsXMLTag open_tag(verbosity);
177 ArtsXMLTag close_tag(verbosity);
178
179 open_tag.set_name("Array");
180 if (name.length()) open_tag.add_attribute("name", name);
181
182 open_tag.add_attribute("type", "ArrayOfString");
183 open_tag.add_attribute("nelem", aastring.nelem());
184
185 open_tag.write_to_stream(os_xml);
186 os_xml << '\n';
187
188 for (Index n = 0; n < aastring.nelem(); n++)
189 xml_write_to_stream(os_xml, aastring[n], pbofs, "", verbosity);
190
191 close_tag.set_name("/Array");
192 close_tag.write_to_stream(os_xml);
193
194 os_xml << '\n';
195}
196
197//=== ArrayOfPpath =========================================================
198
200
205void xml_read_from_stream(istream& is_xml,
206 ArrayOfPpath& appath,
207 bifstream* pbifs,
208 const Verbosity& verbosity) {
209 ArtsXMLTag tag(verbosity);
210 Index nelem;
211
212 tag.read_from_stream(is_xml);
213 tag.check_name("Array");
214 tag.check_attribute("type", "Ppath");
215
216 tag.get_attribute_value("nelem", nelem);
217 appath.resize(nelem);
218
219 Index n;
220 try {
221 for (n = 0; n < nelem; n++) {
222 xml_read_from_stream(is_xml, appath[n], pbifs, verbosity);
223 }
224 } catch (const std::runtime_error& e) {
225 ostringstream os;
226 os << "Error reading ArrayOfPpath: "
227 << "\n Element: " << n << "\n"
228 << e.what();
229 throw runtime_error(os.str());
230 }
231
232 tag.read_from_stream(is_xml);
233 tag.check_name("/Array");
234}
235
237
243void xml_write_to_stream(ostream& os_xml,
244 const ArrayOfPpath& appath,
245 bofstream* pbofs,
246 const String& name,
247 const Verbosity& verbosity) {
248 ArtsXMLTag open_tag(verbosity);
249 ArtsXMLTag close_tag(verbosity);
250
251 open_tag.set_name("Array");
252 if (name.length()) open_tag.add_attribute("name", name);
253
254 open_tag.add_attribute("type", "Ppath");
255 open_tag.add_attribute("nelem", appath.nelem());
256
257 open_tag.write_to_stream(os_xml);
258 os_xml << '\n';
259
260 for (Index n = 0; n < appath.nelem(); n++) {
261 xml_write_to_stream(os_xml, appath[n], pbofs, "", verbosity);
262 }
263
264 close_tag.set_name("/Array");
265 close_tag.write_to_stream(os_xml);
266
267 os_xml << '\n';
268}
269
270//=== ArrayOfArrayOfTensor3==================================================
271
273
278void xml_read_from_stream(istream& is_xml,
279 ArrayOfArrayOfTensor3& aatensor3,
280 bifstream* pbifs,
281 const Verbosity& verbosity) {
282 ArtsXMLTag tag(verbosity);
283 Index nelem;
284
285 tag.read_from_stream(is_xml);
286 tag.check_name("Array");
287 tag.check_attribute("type", "ArrayOfTensor3");
288
289 tag.get_attribute_value("nelem", nelem);
290 aatensor3.resize(nelem);
291
292 Index n;
293 try {
294 for (n = 0; n < nelem; n++)
295 xml_read_from_stream(is_xml, aatensor3[n], pbifs, verbosity);
296 } catch (const std::runtime_error& e) {
297 ostringstream os;
298 os << "Error reading ArrayOfArrayOfTensor3: "
299 << "\n Element: " << n << "\n"
300 << e.what();
301 throw runtime_error(os.str());
302 }
303
304 tag.read_from_stream(is_xml);
305 tag.check_name("/Array");
306}
307
309
315void xml_write_to_stream(ostream& os_xml,
316 const ArrayOfArrayOfTensor3& aatensor3,
317 bofstream* pbofs,
318 const String& name,
319 const Verbosity& verbosity) {
320 ArtsXMLTag open_tag(verbosity);
321 ArtsXMLTag close_tag(verbosity);
322
323 open_tag.set_name("Array");
324 if (name.length()) open_tag.add_attribute("name", name);
325
326 open_tag.add_attribute("type", "ArrayOfTensor3");
327 open_tag.add_attribute("nelem", aatensor3.nelem());
328
329 open_tag.write_to_stream(os_xml);
330 os_xml << '\n';
331
332 for (Index n = 0; n < aatensor3.nelem(); n++) {
333 xml_write_to_stream(os_xml, aatensor3[n], pbofs, "", verbosity);
334 }
335
336 close_tag.set_name("/Array");
337 close_tag.write_to_stream(os_xml);
338
339 os_xml << '\n';
340}
341
342//=== ArrayOfArrayOfTensor6==================================================
343
345
350void xml_read_from_stream(istream& is_xml,
351 ArrayOfArrayOfTensor6& aatensor6,
352 bifstream* pbifs,
353 const Verbosity& verbosity) {
354 ArtsXMLTag tag(verbosity);
355 Index nelem;
356
357 tag.read_from_stream(is_xml);
358 tag.check_name("Array");
359 tag.check_attribute("type", "ArrayOfTensor6");
360
361 tag.get_attribute_value("nelem", nelem);
362 aatensor6.resize(nelem);
363
364 Index n;
365 try {
366 for (n = 0; n < nelem; n++)
367 xml_read_from_stream(is_xml, aatensor6[n], pbifs, verbosity);
368 } catch (const std::runtime_error& e) {
369 ostringstream os;
370 os << "Error reading ArrayOfArrayOfTensor6: "
371 << "\n Element: " << n << "\n"
372 << e.what();
373 throw runtime_error(os.str());
374 }
375
376 tag.read_from_stream(is_xml);
377 tag.check_name("/Array");
378}
379
381
387void xml_write_to_stream(ostream& os_xml,
388 const ArrayOfArrayOfTensor6& aatensor6,
389 bofstream* pbofs,
390 const String& name,
391 const Verbosity& verbosity) {
392 ArtsXMLTag open_tag(verbosity);
393 ArtsXMLTag close_tag(verbosity);
394
395 open_tag.set_name("Array");
396 if (name.length()) open_tag.add_attribute("name", name);
397
398 open_tag.add_attribute("type", "ArrayOfTensor6");
399 open_tag.add_attribute("nelem", aatensor6.nelem());
400
401 open_tag.write_to_stream(os_xml);
402 os_xml << '\n';
403
404 for (Index n = 0; n < aatensor6.nelem(); n++)
405 xml_write_to_stream(os_xml, aatensor6[n], pbofs, "", verbosity);
406
407 close_tag.set_name("/Array");
408 close_tag.write_to_stream(os_xml);
409
410 os_xml << '\n';
411}
412
413//=== ArrayOfGridPos =========================================================
414
416
421void xml_read_from_stream(istream& is_xml,
422 ArrayOfGridPos& agpos,
423 bifstream* pbifs,
424 const Verbosity& verbosity) {
425 ArtsXMLTag tag(verbosity);
426 Index nelem;
427
428 tag.read_from_stream(is_xml);
429 tag.check_name("Array");
430 tag.check_attribute("type", "GridPos");
431
432 tag.get_attribute_value("nelem", nelem);
433 agpos.resize(nelem);
434
435 Index n;
436 try {
437 for (n = 0; n < nelem; n++)
438 xml_read_from_stream(is_xml, agpos[n], pbifs, verbosity);
439 } catch (const std::runtime_error& e) {
440 ostringstream os;
441 os << "Error reading ArrayOfGridPos: "
442 << "\n Element: " << n << "\n"
443 << e.what();
444 throw runtime_error(os.str());
445 }
446
447 tag.read_from_stream(is_xml);
448 tag.check_name("/Array");
449}
450
452
458void xml_write_to_stream(ostream& os_xml,
459 const ArrayOfGridPos& agpos,
460 bofstream* pbofs,
461 const String& name,
462 const Verbosity& verbosity) {
463 ArtsXMLTag open_tag(verbosity);
464 ArtsXMLTag close_tag(verbosity);
465
466 open_tag.set_name("Array");
467 if (name.length()) open_tag.add_attribute("name", name);
468
469 open_tag.add_attribute("type", "GridPos");
470 open_tag.add_attribute("nelem", agpos.nelem());
471
472 open_tag.write_to_stream(os_xml);
473 os_xml << '\n';
474
475 for (Index n = 0; n < agpos.nelem(); n++)
476 xml_write_to_stream(os_xml, agpos[n], pbofs, "", verbosity);
477
478 close_tag.set_name("/Array");
479 close_tag.write_to_stream(os_xml);
480
481 os_xml << '\n';
482}
483
484//=== ArrayOfArrayOfGridPos =====================================
485
487
492void xml_read_from_stream(istream& is_xml,
493 ArrayOfArrayOfGridPos& aagpos,
494 bifstream* pbifs,
495 const Verbosity& verbosity) {
496 ArtsXMLTag tag(verbosity);
497 Index nelem;
498
499 tag.read_from_stream(is_xml);
500 tag.check_name("Array");
501 tag.check_attribute("type", "ArrayOfGridPos");
502
503 tag.get_attribute_value("nelem", nelem);
504 aagpos.resize(nelem);
505
506 Index n;
507 try {
508 for (n = 0; n < nelem; n++)
509 xml_read_from_stream(is_xml, aagpos[n], pbifs, verbosity);
510 } catch (const std::runtime_error& e) {
511 ostringstream os;
512 os << "Error reading ArrayOfArrayOfGridPos: "
513 << "\n Element: " << n << "\n"
514 << e.what();
515 throw runtime_error(os.str());
516 }
517
518 tag.read_from_stream(is_xml);
519 tag.check_name("/Array");
520}
521
523
529void xml_write_to_stream(ostream& os_xml,
530 const ArrayOfArrayOfGridPos& aagpos,
531 bofstream* pbofs,
532 const String& name,
533 const Verbosity& verbosity) {
534 ArtsXMLTag open_tag(verbosity);
535 ArtsXMLTag close_tag(verbosity);
536
537 open_tag.set_name("Array");
538 if (name.length()) open_tag.add_attribute("name", name);
539
540 open_tag.add_attribute("type", "ArrayOfGridPos");
541 open_tag.add_attribute("nelem", aagpos.nelem());
542
543 open_tag.write_to_stream(os_xml);
544 os_xml << '\n';
545
546 for (Index n = 0; n < aagpos.nelem(); n++)
547 xml_write_to_stream(os_xml, aagpos[n], pbofs, "", verbosity);
548
549 close_tag.set_name("/Array");
550 close_tag.write_to_stream(os_xml);
551
552 os_xml << '\n';
553}
554
555//=== ArrayOfArrayOfArrayOfGridPos =====================================
556
558
563void xml_read_from_stream(istream& is_xml,
564 ArrayOfArrayOfArrayOfGridPos& aaagpos,
565 bifstream* pbifs,
566 const Verbosity& verbosity) {
567 ArtsXMLTag tag(verbosity);
568 Index nelem;
569
570 tag.read_from_stream(is_xml);
571 tag.check_name("Array");
572 tag.check_attribute("type", "ArrayOfArrayOfGridPos");
573
574 tag.get_attribute_value("nelem", nelem);
575 aaagpos.resize(nelem);
576
577 Index n;
578 try {
579 for (n = 0; n < nelem; n++)
580 xml_read_from_stream(is_xml, aaagpos[n], pbifs, verbosity);
581 } catch (const std::runtime_error& e) {
582 ostringstream os;
583 os << "Error reading ArrayOfArrayOfArrayOfGridPos: "
584 << "\n Element: " << n << "\n"
585 << e.what();
586 throw runtime_error(os.str());
587 }
588
589 tag.read_from_stream(is_xml);
590 tag.check_name("/Array");
591}
592
594
600void xml_write_to_stream(ostream& os_xml,
601 const ArrayOfArrayOfArrayOfGridPos& aaagpos,
602 bofstream* pbofs,
603 const String& name,
604 const Verbosity& verbosity) {
605 ArtsXMLTag open_tag(verbosity);
606 ArtsXMLTag close_tag(verbosity);
607
608 open_tag.set_name("Array");
609 if (name.length()) open_tag.add_attribute("name", name);
610
611 open_tag.add_attribute("type", "ArrayOfArrayOfGridPos");
612 open_tag.add_attribute("nelem", aaagpos.nelem());
613
614 open_tag.write_to_stream(os_xml);
615 os_xml << '\n';
616
617 for (Index n = 0; n < aaagpos.nelem(); n++)
618 xml_write_to_stream(os_xml, aaagpos[n], pbofs, "", verbosity);
619
620 close_tag.set_name("/Array");
621 close_tag.write_to_stream(os_xml);
622
623 os_xml << '\n';
624}
625
626//=== ArrayOfArrayOfArrayOfArrayOfGridPos =====================================
627
629
634void xml_read_from_stream(istream& is_xml,
635 ArrayOfArrayOfArrayOfArrayOfGridPos& aaaagpos,
636 bifstream* pbifs,
637 const Verbosity& verbosity) {
638 ArtsXMLTag tag(verbosity);
639 Index nelem;
640
641 tag.read_from_stream(is_xml);
642 tag.check_name("Array");
643 tag.check_attribute("type", "ArrayOfArrayOfArrayOfGridPos");
644
645 tag.get_attribute_value("nelem", nelem);
646 aaaagpos.resize(nelem);
647
648 Index n;
649 try {
650 for (n = 0; n < nelem; n++)
651 xml_read_from_stream(is_xml, aaaagpos[n], pbifs, verbosity);
652 } catch (const std::runtime_error& e) {
653 ostringstream os;
654 os << "Error reading ArrayOfArrayOfArrayOfArrayOfGridPos: "
655 << "\n Element: " << n << "\n"
656 << e.what();
657 throw runtime_error(os.str());
658 }
659
660 tag.read_from_stream(is_xml);
661 tag.check_name("/Array");
662}
663
665
671void xml_write_to_stream(ostream& os_xml,
672 const ArrayOfArrayOfArrayOfArrayOfGridPos& aaaagpos,
673 bofstream* pbofs,
674 const String& name,
675 const Verbosity& verbosity) {
676 ArtsXMLTag open_tag(verbosity);
677 ArtsXMLTag close_tag(verbosity);
678
679 open_tag.set_name("Array");
680 if (name.length()) open_tag.add_attribute("name", name);
681
682 open_tag.add_attribute("type", "ArrayOfArrayOfArrayOfGridPos");
683 open_tag.add_attribute("nelem", aaaagpos.nelem());
684
685 open_tag.write_to_stream(os_xml);
686 os_xml << '\n';
687
688 for (Index n = 0; n < aaaagpos.nelem(); n++)
689 xml_write_to_stream(os_xml, aaaagpos[n], pbofs, "", verbosity);
690
691 close_tag.set_name("/Array");
692 close_tag.write_to_stream(os_xml);
693
694 os_xml << '\n';
695}
696
697//=== ArrayOfJacobianTarget ===========================================================
698
700
705void xml_read_from_stream(istream& is_xml,
706 ArrayOfJacobianTarget& ajt,
707 bifstream* pbifs,
708 const Verbosity& verbosity) {
709 ArtsXMLTag tag(verbosity);
710 Index nelem;
711
712 tag.read_from_stream(is_xml);
713 tag.check_name("Array");
714 tag.check_attribute("type", "JacobianTarget");
715
716 tag.get_attribute_value("nelem", nelem);
717 ajt.resize(nelem);
718
719 Index n;
720 try {
721 for (n = 0; n < nelem; n++)
722 xml_read_from_stream(is_xml, ajt[n], pbifs, verbosity);
723 } catch (const std::runtime_error& e) {
724 ostringstream os;
725 os << "Error reading ArrayOfIndex: "
726 << "\n Element: " << n << "\n"
727 << e.what();
728 throw runtime_error(os.str());
729 }
730
731 tag.read_from_stream(is_xml);
732 tag.check_name("/Array");
733}
734
736
742void xml_write_to_stream(ostream& os_xml,
743 const ArrayOfJacobianTarget& ajt,
744 bofstream* pbofs,
745 const String& name,
746 const Verbosity& verbosity) {
747 ArtsXMLTag open_tag(verbosity);
748 ArtsXMLTag close_tag(verbosity);
749
750 open_tag.set_name("Array");
751 if (name.length()) open_tag.add_attribute("name", name);
752
753 open_tag.add_attribute("type", "JacobianTarget");
754 open_tag.add_attribute("nelem", ajt.nelem());
755
756 open_tag.write_to_stream(os_xml);
757 os_xml << '\n';
758
759 for (Index n = 0; n < ajt.nelem(); n++)
760 xml_write_to_stream(os_xml, ajt[n], pbofs, "", verbosity);
761
762 close_tag.set_name("/Array");
763 close_tag.write_to_stream(os_xml);
764
765 os_xml << '\n';
766}
767
768//=== ArrayOfIndex ===========================================================
769
771
776void xml_read_from_stream(istream& is_xml,
777 ArrayOfIndex& aindex,
778 bifstream* pbifs,
779 const Verbosity& verbosity) {
780 ArtsXMLTag tag(verbosity);
781 Index nelem;
782
783 tag.read_from_stream(is_xml);
784 tag.check_name("Array");
785 tag.check_attribute("type", "Index");
786
787 tag.get_attribute_value("nelem", nelem);
788 aindex.resize(nelem);
789
790 Index n;
791 try {
792 for (n = 0; n < nelem; n++)
793 xml_read_from_stream(is_xml, aindex[n], pbifs, verbosity);
794 } catch (const std::runtime_error& e) {
795 ostringstream os;
796 os << "Error reading ArrayOfIndex: "
797 << "\n Element: " << n << "\n"
798 << e.what();
799 throw runtime_error(os.str());
800 }
801
802 tag.read_from_stream(is_xml);
803 tag.check_name("/Array");
804}
805
807
813void xml_write_to_stream(ostream& os_xml,
814 const ArrayOfIndex& aindex,
815 bofstream* pbofs,
816 const String& name,
817 const Verbosity& verbosity) {
818 ArtsXMLTag open_tag(verbosity);
819 ArtsXMLTag close_tag(verbosity);
820
821 open_tag.set_name("Array");
822 if (name.length()) open_tag.add_attribute("name", name);
823
824 open_tag.add_attribute("type", "Index");
825 open_tag.add_attribute("nelem", aindex.nelem());
826
827 open_tag.write_to_stream(os_xml);
828 os_xml << '\n';
829
830 for (Index n = 0; n < aindex.nelem(); n++)
831 xml_write_to_stream(os_xml, aindex[n], pbofs, "", verbosity);
832
833 close_tag.set_name("/Array");
834 close_tag.write_to_stream(os_xml);
835
836 os_xml << '\n';
837}
838
839//=== ArrayOfArrayOfIndex =====================================================
840
842
847void xml_read_from_stream(istream& is_xml,
848 ArrayOfArrayOfIndex& aaindex,
849 bifstream* pbifs,
850 const Verbosity& verbosity) {
851 ArtsXMLTag tag(verbosity);
852 Index nelem;
853
854 tag.read_from_stream(is_xml);
855 tag.check_name("Array");
856 tag.check_attribute("type", "ArrayOfIndex");
857
858 tag.get_attribute_value("nelem", nelem);
859 aaindex.resize(nelem);
860
861 Index n;
862 try {
863 for (n = 0; n < nelem; n++)
864 xml_read_from_stream(is_xml, aaindex[n], pbifs, verbosity);
865 } catch (const std::runtime_error& e) {
866 ostringstream os;
867 os << "Error reading ArrayOfArrayOfIndex: "
868 << "\n Element: " << n << "\n"
869 << e.what();
870 throw runtime_error(os.str());
871 }
872
873 tag.read_from_stream(is_xml);
874 tag.check_name("/Array");
875}
876
878
884void xml_write_to_stream(ostream& os_xml,
885 const ArrayOfArrayOfIndex& aaindex,
886 bofstream* pbofs,
887 const String& name,
888 const Verbosity& verbosity) {
889 ArtsXMLTag open_tag(verbosity);
890 ArtsXMLTag close_tag(verbosity);
891
892 open_tag.set_name("Array");
893 if (name.length()) open_tag.add_attribute("name", name);
894
895 open_tag.add_attribute("type", "ArrayOfIndex");
896 open_tag.add_attribute("nelem", aaindex.nelem());
897
898 open_tag.write_to_stream(os_xml);
899 os_xml << '\n';
900
901 for (Index n = 0; n < aaindex.nelem(); n++)
902 xml_write_to_stream(os_xml, aaindex[n], pbofs, "", verbosity);
903
904 close_tag.set_name("/Array");
905 close_tag.write_to_stream(os_xml);
906
907 os_xml << '\n';
908}
909
910//=== ArrayOfCIARecord ===========================================
911
913
918void xml_read_from_stream(istream& is_xml,
919 ArrayOfCIARecord& acr,
920 bifstream* pbifs,
921 const Verbosity& verbosity) {
922 ArtsXMLTag tag(verbosity);
923 Index nelem;
924
925 tag.read_from_stream(is_xml);
926 tag.check_name("Array");
927 tag.check_attribute("type", "CIARecord");
928
929 tag.get_attribute_value("nelem", nelem);
930 acr.resize(nelem);
931
932 Index n;
933 try {
934 for (n = 0; n < nelem; n++)
935 xml_read_from_stream(is_xml, acr[n], pbifs, verbosity);
936 } catch (const std::runtime_error& e) {
937 ostringstream os;
938 os << "Error reading ArrayOfCIARecord: "
939 << "\n Element: " << n << "\n"
940 << e.what();
941 throw runtime_error(os.str());
942 }
943
944 tag.read_from_stream(is_xml);
945 tag.check_name("/Array");
946}
947
949
955void xml_write_to_stream(ostream& os_xml,
956 const ArrayOfCIARecord& acr,
957 bofstream* pbofs,
958 const String& name,
959 const Verbosity& verbosity)
960
961{
962 ArtsXMLTag open_tag(verbosity);
963 ArtsXMLTag close_tag(verbosity);
964
965 open_tag.set_name("Array");
966 if (name.length()) open_tag.add_attribute("name", name);
967
968 open_tag.add_attribute("type", "CIARecord");
969 open_tag.add_attribute("nelem", acr.nelem());
970
971 open_tag.write_to_stream(os_xml);
972 os_xml << '\n';
973
974 for (Index n = 0; n < acr.nelem(); n++)
975 xml_write_to_stream(os_xml, acr[n], pbofs, "", verbosity);
976
977 close_tag.set_name("/Array");
978 close_tag.write_to_stream(os_xml);
979
980 os_xml << '\n';
981}
982
983//=== ArrayOfMatrix ==========================================================
984
986
991void xml_read_from_stream(istream& is_xml,
992 ArrayOfMatrix& amatrix,
993 bifstream* pbifs,
994 const Verbosity& verbosity) {
995 ArtsXMLTag tag(verbosity);
996 Index nelem;
997
998 tag.read_from_stream(is_xml);
999 tag.check_name("Array");
1000 tag.check_attribute("type", "Matrix");
1001
1002 tag.get_attribute_value("nelem", nelem);
1003 amatrix.resize(nelem);
1004
1005 Index n;
1006 try {
1007 for (n = 0; n < nelem; n++)
1008 xml_read_from_stream(is_xml, amatrix[n], pbifs, verbosity);
1009 } catch (const std::runtime_error& e) {
1010 ostringstream os;
1011 os << "Error reading ArrayOfMatrix: "
1012 << "\n Element: " << n << "\n"
1013 << e.what();
1014 throw runtime_error(os.str());
1015 }
1016
1017 tag.read_from_stream(is_xml);
1018 tag.check_name("/Array");
1019}
1020
1022
1028void xml_write_to_stream(ostream& os_xml,
1029 const ArrayOfMatrix& amatrix,
1030 bofstream* pbofs,
1031 const String& name,
1032 const Verbosity& verbosity) {
1033 ArtsXMLTag open_tag(verbosity);
1034 ArtsXMLTag close_tag(verbosity);
1035
1036 open_tag.set_name("Array");
1037 if (name.length()) open_tag.add_attribute("name", name);
1038
1039 open_tag.add_attribute("type", "Matrix");
1040 open_tag.add_attribute("nelem", amatrix.nelem());
1041
1042 open_tag.write_to_stream(os_xml);
1043 os_xml << '\n';
1044
1045 for (Index n = 0; n < amatrix.nelem(); n++)
1046 xml_write_to_stream(os_xml, amatrix[n], pbofs, "", verbosity);
1047
1048 close_tag.set_name("/Array");
1049 close_tag.write_to_stream(os_xml);
1050
1051 os_xml << '\n';
1052}
1053
1054//=== ArrayOfArrayOfMatrix====================================================
1055
1057
1062void xml_read_from_stream(istream& is_xml,
1063 ArrayOfArrayOfMatrix& aamatrix,
1064 bifstream* pbifs,
1065 const Verbosity& verbosity) {
1066 ArtsXMLTag tag(verbosity);
1067 Index nelem;
1068
1069 tag.read_from_stream(is_xml);
1070 tag.check_name("Array");
1071 tag.check_attribute("type", "ArrayOfMatrix");
1072
1073 tag.get_attribute_value("nelem", nelem);
1074 aamatrix.resize(nelem);
1075
1076 Index n;
1077 try {
1078 for (n = 0; n < nelem; n++)
1079 xml_read_from_stream(is_xml, aamatrix[n], pbifs, verbosity);
1080 } catch (const std::runtime_error& e) {
1081 ostringstream os;
1082 os << "Error reading ArrayOfArrayOfMatrix: "
1083 << "\n Element: " << n << "\n"
1084 << e.what();
1085 throw runtime_error(os.str());
1086 }
1087
1088 tag.read_from_stream(is_xml);
1089 tag.check_name("/Array");
1090}
1091
1093
1099void xml_write_to_stream(ostream& os_xml,
1100 const ArrayOfArrayOfMatrix& aamatrix,
1101 bofstream* pbofs,
1102 const String& name,
1103 const Verbosity& verbosity) {
1104 ArtsXMLTag open_tag(verbosity);
1105 ArtsXMLTag close_tag(verbosity);
1106
1107 open_tag.set_name("Array");
1108 if (name.length()) open_tag.add_attribute("name", name);
1109
1110 open_tag.add_attribute("type", "ArrayOfMatrix");
1111 open_tag.add_attribute("nelem", aamatrix.nelem());
1112
1113 open_tag.write_to_stream(os_xml);
1114 os_xml << '\n';
1115
1116 for (Index n = 0; n < aamatrix.nelem(); n++)
1117 xml_write_to_stream(os_xml, aamatrix[n], pbofs, "", verbosity);
1118
1119 close_tag.set_name("/Array");
1120 close_tag.write_to_stream(os_xml);
1121
1122 os_xml << '\n';
1123}
1124
1125//=== ArrayOfArrayOfVector====================================================
1126
1128
1133void xml_read_from_stream(istream& is_xml,
1134 ArrayOfArrayOfVector& aavector,
1135 bifstream* pbifs,
1136 const Verbosity& verbosity) {
1137 ArtsXMLTag tag(verbosity);
1138 Index nelem;
1139
1140 tag.read_from_stream(is_xml);
1141 tag.check_name("Array");
1142 tag.check_attribute("type", "ArrayOfVector");
1143
1144 tag.get_attribute_value("nelem", nelem);
1145 aavector.resize(nelem);
1146
1147 Index n;
1148 try {
1149 for (n = 0; n < nelem; n++)
1150 xml_read_from_stream(is_xml, aavector[n], pbifs, verbosity);
1151 } catch (const std::runtime_error& e) {
1152 ostringstream os;
1153 os << "Error reading ArrayOfArrayOfVector: "
1154 << "\n Element: " << n << "\n"
1155 << e.what();
1156 throw runtime_error(os.str());
1157 }
1158
1159 tag.read_from_stream(is_xml);
1160 tag.check_name("/Array");
1161}
1162
1164
1170void xml_write_to_stream(ostream& os_xml,
1171 const ArrayOfArrayOfVector& aaVector,
1172 bofstream* pbofs,
1173 const String& name,
1174 const Verbosity& verbosity) {
1175 ArtsXMLTag open_tag(verbosity);
1176 ArtsXMLTag close_tag(verbosity);
1177
1178 open_tag.set_name("Array");
1179 if (name.length()) open_tag.add_attribute("name", name);
1180
1181 open_tag.add_attribute("type", "ArrayOfVector");
1182 open_tag.add_attribute("nelem", aaVector.nelem());
1183
1184 open_tag.write_to_stream(os_xml);
1185 os_xml << '\n';
1186
1187 for (Index n = 0; n < aaVector.nelem(); n++)
1188 xml_write_to_stream(os_xml, aaVector[n], pbofs, "", verbosity);
1189
1190 close_tag.set_name("/Array");
1191 close_tag.write_to_stream(os_xml);
1192
1193 os_xml << '\n';
1194}
1195
1196//=== ArrayOfSparse ==========================================================
1197
1199
1204void xml_read_from_stream(istream& is_xml,
1205 ArrayOfSparse& asparse,
1206 bifstream* pbifs,
1207 const Verbosity& verbosity) {
1208 ArtsXMLTag tag(verbosity);
1209 Index nelem;
1210
1211 tag.read_from_stream(is_xml);
1212 tag.check_name("Array");
1213 tag.check_attribute("type", "Sparse");
1214
1215 tag.get_attribute_value("nelem", nelem);
1216 asparse.resize(nelem);
1217
1218 Index n;
1219 try {
1220 for (n = 0; n < nelem; n++)
1221 xml_read_from_stream(is_xml, asparse[n], pbifs, verbosity);
1222 } catch (const std::runtime_error& e) {
1223 ostringstream os;
1224 os << "Error reading ArrayOfSparse: "
1225 << "\n Element: " << n << "\n"
1226 << e.what();
1227 throw runtime_error(os.str());
1228 }
1229
1230 tag.read_from_stream(is_xml);
1231 tag.check_name("/Array");
1232}
1233
1235
1241void xml_write_to_stream(ostream& os_xml,
1242 const ArrayOfSparse& asparse,
1243 bofstream* pbofs,
1244 const String& name,
1245 const Verbosity& verbosity) {
1246 ArtsXMLTag open_tag(verbosity);
1247 ArtsXMLTag close_tag(verbosity);
1248
1249 open_tag.set_name("Array");
1250 if (name.length()) open_tag.add_attribute("name", name);
1251
1252 open_tag.add_attribute("type", "Sparse");
1253 open_tag.add_attribute("nelem", asparse.nelem());
1254
1255 open_tag.write_to_stream(os_xml);
1256 os_xml << '\n';
1257
1258 for (Index n = 0; n < asparse.nelem(); n++)
1259 xml_write_to_stream(os_xml, asparse[n], pbofs, "", verbosity);
1260
1261 close_tag.set_name("/Array");
1262 close_tag.write_to_stream(os_xml);
1263
1264 os_xml << '\n';
1265}
1266
1267//=== ArrayOfQuantumIdentifier ================================================
1268
1270
1275void xml_read_from_stream(istream& is_xml,
1276 ArrayOfQuantumIdentifier& aqtag,
1277 bifstream* pbifs,
1278 const Verbosity& verbosity) {
1279 ArtsXMLTag tag(verbosity);
1280 Index nelem;
1281
1282 tag.read_from_stream(is_xml);
1283 tag.check_name("Array");
1284 tag.check_attribute("type", "QuantumIdentifier");
1285
1286 tag.get_attribute_value("nelem", nelem);
1287 aqtag.resize(nelem);
1288
1289 Index n;
1290 try {
1291 for (n = 0; n < nelem; n++) {
1292 aqtag[n] = QuantumIdentifier();
1293 xml_read_from_stream(is_xml, aqtag[n], pbifs, verbosity);
1294 }
1295 } catch (const std::runtime_error& e) {
1296 ostringstream os;
1297 os << "Error reading ArrayOfQuantumIdentifier: "
1298 << "\n Element: " << n << "\n"
1299 << e.what();
1300 throw runtime_error(os.str());
1301 }
1302
1303 tag.read_from_stream(is_xml);
1304 tag.check_name("/Array");
1305}
1306
1308
1314void xml_write_to_stream(ostream& os_xml,
1315 const ArrayOfQuantumIdentifier& aqtag,
1316 bofstream* pbofs,
1317 const String& name,
1318 const Verbosity& verbosity) {
1319 ArtsXMLTag open_tag(verbosity);
1320 ArtsXMLTag close_tag(verbosity);
1321
1322 open_tag.set_name("Array");
1323 if (name.length()) open_tag.add_attribute("name", name);
1324
1325 open_tag.add_attribute("type", "QuantumIdentifier");
1326 open_tag.add_attribute("nelem", aqtag.nelem());
1327
1328 open_tag.write_to_stream(os_xml);
1329 os_xml << '\n';
1330
1331 for (Index n = 0; n < aqtag.nelem(); n++)
1332 xml_write_to_stream(os_xml, aqtag[n], pbofs, "", verbosity);
1333
1334 close_tag.set_name("/Array");
1335 close_tag.write_to_stream(os_xml);
1336
1337 os_xml << '\n';
1338}
1339
1340//=== ArrayOfRetrievalQuantity =======================================
1341
1343
1348void xml_read_from_stream(istream& is_xml,
1349 ArrayOfRetrievalQuantity& arq,
1350 bifstream* pbifs,
1351 const Verbosity& verbosity) {
1352 ArtsXMLTag tag(verbosity);
1353 Index nelem;
1354
1355 tag.read_from_stream(is_xml);
1356 tag.check_name("Array");
1357 tag.check_attribute("type", "RetrievalQuantity");
1358
1359 tag.get_attribute_value("nelem", nelem);
1360 arq.resize(nelem);
1361
1362 Index n;
1363 try {
1364 for (n = 0; n < nelem; n++)
1365 xml_read_from_stream(is_xml, arq[n], pbifs, verbosity);
1366 } catch (const std::runtime_error& e) {
1367 ostringstream os;
1368 os << "Error reading ArrayOfRetrievalQuantity: "
1369 << "\n Element: " << n << "\n"
1370 << e.what();
1371 throw runtime_error(os.str());
1372 }
1373
1374 tag.read_from_stream(is_xml);
1375 tag.check_name("/Array");
1376}
1377
1379
1385void xml_write_to_stream(ostream& os_xml,
1386 const ArrayOfRetrievalQuantity& arq,
1387 bofstream* pbofs,
1388 const String& name,
1389 const Verbosity& verbosity) {
1390 ArtsXMLTag open_tag(verbosity);
1391 ArtsXMLTag close_tag(verbosity);
1392
1393 open_tag.set_name("Array");
1394 if (name.length()) open_tag.add_attribute("name", name);
1395
1396 open_tag.add_attribute("type", "RetrievalQuantity");
1397 open_tag.add_attribute("nelem", arq.nelem());
1398
1399 open_tag.write_to_stream(os_xml);
1400 os_xml << '\n';
1401
1402 for (Index n = 0; n < arq.nelem(); n++)
1403 xml_write_to_stream(os_xml, arq[n], pbofs, "", verbosity);
1404
1405 close_tag.set_name("/Array");
1406 close_tag.write_to_stream(os_xml);
1407
1408 os_xml << '\n';
1409}
1410
1411//=== ArrayOfSpeciesTag ================================================
1412
1414
1419void xml_read_from_stream(istream& is_xml,
1420 ArrayOfSpeciesTag& astag,
1421 bifstream* pbifs,
1422 const Verbosity& verbosity) {
1423 ArtsXMLTag tag(verbosity);
1424 Index nelem;
1425
1426 tag.read_from_stream(is_xml);
1427 tag.check_name("Array");
1428 tag.check_attribute("type", "SpeciesTag");
1429
1430 tag.get_attribute_value("nelem", nelem);
1431 astag.resize(nelem);
1432
1433 Index n;
1434 try {
1435 for (n = 0; n < nelem; n++)
1436 xml_read_from_stream(is_xml, astag[n], pbifs, verbosity);
1437 } catch (const std::runtime_error& e) {
1438 ostringstream os;
1439 os << "Error reading ArrayOfSpeciesTag: "
1440 << "\n Element: " << n << "\n"
1441 << e.what();
1442 throw runtime_error(os.str());
1443 }
1444
1445 tag.read_from_stream(is_xml);
1446 tag.check_name("/Array");
1447}
1448
1450
1456void xml_write_to_stream(ostream& os_xml,
1457 const ArrayOfSpeciesTag& astag,
1458 bofstream* pbofs,
1459 const String& name,
1460 const Verbosity& verbosity) {
1461 ArtsXMLTag open_tag(verbosity);
1462 ArtsXMLTag close_tag(verbosity);
1463
1464 open_tag.set_name("Array");
1465 if (name.length()) open_tag.add_attribute("name", name);
1466
1467 open_tag.add_attribute("type", "SpeciesTag");
1468 open_tag.add_attribute("nelem", astag.nelem());
1469
1470 open_tag.write_to_stream(os_xml);
1471 os_xml << '\n';
1472
1473 for (Index n = 0; n < astag.nelem(); n++)
1474 xml_write_to_stream(os_xml, astag[n], pbofs, "", verbosity);
1475
1476 close_tag.set_name("/Array");
1477 close_tag.write_to_stream(os_xml);
1478
1479 os_xml << '\n';
1480}
1481
1482//=== ArrayOfSingleScatteringData===========================================
1483
1485
1490void xml_read_from_stream(istream& is_xml,
1491 ArrayOfSingleScatteringData& assdata,
1492 bifstream* pbifs,
1493 const Verbosity& verbosity) {
1494 ArtsXMLTag tag(verbosity);
1495 Index nelem;
1496
1497 tag.read_from_stream(is_xml);
1498 tag.check_name("Array");
1499 tag.check_attribute("type", "SingleScatteringData");
1500
1501 tag.get_attribute_value("nelem", nelem);
1502 assdata.resize(nelem);
1503
1504 Index n;
1505 try {
1506 for (n = 0; n < nelem; n++)
1507 xml_read_from_stream(is_xml, assdata[n], pbifs, verbosity);
1508 } catch (const std::runtime_error& e) {
1509 ostringstream os;
1510 os << "Error reading ArrayOfSingleScatteringData: "
1511 << "\n Element: " << n << "\n"
1512 << e.what();
1513 throw runtime_error(os.str());
1514 }
1515
1516 tag.read_from_stream(is_xml);
1517 tag.check_name("/Array");
1518}
1519
1521
1527void xml_write_to_stream(ostream& os_xml,
1528 const ArrayOfSingleScatteringData& assdata,
1529 bofstream* pbofs,
1530 const String& name,
1531 const Verbosity& verbosity) {
1532 ArtsXMLTag open_tag(verbosity);
1533 ArtsXMLTag close_tag(verbosity);
1534
1535 open_tag.set_name("Array");
1536 if (name.length()) open_tag.add_attribute("name", name);
1537
1538 open_tag.add_attribute("type", "SingleScatteringData");
1539 open_tag.add_attribute("nelem", assdata.nelem());
1540
1541 open_tag.write_to_stream(os_xml);
1542 os_xml << '\n';
1543
1544 for (Index n = 0; n < assdata.nelem(); n++)
1545 xml_write_to_stream(os_xml, assdata[n], pbofs, "", verbosity);
1546
1547 close_tag.set_name("/Array");
1548 close_tag.write_to_stream(os_xml);
1549
1550 os_xml << '\n';
1551}
1552
1553//=== ArrayOfArrayOfSingleScatteringData===========================================
1554
1556
1561void xml_read_from_stream(istream& is_xml,
1562 ArrayOfArrayOfSingleScatteringData& assdata,
1563 bifstream* pbifs,
1564 const Verbosity& verbosity) {
1565 ArtsXMLTag tag(verbosity);
1566 Index nelem;
1567
1568 tag.read_from_stream(is_xml);
1569 tag.check_name("Array");
1570 tag.check_attribute("type", "ArrayOfSingleScatteringData");
1571
1572 tag.get_attribute_value("nelem", nelem);
1573 assdata.resize(nelem);
1574
1575 Index n;
1576 try {
1577 for (n = 0; n < nelem; n++)
1578 xml_read_from_stream(is_xml, assdata[n], pbifs, verbosity);
1579 } catch (const std::runtime_error& e) {
1580 ostringstream os;
1581 os << "Error reading ArrayOfArrayOfSingleScatteringData: "
1582 << "\n Element: " << n << "\n"
1583 << e.what();
1584 throw runtime_error(os.str());
1585 }
1586
1587 tag.read_from_stream(is_xml);
1588 tag.check_name("/Array");
1589}
1590
1592
1598void xml_write_to_stream(ostream& os_xml,
1599 const ArrayOfArrayOfSingleScatteringData& assdata,
1600 bofstream* pbofs,
1601 const String& name,
1602 const Verbosity& verbosity) {
1603 ArtsXMLTag open_tag(verbosity);
1604 ArtsXMLTag close_tag(verbosity);
1605
1606 open_tag.set_name("Array");
1607 if (name.length()) open_tag.add_attribute("name", name);
1608
1609 open_tag.add_attribute("type", "ArrayOfSingleScatteringData");
1610 open_tag.add_attribute("nelem", assdata.nelem());
1611
1612 open_tag.write_to_stream(os_xml);
1613 os_xml << '\n';
1614
1615 for (Index n = 0; n < assdata.nelem(); n++)
1616 xml_write_to_stream(os_xml, assdata[n], pbofs, "", verbosity);
1617
1618 close_tag.set_name("/Array");
1619 close_tag.write_to_stream(os_xml);
1620
1621 os_xml << '\n';
1622}
1623
1624//=== ArrayOfScatteringMetaData===========================================
1625
1627
1632void xml_read_from_stream(istream& is_xml,
1633 ArrayOfScatteringMetaData& asmdata,
1634 bifstream* pbifs,
1635 const Verbosity& verbosity) {
1636 ArtsXMLTag tag(verbosity);
1637 Index nelem;
1638
1639 tag.read_from_stream(is_xml);
1640 tag.check_name("Array");
1641 tag.check_attribute("type", "ScatteringMetaData");
1642
1643 tag.get_attribute_value("nelem", nelem);
1644 asmdata.resize(nelem);
1645
1646 Index n;
1647 try {
1648 for (n = 0; n < nelem; n++)
1649 xml_read_from_stream(is_xml, asmdata[n], pbifs, verbosity);
1650 } catch (const std::runtime_error& e) {
1651 ostringstream os;
1652 os << "Error reading ArrayOfScatteringMetaData: "
1653 << "\n Element: " << n << "\n"
1654 << e.what();
1655 throw runtime_error(os.str());
1656 }
1657
1658 tag.read_from_stream(is_xml);
1659 tag.check_name("/Array");
1660}
1661
1663
1669void xml_write_to_stream(ostream& os_xml,
1670 const ArrayOfScatteringMetaData& asmdata,
1671 bofstream* pbofs,
1672 const String& name,
1673 const Verbosity& verbosity) {
1674 ArtsXMLTag open_tag(verbosity);
1675 ArtsXMLTag close_tag(verbosity);
1676
1677 open_tag.set_name("Array");
1678 if (name.length()) open_tag.add_attribute("name", name);
1679
1680 open_tag.add_attribute("type", "ScatteringMetaData");
1681 open_tag.add_attribute("nelem", asmdata.nelem());
1682
1683 open_tag.write_to_stream(os_xml);
1684 os_xml << '\n';
1685
1686 for (Index n = 0; n < asmdata.nelem(); n++)
1687 xml_write_to_stream(os_xml, asmdata[n], pbofs, "", verbosity);
1688
1689 close_tag.set_name("/Array");
1690 close_tag.write_to_stream(os_xml);
1691
1692 os_xml << '\n';
1693}
1694
1695//=== ArrayOfArrayOfScatteringMetaData===========================================
1696
1698
1703void xml_read_from_stream(istream& is_xml,
1704 ArrayOfArrayOfScatteringMetaData& asmdata,
1705 bifstream* pbifs,
1706 const Verbosity& verbosity) {
1707 ArtsXMLTag tag(verbosity);
1708 Index nelem;
1709
1710 tag.read_from_stream(is_xml);
1711 tag.check_name("Array");
1712 tag.check_attribute("type", "ArrayOfScatteringMetaData");
1713
1714 tag.get_attribute_value("nelem", nelem);
1715 asmdata.resize(nelem);
1716
1717 Index n;
1718 try {
1719 for (n = 0; n < nelem; n++)
1720 xml_read_from_stream(is_xml, asmdata[n], pbifs, verbosity);
1721 } catch (const std::runtime_error& e) {
1722 ostringstream os;
1723 os << "Error reading ArrayOfArrayOfScatteringMetaData: "
1724 << "\n Element: " << n << "\n"
1725 << e.what();
1726 throw runtime_error(os.str());
1727 }
1728
1729 tag.read_from_stream(is_xml);
1730 tag.check_name("/Array");
1731}
1732
1734
1740void xml_write_to_stream(ostream& os_xml,
1741 const ArrayOfArrayOfScatteringMetaData& asmdata,
1742 bofstream* pbofs,
1743 const String& name,
1744 const Verbosity& verbosity) {
1745 ArtsXMLTag open_tag(verbosity);
1746 ArtsXMLTag close_tag(verbosity);
1747
1748 open_tag.set_name("Array");
1749 if (name.length()) open_tag.add_attribute("name", name);
1750
1751 open_tag.add_attribute("type", "ArrayOfScatteringMetaData");
1752 open_tag.add_attribute("nelem", asmdata.nelem());
1753
1754 open_tag.write_to_stream(os_xml);
1755 os_xml << '\n';
1756
1757 for (Index n = 0; n < asmdata.nelem(); n++)
1758 xml_write_to_stream(os_xml, asmdata[n], pbofs, "", verbosity);
1759
1760 close_tag.set_name("/Array");
1761 close_tag.write_to_stream(os_xml);
1762
1763 os_xml << '\n';
1764}
1765
1766//=== ArrayOfGriddedField1 ===========================================
1767
1769
1774void xml_read_from_stream(istream& is_xml,
1775 ArrayOfGriddedField1& agfield,
1776 bifstream* pbifs,
1777 const Verbosity& verbosity) {
1778 ArtsXMLTag tag(verbosity);
1779 Index nelem;
1780
1781 tag.read_from_stream(is_xml);
1782 tag.check_name("Array");
1783 tag.check_attribute("type", "GriddedField1");
1784
1785 tag.get_attribute_value("nelem", nelem);
1786 agfield.resize(nelem);
1787
1788 Index n;
1789 try {
1790 for (n = 0; n < nelem; n++)
1791 xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
1792 } catch (const std::runtime_error& e) {
1793 ostringstream os;
1794 os << "Error reading ArrayOfGriddedField1: "
1795 << "\n Element: " << n << "\n"
1796 << e.what();
1797 throw runtime_error(os.str());
1798 }
1799
1800 tag.read_from_stream(is_xml);
1801 tag.check_name("/Array");
1802}
1803
1805
1811void xml_write_to_stream(ostream& os_xml,
1812 const ArrayOfGriddedField1& agfield,
1813 bofstream* pbofs,
1814 const String& name,
1815 const Verbosity& verbosity) {
1816 ArtsXMLTag open_tag(verbosity);
1817 ArtsXMLTag close_tag(verbosity);
1818
1819 open_tag.set_name("Array");
1820 if (name.length()) open_tag.add_attribute("name", name);
1821
1822 open_tag.add_attribute("type", "GriddedField1");
1823 open_tag.add_attribute("nelem", agfield.nelem());
1824
1825 open_tag.write_to_stream(os_xml);
1826 os_xml << '\n';
1827
1828 for (Index n = 0; n < agfield.nelem(); n++)
1829 xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
1830
1831 close_tag.set_name("/Array");
1832 close_tag.write_to_stream(os_xml);
1833
1834 os_xml << '\n';
1835}
1836
1837//=== ArrayOfGriddedField2 ===========================================
1838
1840
1845void xml_read_from_stream(istream& is_xml,
1846 ArrayOfGriddedField2& agfield,
1847 bifstream* pbifs,
1848 const Verbosity& verbosity) {
1849 ArtsXMLTag tag(verbosity);
1850 Index nelem;
1851
1852 tag.read_from_stream(is_xml);
1853 tag.check_name("Array");
1854 tag.check_attribute("type", "GriddedField2");
1855
1856 tag.get_attribute_value("nelem", nelem);
1857 agfield.resize(nelem);
1858
1859 Index n;
1860 try {
1861 for (n = 0; n < nelem; n++)
1862 xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
1863 } catch (const std::runtime_error& e) {
1864 ostringstream os;
1865 os << "Error reading ArrayOfGriddedField2: "
1866 << "\n Element: " << n << "\n"
1867 << e.what();
1868 throw runtime_error(os.str());
1869 }
1870
1871 tag.read_from_stream(is_xml);
1872 tag.check_name("/Array");
1873}
1874
1876
1882void xml_write_to_stream(ostream& os_xml,
1883 const ArrayOfGriddedField2& agfield,
1884 bofstream* pbofs,
1885 const String& name,
1886 const Verbosity& verbosity) {
1887 ArtsXMLTag open_tag(verbosity);
1888 ArtsXMLTag close_tag(verbosity);
1889
1890 open_tag.set_name("Array");
1891 if (name.length()) open_tag.add_attribute("name", name);
1892
1893 open_tag.add_attribute("type", "GriddedField2");
1894 open_tag.add_attribute("nelem", agfield.nelem());
1895
1896 open_tag.write_to_stream(os_xml);
1897 os_xml << '\n';
1898
1899 for (Index n = 0; n < agfield.nelem(); n++)
1900 xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
1901
1902 close_tag.set_name("/Array");
1903 close_tag.write_to_stream(os_xml);
1904
1905 os_xml << '\n';
1906}
1907
1908//=== ArrayOfGriddedField3 ===========================================
1909
1911
1916void xml_read_from_stream(istream& is_xml,
1917 ArrayOfGriddedField3& agfield,
1918 bifstream* pbifs,
1919 const Verbosity& verbosity) {
1920 ArtsXMLTag tag(verbosity);
1921 Index nelem;
1922
1923 tag.read_from_stream(is_xml);
1924 tag.check_name("Array");
1925 tag.check_attribute("type", "GriddedField3");
1926
1927 tag.get_attribute_value("nelem", nelem);
1928 agfield.resize(nelem);
1929
1930 Index n;
1931 try {
1932 for (n = 0; n < nelem; n++)
1933 xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
1934 } catch (const std::runtime_error& e) {
1935 ostringstream os;
1936 os << "Error reading ArrayOfGriddedField3: "
1937 << "\n Element: " << n << "\n"
1938 << e.what();
1939 throw runtime_error(os.str());
1940 }
1941
1942 tag.read_from_stream(is_xml);
1943 tag.check_name("/Array");
1944}
1945
1947
1953void xml_write_to_stream(ostream& os_xml,
1954 const ArrayOfGriddedField3& agfield,
1955 bofstream* pbofs,
1956 const String& name,
1957 const Verbosity& verbosity) {
1958 ArtsXMLTag open_tag(verbosity);
1959 ArtsXMLTag close_tag(verbosity);
1960
1961 open_tag.set_name("Array");
1962 if (name.length()) open_tag.add_attribute("name", name);
1963
1964 open_tag.add_attribute("type", "GriddedField3");
1965 open_tag.add_attribute("nelem", agfield.nelem());
1966
1967 open_tag.write_to_stream(os_xml);
1968 os_xml << '\n';
1969
1970 for (Index n = 0; n < agfield.nelem(); n++)
1971 xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
1972
1973 close_tag.set_name("/Array");
1974 close_tag.write_to_stream(os_xml);
1975
1976 os_xml << '\n';
1977}
1978
1979//=== ArrayOfArrayOfGriddedField1 ===========================================
1980
1982
1987void xml_read_from_stream(istream& is_xml,
1988 ArrayOfArrayOfGriddedField1& aagfield,
1989 bifstream* pbifs,
1990 const Verbosity& verbosity) {
1991 ArtsXMLTag tag(verbosity);
1992 Index nelem;
1993
1994 tag.read_from_stream(is_xml);
1995 tag.check_name("Array");
1996 tag.check_attribute("type", "ArrayOfGriddedField1");
1997
1998 tag.get_attribute_value("nelem", nelem);
1999 aagfield.resize(nelem);
2000
2001 Index n;
2002 try {
2003 for (n = 0; n < nelem; n++)
2004 xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2005 } catch (const std::runtime_error& e) {
2006 ostringstream os;
2007 os << "Error reading ArrayOfArrayOfGriddedField1: "
2008 << "\n Element: " << n << "\n"
2009 << e.what();
2010 throw runtime_error(os.str());
2011 }
2012
2013 tag.read_from_stream(is_xml);
2014 tag.check_name("/Array");
2015}
2016
2018
2024void xml_write_to_stream(ostream& os_xml,
2025 const ArrayOfArrayOfGriddedField1& aagfield,
2026 bofstream* pbofs,
2027 const String& name,
2028 const Verbosity& verbosity) {
2029 ArtsXMLTag open_tag(verbosity);
2030 ArtsXMLTag close_tag(verbosity);
2031
2032 open_tag.set_name("Array");
2033 if (name.length()) open_tag.add_attribute("name", name);
2034
2035 open_tag.add_attribute("type", "ArrayOfGriddedField1");
2036 open_tag.add_attribute("nelem", aagfield.nelem());
2037
2038 open_tag.write_to_stream(os_xml);
2039 os_xml << '\n';
2040
2041 for (Index n = 0; n < aagfield.nelem(); n++)
2042 xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2043
2044 close_tag.set_name("/Array");
2045 close_tag.write_to_stream(os_xml);
2046
2047 os_xml << '\n';
2048}
2049
2050//=== ArrayOfArrayOfGriddedField2 ===========================================
2051
2053
2058void xml_read_from_stream(istream& is_xml,
2059 ArrayOfArrayOfGriddedField2& aagfield,
2060 bifstream* pbifs,
2061 const Verbosity& verbosity) {
2062 ArtsXMLTag tag(verbosity);
2063 Index nelem;
2064
2065 tag.read_from_stream(is_xml);
2066 tag.check_name("Array");
2067 tag.check_attribute("type", "ArrayOfGriddedField2");
2068
2069 tag.get_attribute_value("nelem", nelem);
2070 aagfield.resize(nelem);
2071
2072 Index n;
2073 try {
2074 for (n = 0; n < nelem; n++)
2075 xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2076 } catch (const std::runtime_error& e) {
2077 ostringstream os;
2078 os << "Error reading ArrayOfArrayOfGriddedField2: "
2079 << "\n Element: " << n << "\n"
2080 << e.what();
2081 throw runtime_error(os.str());
2082 }
2083
2084 tag.read_from_stream(is_xml);
2085 tag.check_name("/Array");
2086}
2087
2089
2095void xml_write_to_stream(ostream& os_xml,
2096 const ArrayOfArrayOfGriddedField2& aagfield,
2097 bofstream* pbofs,
2098 const String& name,
2099 const Verbosity& verbosity) {
2100 ArtsXMLTag open_tag(verbosity);
2101 ArtsXMLTag close_tag(verbosity);
2102
2103 open_tag.set_name("Array");
2104 if (name.length()) open_tag.add_attribute("name", name);
2105
2106 open_tag.add_attribute("type", "ArrayOfGriddedField2");
2107 open_tag.add_attribute("nelem", aagfield.nelem());
2108
2109 open_tag.write_to_stream(os_xml);
2110 os_xml << '\n';
2111
2112 for (Index n = 0; n < aagfield.nelem(); n++)
2113 xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2114
2115 close_tag.set_name("/Array");
2116 close_tag.write_to_stream(os_xml);
2117
2118 os_xml << '\n';
2119}
2120
2121//=== ArrayOfArrayOfGriddedField3 ===========================================
2122
2124
2129void xml_read_from_stream(istream& is_xml,
2130 ArrayOfArrayOfGriddedField3& aagfield,
2131 bifstream* pbifs,
2132 const Verbosity& verbosity) {
2133 ArtsXMLTag tag(verbosity);
2134 Index nelem;
2135
2136 tag.read_from_stream(is_xml);
2137 tag.check_name("Array");
2138 tag.check_attribute("type", "ArrayOfGriddedField3");
2139
2140 tag.get_attribute_value("nelem", nelem);
2141 aagfield.resize(nelem);
2142
2143 Index n;
2144 try {
2145 for (n = 0; n < nelem; n++)
2146 xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2147 } catch (const std::runtime_error& e) {
2148 ostringstream os;
2149 os << "Error reading ArrayOfArrayOfGriddedField3: "
2150 << "\n Element: " << n << "\n"
2151 << e.what();
2152 throw runtime_error(os.str());
2153 }
2154
2155 tag.read_from_stream(is_xml);
2156 tag.check_name("/Array");
2157}
2158
2160
2166void xml_write_to_stream(ostream& os_xml,
2167 const ArrayOfArrayOfGriddedField3& aagfield,
2168 bofstream* pbofs,
2169 const String& name,
2170 const Verbosity& verbosity) {
2171 ArtsXMLTag open_tag(verbosity);
2172 ArtsXMLTag close_tag(verbosity);
2173
2174 open_tag.set_name("Array");
2175 if (name.length()) open_tag.add_attribute("name", name);
2176
2177 open_tag.add_attribute("type", "ArrayOfGriddedField3");
2178 open_tag.add_attribute("nelem", aagfield.nelem());
2179
2180 open_tag.write_to_stream(os_xml);
2181 os_xml << '\n';
2182
2183 for (Index n = 0; n < aagfield.nelem(); n++)
2184 xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2185
2186 close_tag.set_name("/Array");
2187 close_tag.write_to_stream(os_xml);
2188
2189 os_xml << '\n';
2190}
2191
2192//=== ArrayOfGriddedField4 ===========================================
2193
2195
2200void xml_read_from_stream(istream& is_xml,
2201 ArrayOfGriddedField4& agfield,
2202 bifstream* pbifs,
2203 const Verbosity& verbosity) {
2204 ArtsXMLTag tag(verbosity);
2205 Index nelem;
2206
2207 tag.read_from_stream(is_xml);
2208 tag.check_name("Array");
2209 tag.check_attribute("type", "GriddedField4");
2210
2211 tag.get_attribute_value("nelem", nelem);
2212 agfield.resize(nelem);
2213
2214 Index n;
2215 try {
2216 for (n = 0; n < nelem; n++)
2217 xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
2218 } catch (const std::runtime_error& e) {
2219 ostringstream os;
2220 os << "Error reading ArrayOfGriddedField4: "
2221 << "\n Element: " << n << "\n"
2222 << e.what();
2223 throw runtime_error(os.str());
2224 }
2225
2226 tag.read_from_stream(is_xml);
2227 tag.check_name("/Array");
2228}
2229
2231
2237void xml_write_to_stream(ostream& os_xml,
2238 const ArrayOfGriddedField4& agfield,
2239 bofstream* pbofs,
2240 const String& name,
2241 const Verbosity& verbosity) {
2242 ArtsXMLTag open_tag(verbosity);
2243 ArtsXMLTag close_tag(verbosity);
2244
2245 open_tag.set_name("Array");
2246 if (name.length()) open_tag.add_attribute("name", name);
2247
2248 open_tag.add_attribute("type", "GriddedField4");
2249 open_tag.add_attribute("nelem", agfield.nelem());
2250
2251 open_tag.write_to_stream(os_xml);
2252 os_xml << '\n';
2253
2254 for (Index n = 0; n < agfield.nelem(); n++)
2255 xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
2256
2257 close_tag.set_name("/Array");
2258 close_tag.write_to_stream(os_xml);
2259
2260 os_xml << '\n';
2261}
2262
2263//=== ArrayOfTelsemAtlas =========================================================
2264
2266
2271void xml_read_from_stream(istream& is_xml,
2272 ArrayOfTelsemAtlas& arr_telsem,
2273 bifstream* pbifs,
2274 const Verbosity& verbosity) {
2275 ArtsXMLTag tag(verbosity);
2276 Index nelem;
2277
2278 tag.read_from_stream(is_xml);
2279 tag.check_name("Array");
2280 tag.check_attribute("type", "TelsemAtlas");
2281
2282 tag.get_attribute_value("nelem", nelem);
2283 arr_telsem.resize(nelem);
2284
2285 Index n;
2286 try {
2287 for (n = 0; n < nelem; n++)
2288 xml_read_from_stream(is_xml, arr_telsem[n], pbifs, verbosity);
2289 } catch (const std::runtime_error& e) {
2290 ostringstream os;
2291 os << "Error reading ArrayOfTelsemAtlas: "
2292 << "\n Element: " << n << "\n"
2293 << e.what();
2294 throw runtime_error(os.str());
2295 }
2296
2297 tag.read_from_stream(is_xml);
2298 tag.check_name("/Array");
2299}
2300
2302
2308void xml_write_to_stream(ostream& os_xml,
2309 const ArrayOfTelsemAtlas& arr_telsem,
2310 bofstream* pbofs,
2311 const String& name,
2312 const Verbosity& verbosity) {
2313 ArtsXMLTag open_tag(verbosity);
2314 ArtsXMLTag close_tag(verbosity);
2315
2316 open_tag.set_name("Array");
2317 if (name.length()) open_tag.add_attribute("name", name);
2318
2319 open_tag.add_attribute("type", "TelsemAtlas");
2320 open_tag.add_attribute("nelem", arr_telsem.nelem());
2321
2322 open_tag.write_to_stream(os_xml);
2323 os_xml << '\n';
2324
2325 for (Index n = 0; n < arr_telsem.nelem(); n++)
2326 xml_write_to_stream(os_xml, arr_telsem[n], pbofs, "", verbosity);
2327
2328 close_tag.set_name("/Array");
2329 close_tag.write_to_stream(os_xml);
2330
2331 os_xml << '\n';
2332}
2333
2334//=== ArrayOfTensor3=========================================================
2335
2337
2342void xml_read_from_stream(istream& is_xml,
2343 ArrayOfTensor3& atensor3,
2344 bifstream* pbifs,
2345 const Verbosity& verbosity) {
2346 ArtsXMLTag tag(verbosity);
2347 Index nelem;
2348
2349 tag.read_from_stream(is_xml);
2350 tag.check_name("Array");
2351 tag.check_attribute("type", "Tensor3");
2352
2353 tag.get_attribute_value("nelem", nelem);
2354 atensor3.resize(nelem);
2355
2356 Index n;
2357 try {
2358 for (n = 0; n < nelem; n++)
2359 xml_read_from_stream(is_xml, atensor3[n], pbifs, verbosity);
2360 } catch (const std::runtime_error& e) {
2361 ostringstream os;
2362 os << "Error reading ArrayOfTensor3: "
2363 << "\n Element: " << n << "\n"
2364 << e.what();
2365 throw runtime_error(os.str());
2366 }
2367
2368 tag.read_from_stream(is_xml);
2369 tag.check_name("/Array");
2370}
2371
2373
2379void xml_write_to_stream(ostream& os_xml,
2380 const ArrayOfTensor3& atensor3,
2381 bofstream* pbofs,
2382 const String& name,
2383 const Verbosity& verbosity) {
2384 ArtsXMLTag open_tag(verbosity);
2385 ArtsXMLTag close_tag(verbosity);
2386
2387 open_tag.set_name("Array");
2388 if (name.length()) open_tag.add_attribute("name", name);
2389
2390 open_tag.add_attribute("type", "Tensor3");
2391 open_tag.add_attribute("nelem", atensor3.nelem());
2392
2393 open_tag.write_to_stream(os_xml);
2394 os_xml << '\n';
2395
2396 for (Index n = 0; n < atensor3.nelem(); n++)
2397 xml_write_to_stream(os_xml, atensor3[n], pbofs, "", verbosity);
2398
2399 close_tag.set_name("/Array");
2400 close_tag.write_to_stream(os_xml);
2401
2402 os_xml << '\n';
2403}
2404
2405//=== ArrayOfTensor4=========================================================
2406
2408
2413void xml_read_from_stream(istream& is_xml,
2414 ArrayOfTensor4& atensor4,
2415 bifstream* pbifs,
2416 const Verbosity& verbosity) {
2417 ArtsXMLTag tag(verbosity);
2418 Index nelem;
2419
2420 tag.read_from_stream(is_xml);
2421 tag.check_name("Array");
2422 tag.check_attribute("type", "Tensor4");
2423
2424 tag.get_attribute_value("nelem", nelem);
2425 atensor4.resize(nelem);
2426
2427 Index n;
2428 try {
2429 for (n = 0; n < nelem; n++)
2430 xml_read_from_stream(is_xml, atensor4[n], pbifs, verbosity);
2431 } catch (const std::runtime_error& e) {
2432 ostringstream os;
2433 os << "Error reading ArrayOfTensor4: "
2434 << "\n Element: " << n << "\n"
2435 << e.what();
2436 throw runtime_error(os.str());
2437 }
2438
2439 tag.read_from_stream(is_xml);
2440 tag.check_name("/Array");
2441}
2442
2444
2450void xml_write_to_stream(ostream& os_xml,
2451 const ArrayOfTensor4& atensor4,
2452 bofstream* pbofs,
2453 const String& name,
2454 const Verbosity& verbosity) {
2455 ArtsXMLTag open_tag(verbosity);
2456 ArtsXMLTag close_tag(verbosity);
2457
2458 open_tag.set_name("Array");
2459 if (name.length()) open_tag.add_attribute("name", name);
2460
2461 open_tag.add_attribute("type", "Tensor4");
2462 open_tag.add_attribute("nelem", atensor4.nelem());
2463
2464 open_tag.write_to_stream(os_xml);
2465 os_xml << '\n';
2466
2467 for (Index n = 0; n < atensor4.nelem(); n++)
2468 xml_write_to_stream(os_xml, atensor4[n], pbofs, "", verbosity);
2469
2470 close_tag.set_name("/Array");
2471 close_tag.write_to_stream(os_xml);
2472
2473 os_xml << '\n';
2474}
2475
2476//=== ArrayOfTensor5=========================================================
2477
2479
2484void xml_read_from_stream(istream& is_xml,
2485 ArrayOfTensor5& atensor5,
2486 bifstream* pbifs,
2487 const Verbosity& verbosity) {
2488 ArtsXMLTag tag(verbosity);
2489 Index nelem;
2490
2491 tag.read_from_stream(is_xml);
2492 tag.check_name("Array");
2493 tag.check_attribute("type", "Tensor5");
2494
2495 tag.get_attribute_value("nelem", nelem);
2496 atensor5.resize(nelem);
2497
2498 Index n;
2499 try {
2500 for (n = 0; n < nelem; n++)
2501 xml_read_from_stream(is_xml, atensor5[n], pbifs, verbosity);
2502 } catch (const std::runtime_error& e) {
2503 ostringstream os;
2504 os << "Error reading ArrayOfTensor5: "
2505 << "\n Element: " << n << "\n"
2506 << e.what();
2507 throw runtime_error(os.str());
2508 }
2509
2510 tag.read_from_stream(is_xml);
2511 tag.check_name("/Array");
2512}
2513
2515
2521void xml_write_to_stream(ostream& os_xml,
2522 const ArrayOfTensor5& atensor5,
2523 bofstream* pbofs,
2524 const String& name,
2525 const Verbosity& verbosity) {
2526 ArtsXMLTag open_tag(verbosity);
2527 ArtsXMLTag close_tag(verbosity);
2528
2529 open_tag.set_name("Array");
2530 if (name.length()) open_tag.add_attribute("name", name);
2531
2532 open_tag.add_attribute("type", "Tensor5");
2533 open_tag.add_attribute("nelem", atensor5.nelem());
2534
2535 open_tag.write_to_stream(os_xml);
2536 os_xml << '\n';
2537
2538 for (Index n = 0; n < atensor5.nelem(); n++)
2539 xml_write_to_stream(os_xml, atensor5[n], pbofs, "", verbosity);
2540
2541 close_tag.set_name("/Array");
2542 close_tag.write_to_stream(os_xml);
2543
2544 os_xml << '\n';
2545}
2546
2547//=== ArrayOfTensor6=========================================================
2548
2550
2555void xml_read_from_stream(istream& is_xml,
2556 ArrayOfTensor6& atensor6,
2557 bifstream* pbifs,
2558 const Verbosity& verbosity) {
2559 ArtsXMLTag tag(verbosity);
2560 Index nelem;
2561
2562 tag.read_from_stream(is_xml);
2563 tag.check_name("Array");
2564 tag.check_attribute("type", "Tensor6");
2565
2566 tag.get_attribute_value("nelem", nelem);
2567 atensor6.resize(nelem);
2568
2569 Index n;
2570 try {
2571 for (n = 0; n < nelem; n++)
2572 xml_read_from_stream(is_xml, atensor6[n], pbifs, verbosity);
2573 } catch (const std::runtime_error& e) {
2574 ostringstream os;
2575 os << "Error reading ArrayOfTensor6: "
2576 << "\n Element: " << n << "\n"
2577 << e.what();
2578 throw runtime_error(os.str());
2579 }
2580
2581 tag.read_from_stream(is_xml);
2582 tag.check_name("/Array");
2583}
2584
2586
2592void xml_write_to_stream(ostream& os_xml,
2593 const ArrayOfTensor6& atensor6,
2594 bofstream* pbofs,
2595 const String& name,
2596 const Verbosity& verbosity) {
2597 ArtsXMLTag open_tag(verbosity);
2598 ArtsXMLTag close_tag(verbosity);
2599
2600 open_tag.set_name("Array");
2601 if (name.length()) open_tag.add_attribute("name", name);
2602
2603 open_tag.add_attribute("type", "Tensor6");
2604 open_tag.add_attribute("nelem", atensor6.nelem());
2605
2606 open_tag.write_to_stream(os_xml);
2607 os_xml << '\n';
2608
2609 for (Index n = 0; n < atensor6.nelem(); n++)
2610 xml_write_to_stream(os_xml, atensor6[n], pbofs, "", verbosity);
2611
2612 close_tag.set_name("/Array");
2613 close_tag.write_to_stream(os_xml);
2614
2615 os_xml << '\n';
2616}
2617
2618//=== ArrayOfTensor7=========================================================
2619
2621
2626void xml_read_from_stream(istream& is_xml,
2627 ArrayOfTensor7& atensor7,
2628 bifstream* pbifs,
2629 const Verbosity& verbosity) {
2630 ArtsXMLTag tag(verbosity);
2631 Index nelem;
2632
2633 tag.read_from_stream(is_xml);
2634 tag.check_name("Array");
2635 tag.check_attribute("type", "Tensor7");
2636
2637 tag.get_attribute_value("nelem", nelem);
2638 atensor7.resize(nelem);
2639
2640 Index n;
2641 try {
2642 for (n = 0; n < nelem; n++)
2643 xml_read_from_stream(is_xml, atensor7[n], pbifs, verbosity);
2644 } catch (const std::runtime_error& e) {
2645 ostringstream os;
2646 os << "Error reading ArrayOfTensor7: "
2647 << "\n Element: " << n << "\n"
2648 << e.what();
2649 throw runtime_error(os.str());
2650 }
2651
2652 tag.read_from_stream(is_xml);
2653 tag.check_name("/Array");
2654}
2655
2657
2663void xml_write_to_stream(ostream& os_xml,
2664 const ArrayOfTensor7& atensor7,
2665 bofstream* pbofs,
2666 const String& name,
2667 const Verbosity& verbosity) {
2668 ArtsXMLTag open_tag(verbosity);
2669 ArtsXMLTag close_tag(verbosity);
2670
2671 open_tag.set_name("Array");
2672 if (name.length()) open_tag.add_attribute("name", name);
2673
2674 open_tag.add_attribute("type", "Tensor7");
2675 open_tag.add_attribute("nelem", atensor7.nelem());
2676
2677 open_tag.write_to_stream(os_xml);
2678 os_xml << '\n';
2679
2680 for (Index n = 0; n < atensor7.nelem(); n++)
2681 xml_write_to_stream(os_xml, atensor7[n], pbofs, "", verbosity);
2682
2683 close_tag.set_name("/Array");
2684 close_tag.write_to_stream(os_xml);
2685
2686 os_xml << '\n';
2687}
2688
2689//=== ArrayOfSun =========================================================
2690
2692
2697void xml_read_from_stream(istream& is_xml,
2698 ArrayOfSun& astar,
2699 bifstream* pbifs,
2700 const Verbosity& verbosity) {
2701 ArtsXMLTag tag(verbosity);
2702 Index nelem;
2703
2704 tag.read_from_stream(is_xml);
2705 tag.check_name("Array");
2706 tag.check_attribute("type", "Sun");
2707
2708 tag.get_attribute_value("nelem", nelem);
2709 astar.resize(nelem);
2710
2711 Index n;
2712 try {
2713 for (n = 0; n < nelem; n++) {
2714 xml_read_from_stream(is_xml, astar[n], pbifs, verbosity);
2715 }
2716 } catch (const std::runtime_error& e) {
2717 ostringstream os;
2718 os << "Error reading ArrayOfSun: "
2719 << "\n Element: " << n << "\n"
2720 << e.what();
2721 throw runtime_error(os.str());
2722 }
2723
2724 tag.read_from_stream(is_xml);
2725 tag.check_name("/Array");
2726}
2727
2729
2735void xml_write_to_stream(ostream& os_xml,
2736 const ArrayOfSun& astar,
2737 bofstream* pbofs,
2738 const String& name,
2739 const Verbosity& verbosity) {
2740 ArtsXMLTag open_tag(verbosity);
2741 ArtsXMLTag close_tag(verbosity);
2742
2743 open_tag.set_name("Array");
2744 if (name.length()) open_tag.add_attribute("name", name);
2745
2746 open_tag.add_attribute("type", "Sun");
2747 open_tag.add_attribute("nelem", astar.nelem());
2748
2749 open_tag.write_to_stream(os_xml);
2750 os_xml << '\n';
2751
2752 for (Index n = 0; n < astar.nelem(); n++) {
2753 xml_write_to_stream(os_xml, astar[n], pbofs, "", verbosity);
2754 }
2755
2756 close_tag.set_name("/Array");
2757 close_tag.write_to_stream(os_xml);
2758
2759 os_xml << '\n';
2760}
2761
2762//=== ArrayOfString ==========================================================
2763
2765
2771void xml_parse_from_stream(istream& is_xml,
2772 ArrayOfString& astring,
2773 bifstream* pbifs,
2774 XMLTag& tag,
2775 const Verbosity& verbosity) {
2776 Index nelem;
2777
2778 tag.check_attribute("type", "String");
2779
2780 tag.get_attribute_value("nelem", nelem);
2781 astring.resize(nelem);
2782
2783 Index n;
2784 try {
2785 for (n = 0; n < nelem; n++)
2786 xml_read_from_stream(is_xml, astring[n], pbifs, verbosity);
2787 } catch (const std::runtime_error& e) {
2788 ostringstream os;
2789 os << "Error reading ArrayOfString: "
2790 << "\n Element: " << n << "\n"
2791 << e.what();
2792 throw runtime_error(os.str());
2793 }
2794}
2795
2797
2802void xml_read_from_stream(istream& is_xml,
2803 ArrayOfString& astring,
2804 bifstream* pbifs,
2805 const Verbosity& verbosity) {
2806 XMLTag tag(verbosity);
2807
2808 tag.read_from_stream(is_xml);
2809 tag.check_name("Array");
2810
2811 xml_parse_from_stream(is_xml, astring, pbifs, tag, verbosity);
2812
2813 tag.read_from_stream(is_xml);
2814 tag.check_name("/Array");
2815}
2816
2818
2824void xml_write_to_stream(ostream& os_xml,
2825 const ArrayOfString& astring,
2826 bofstream* pbofs,
2827 const String& name,
2828 const Verbosity& verbosity) {
2829 ArtsXMLTag open_tag(verbosity);
2830 ArtsXMLTag close_tag(verbosity);
2831
2832 open_tag.set_name("Array");
2833 if (name.length()) open_tag.add_attribute("name", name);
2834
2835 open_tag.add_attribute("type", "String");
2836 open_tag.add_attribute("nelem", astring.nelem());
2837
2838 open_tag.write_to_stream(os_xml);
2839 os_xml << '\n';
2840
2841 for (Index n = 0; n < astring.nelem(); n++)
2842 xml_write_to_stream(os_xml, astring[n], pbofs, "", verbosity);
2843
2844 close_tag.set_name("/Array");
2845 close_tag.write_to_stream(os_xml);
2846
2847 os_xml << '\n';
2848}
2849
2850//=== ArrayOfVector ==========================================================
2851
2853
2858void xml_read_from_stream(istream& is_xml,
2859 ArrayOfVector& avector,
2860 bifstream* pbifs,
2861 const Verbosity& verbosity) {
2862 ArtsXMLTag tag(verbosity);
2863 Index nelem;
2864
2865 tag.read_from_stream(is_xml);
2866 tag.check_name("Array");
2867 tag.check_attribute("type", "Vector");
2868
2869 tag.get_attribute_value("nelem", nelem);
2870 avector.resize(nelem);
2871
2872 Index n;
2873 try {
2874 for (n = 0; n < nelem; n++)
2875 xml_read_from_stream(is_xml, avector[n], pbifs, verbosity);
2876 } catch (const std::runtime_error& e) {
2877 ostringstream os;
2878 os << "Error reading ArrayOfVector: "
2879 << "\n Element: " << n << "\n"
2880 << e.what();
2881 throw runtime_error(os.str());
2882 }
2883
2884 tag.read_from_stream(is_xml);
2885 tag.check_name("/Array");
2886}
2887
2889
2895void xml_write_to_stream(ostream& os_xml,
2896 const ArrayOfVector& avector,
2897 bofstream* pbofs,
2898 const String& name,
2899 const Verbosity& verbosity) {
2900 ArtsXMLTag open_tag(verbosity);
2901 ArtsXMLTag close_tag(verbosity);
2902
2903 open_tag.set_name("Array");
2904 if (name.length()) open_tag.add_attribute("name", name);
2905
2906 open_tag.add_attribute("type", "Vector");
2907 open_tag.add_attribute("nelem", avector.nelem());
2908
2909 open_tag.write_to_stream(os_xml);
2910 os_xml << '\n';
2911
2912 for (Index n = 0; n < avector.nelem(); n++)
2913 xml_write_to_stream(os_xml, avector[n], pbofs, "", verbosity);
2914
2915 close_tag.set_name("/Array");
2916 close_tag.write_to_stream(os_xml);
2917
2918 os_xml << '\n';
2919}
2920
2921//=== ArrayOfTransmissionMatrix ======================================================
2922
2924
2929void xml_read_from_stream(istream& is_xml,
2930 ArrayOfTransmissionMatrix& atm,
2931 bifstream* pbifs,
2932 const Verbosity& verbosity) {
2933 ArtsXMLTag tag(verbosity);
2934 Index nelem;
2935
2936 tag.read_from_stream(is_xml);
2937 tag.check_name("Array");
2938 tag.check_attribute("type", "TransmissionMatrix");
2939
2940 tag.get_attribute_value("nelem", nelem);
2941 atm.resize(nelem);
2942
2943 Index n;
2944 try {
2945 for (n = 0; n < nelem; n++)
2946 xml_read_from_stream(is_xml, atm[n], pbifs, verbosity);
2947 } catch (const std::runtime_error& e) {
2948 ostringstream os;
2949 os << "Error reading ArrayOfTransmissionMatrix: "
2950 << "\n Element: " << n << "\n"
2951 << e.what();
2952 throw runtime_error(os.str());
2953 }
2954
2955 tag.read_from_stream(is_xml);
2956 tag.check_name("/Array");
2957}
2958
2960
2966void xml_write_to_stream(ostream& os_xml,
2967 const ArrayOfTransmissionMatrix& atm,
2968 bofstream* pbofs,
2969 const String& name,
2970 const Verbosity& verbosity) {
2971 ArtsXMLTag open_tag(verbosity);
2972 ArtsXMLTag close_tag(verbosity);
2973
2974 open_tag.set_name("Array");
2975 if (name.length()) open_tag.add_attribute("name", name);
2976
2977 open_tag.add_attribute("type", "TransmissionMatrix");
2978 open_tag.add_attribute("nelem", atm.nelem());
2979
2980 open_tag.write_to_stream(os_xml);
2981 os_xml << '\n';
2982
2983 for (Index n = 0; n < atm.nelem(); n++)
2984 xml_write_to_stream(os_xml, atm[n], pbofs, "", verbosity);
2985
2986 close_tag.set_name("/Array");
2987 close_tag.write_to_stream(os_xml);
2988
2989 os_xml << '\n';
2990}
2991
2992//=== ArrayOfArrayOfTransmissionMatrix ======================================================
2993
2995
3000void xml_read_from_stream(istream& is_xml,
3001 ArrayOfArrayOfTransmissionMatrix& aatm,
3002 bifstream* pbifs,
3003 const Verbosity& verbosity) {
3004 ArtsXMLTag tag(verbosity);
3005 Index nelem;
3006
3007 tag.read_from_stream(is_xml);
3008 tag.check_name("Array");
3009 tag.check_attribute("type", "ArrayOfTransmissionMatrix");
3010
3011 tag.get_attribute_value("nelem", nelem);
3012 aatm.resize(nelem);
3013
3014 Index n;
3015 try {
3016 for (n = 0; n < nelem; n++)
3017 xml_read_from_stream(is_xml, aatm[n], pbifs, verbosity);
3018 } catch (const std::runtime_error& e) {
3019 ostringstream os;
3020 os << "Error reading ArrayOfArrayOfTransmissionMatrix: "
3021 << "\n Element: " << n << "\n"
3022 << e.what();
3023 throw runtime_error(os.str());
3024 }
3025
3026 tag.read_from_stream(is_xml);
3027 tag.check_name("/Array");
3028}
3029
3031
3037void xml_write_to_stream(ostream& os_xml,
3038 const ArrayOfArrayOfTransmissionMatrix& aatm,
3039 bofstream* pbofs,
3040 const String& name,
3041 const Verbosity& verbosity) {
3042 ArtsXMLTag open_tag(verbosity);
3043 ArtsXMLTag close_tag(verbosity);
3044
3045 open_tag.set_name("Array");
3046 if (name.length()) open_tag.add_attribute("name", name);
3047
3048 open_tag.add_attribute("type", "ArrayOfTransmissionMatrix");
3049 open_tag.add_attribute("nelem", aatm.nelem());
3050
3051 open_tag.write_to_stream(os_xml);
3052 os_xml << '\n';
3053
3054 for (Index n = 0; n < aatm.nelem(); n++)
3055 xml_write_to_stream(os_xml, aatm[n], pbofs, "", verbosity);
3056
3057 close_tag.set_name("/Array");
3058 close_tag.write_to_stream(os_xml);
3059
3060 os_xml << '\n';
3061}
3062
3063//=== ArrayOfRadiationVector ======================================================
3064
3066
3071void xml_read_from_stream(istream& is_xml,
3072 ArrayOfRadiationVector& arv,
3073 bifstream* pbifs,
3074 const Verbosity& verbosity) {
3075 ArtsXMLTag tag(verbosity);
3076 Index nelem;
3077
3078 tag.read_from_stream(is_xml);
3079 tag.check_name("Array");
3080 tag.check_attribute("type", "RadiationVector");
3081
3082 tag.get_attribute_value("nelem", nelem);
3083 arv.resize(nelem);
3084
3085 Index n;
3086 try {
3087 for (n = 0; n < nelem; n++)
3088 xml_read_from_stream(is_xml, arv[n], pbifs, verbosity);
3089 } catch (const std::runtime_error& e) {
3090 ostringstream os;
3091 os << "Error reading ArrayOfRadiationVector: "
3092 << "\n Element: " << n << "\n"
3093 << e.what();
3094 throw runtime_error(os.str());
3095 }
3096
3097 tag.read_from_stream(is_xml);
3098 tag.check_name("/Array");
3099}
3100
3102
3108void xml_write_to_stream(ostream& os_xml,
3109 const ArrayOfRadiationVector& arv,
3110 bofstream* pbofs,
3111 const String& name,
3112 const Verbosity& verbosity) {
3113 ArtsXMLTag open_tag(verbosity);
3114 ArtsXMLTag close_tag(verbosity);
3115
3116 open_tag.set_name("Array");
3117 if (name.length()) open_tag.add_attribute("name", name);
3118
3119 open_tag.add_attribute("type", "RadiationVector");
3120 open_tag.add_attribute("nelem", arv.nelem());
3121
3122 open_tag.write_to_stream(os_xml);
3123 os_xml << '\n';
3124
3125 for (Index n = 0; n < arv.nelem(); n++)
3126 xml_write_to_stream(os_xml, arv[n], pbofs, "", verbosity);
3127
3128 close_tag.set_name("/Array");
3129 close_tag.write_to_stream(os_xml);
3130
3131 os_xml << '\n';
3132}
3133
3134//=== ArrayOfArrayOfRadiationVector ======================================================
3135
3137
3142void xml_read_from_stream(istream& is_xml,
3143 ArrayOfArrayOfRadiationVector& aarv,
3144 bifstream* pbifs,
3145 const Verbosity& verbosity) {
3146 ArtsXMLTag tag(verbosity);
3147 Index nelem;
3148
3149 tag.read_from_stream(is_xml);
3150 tag.check_name("Array");
3151 tag.check_attribute("type", "ArrayOfRadiationVector");
3152
3153 tag.get_attribute_value("nelem", nelem);
3154 aarv.resize(nelem);
3155
3156 Index n;
3157 try {
3158 for (n = 0; n < nelem; n++)
3159 xml_read_from_stream(is_xml, aarv[n], pbifs, verbosity);
3160 } catch (const std::runtime_error& e) {
3161 ostringstream os;
3162 os << "Error reading ArrayOfArrayOfRadiationVector: "
3163 << "\n Element: " << n << "\n"
3164 << e.what();
3165 throw runtime_error(os.str());
3166 }
3167
3168 tag.read_from_stream(is_xml);
3169 tag.check_name("/Array");
3170}
3171
3173
3179void xml_write_to_stream(ostream& os_xml,
3180 const ArrayOfArrayOfRadiationVector& aarv,
3181 bofstream* pbofs,
3182 const String& name,
3183 const Verbosity& verbosity) {
3184 ArtsXMLTag open_tag(verbosity);
3185 ArtsXMLTag close_tag(verbosity);
3186
3187 open_tag.set_name("Array");
3188 if (name.length()) open_tag.add_attribute("name", name);
3189
3190 open_tag.add_attribute("type", "ArrayOfRadiationVector");
3191 open_tag.add_attribute("nelem", aarv.nelem());
3192
3193 open_tag.write_to_stream(os_xml);
3194 os_xml << '\n';
3195
3196 for (Index n = 0; n < aarv.nelem(); n++)
3197 xml_write_to_stream(os_xml, aarv[n], pbofs, "", verbosity);
3198
3199 close_tag.set_name("/Array");
3200 close_tag.write_to_stream(os_xml);
3201
3202 os_xml << '\n';
3203}
3204
3205//=== ArrayOfPropagationMatrix ======================================================
3206
3208
3213void xml_read_from_stream(istream& is_xml,
3214 ArrayOfPropagationMatrix& apm,
3215 bifstream* pbifs,
3216 const Verbosity& verbosity) {
3217 ArtsXMLTag tag(verbosity);
3218 Index nelem;
3219
3220 tag.read_from_stream(is_xml);
3221 tag.check_name("Array");
3222 tag.check_attribute("type", "PropagationMatrix");
3223
3224 tag.get_attribute_value("nelem", nelem);
3225 apm.resize(nelem);
3226
3227 Index n;
3228 try {
3229 for (n = 0; n < nelem; n++)
3230 xml_read_from_stream(is_xml, apm[n], pbifs, verbosity);
3231 } catch (const std::runtime_error& e) {
3232 ostringstream os;
3233 os << "Error reading ArrayOfPropagationMatrix: "
3234 << "\n Element: " << n << "\n"
3235 << e.what();
3236 throw runtime_error(os.str());
3237 }
3238
3239 tag.read_from_stream(is_xml);
3240 tag.check_name("/Array");
3241}
3242
3244
3250void xml_write_to_stream(ostream& os_xml,
3251 const ArrayOfPropagationMatrix& apm,
3252 bofstream* pbofs,
3253 const String& name,
3254 const Verbosity& verbosity) {
3255 ArtsXMLTag open_tag(verbosity);
3256 ArtsXMLTag close_tag(verbosity);
3257
3258 open_tag.set_name("Array");
3259 if (name.length()) open_tag.add_attribute("name", name);
3260
3261 open_tag.add_attribute("type", "PropagationMatrix");
3262 open_tag.add_attribute("nelem", apm.nelem());
3263
3264 open_tag.write_to_stream(os_xml);
3265 os_xml << '\n';
3266
3267 for (Index n = 0; n < apm.nelem(); n++)
3268 xml_write_to_stream(os_xml, apm[n], pbofs, "", verbosity);
3269
3270 close_tag.set_name("/Array");
3271 close_tag.write_to_stream(os_xml);
3272
3273 os_xml << '\n';
3274}
3275
3276//=== ArrayOfAbsorptionLines ======================================================
3277
3279
3284void xml_read_from_stream(istream& is_xml,
3285 ArrayOfAbsorptionLines& aal,
3286 bifstream* pbifs,
3287 const Verbosity& verbosity) {
3288 ArtsXMLTag tag(verbosity);
3289 Index nelem;
3290
3291 tag.read_from_stream(is_xml);
3292 tag.check_name("Array");
3293 tag.check_attribute("type", "AbsorptionLines");
3294
3295 tag.get_attribute_value("nelem", nelem);
3296 aal.resize(nelem);
3297
3298 Index n;
3299 try {
3300 for (n = 0; n < nelem; n++)
3301 xml_read_from_stream(is_xml, aal[n], pbifs, verbosity);
3302 } catch (const std::runtime_error& e) {
3303 ostringstream os;
3304 os << "Error reading ArrayOfAbsorptionLines: "
3305 << "\n Element: " << n << "\n"
3306 << e.what();
3307 throw runtime_error(os.str());
3308 }
3309
3310 tag.read_from_stream(is_xml);
3311 tag.check_name("/Array");
3312}
3313
3315
3321void xml_write_to_stream(ostream& os_xml,
3322 const ArrayOfAbsorptionLines& aal,
3323 bofstream* pbofs,
3324 const String& name,
3325 const Verbosity& verbosity) {
3326 ArtsXMLTag open_tag(verbosity);
3327 ArtsXMLTag close_tag(verbosity);
3328
3329 open_tag.set_name("Array");
3330 if (name.length()) open_tag.add_attribute("name", name);
3331
3332 open_tag.add_attribute("type", "AbsorptionLines");
3333 open_tag.add_attribute("nelem", aal.nelem());
3334
3335 open_tag.write_to_stream(os_xml);
3336 os_xml << '\n';
3337
3338 for (Index n = 0; n < aal.nelem(); n++)
3339 xml_write_to_stream(os_xml, aal[n], pbofs, "", verbosity);
3340
3341 close_tag.set_name("/Array");
3342 close_tag.write_to_stream(os_xml);
3343
3344 os_xml << '\n';
3345}
3346
3347//=== ArrayOfArrayOfAbsorptionLines ======================================================
3348
3350
3355void xml_read_from_stream(istream& is_xml,
3356 ArrayOfArrayOfAbsorptionLines& aal,
3357 bifstream* pbifs,
3358 const Verbosity& verbosity) {
3359 ArtsXMLTag tag(verbosity);
3360 Index nelem;
3361
3362 tag.read_from_stream(is_xml);
3363 tag.check_name("Array");
3364 tag.check_attribute("type", "ArrayOfAbsorptionLines");
3365
3366 tag.get_attribute_value("nelem", nelem);
3367 aal.resize(nelem);
3368
3369 Index n;
3370 try {
3371 for (n = 0; n < nelem; n++)
3372 xml_read_from_stream(is_xml, aal[n], pbifs, verbosity);
3373 } catch (const std::runtime_error& e) {
3374 ostringstream os;
3375 os << "Error reading ArrayOfArrayOfAbsorptionLines: "
3376 << "\n Element: " << n << "\n"
3377 << e.what();
3378 throw runtime_error(os.str());
3379 }
3380
3381 tag.read_from_stream(is_xml);
3382 tag.check_name("/Array");
3383}
3384
3386
3392void xml_write_to_stream(ostream& os_xml,
3393 const ArrayOfArrayOfAbsorptionLines& aal,
3394 bofstream* pbofs,
3395 const String& name,
3396 const Verbosity& verbosity) {
3397 ArtsXMLTag open_tag(verbosity);
3398 ArtsXMLTag close_tag(verbosity);
3399
3400 open_tag.set_name("Array");
3401 if (name.length()) open_tag.add_attribute("name", name);
3402
3403 open_tag.add_attribute("type", "ArrayOfAbsorptionLines");
3404 open_tag.add_attribute("nelem", aal.nelem());
3405
3406 open_tag.write_to_stream(os_xml);
3407 os_xml << '\n';
3408
3409 for (Index n = 0; n < aal.nelem(); n++)
3410 xml_write_to_stream(os_xml, aal[n], pbofs, "", verbosity);
3411
3412 close_tag.set_name("/Array");
3413 close_tag.write_to_stream(os_xml);
3414
3415 os_xml << '\n';
3416}
3417
3418//=== ArrayOfArrayOfPropagationMatrix ======================================================
3419
3421
3426void xml_read_from_stream(istream& is_xml,
3427 ArrayOfArrayOfPropagationMatrix& aapm,
3428 bifstream* pbifs,
3429 const Verbosity& verbosity) {
3430 ArtsXMLTag tag(verbosity);
3431 Index nelem;
3432
3433 tag.read_from_stream(is_xml);
3434 tag.check_name("Array");
3435 tag.check_attribute("type", "ArrayOfPropagationMatrix");
3436
3437 tag.get_attribute_value("nelem", nelem);
3438 aapm.resize(nelem);
3439
3440 Index n;
3441 try {
3442 for (n = 0; n < nelem; n++)
3443 xml_read_from_stream(is_xml, aapm[n], pbifs, verbosity);
3444 } catch (const std::runtime_error& e) {
3445 ostringstream os;
3446 os << "Error reading ArrayOfArrayOfPropagationMatrix: "
3447 << "\n Element: " << n << "\n"
3448 << e.what();
3449 throw runtime_error(os.str());
3450 }
3451
3452 tag.read_from_stream(is_xml);
3453 tag.check_name("/Array");
3454}
3455
3457
3463void xml_write_to_stream(ostream& os_xml,
3464 const ArrayOfArrayOfPropagationMatrix& aapm,
3465 bofstream* pbofs,
3466 const String& name,
3467 const Verbosity& verbosity) {
3468 ArtsXMLTag open_tag(verbosity);
3469 ArtsXMLTag close_tag(verbosity);
3470
3471 open_tag.set_name("Array");
3472 if (name.length()) open_tag.add_attribute("name", name);
3473
3474 open_tag.add_attribute("type", "ArrayOfPropagationMatrix");
3475 open_tag.add_attribute("nelem", aapm.nelem());
3476
3477 open_tag.write_to_stream(os_xml);
3478 os_xml << '\n';
3479
3480 for (Index n = 0; n < aapm.nelem(); n++)
3481 xml_write_to_stream(os_xml, aapm[n], pbofs, "", verbosity);
3482
3483 close_tag.set_name("/Array");
3484 close_tag.write_to_stream(os_xml);
3485
3486 os_xml << '\n';
3487}
3488
3489//=== ArrayOfStokesVector ======================================================
3490
3492
3497void xml_read_from_stream(istream& is_xml,
3498 ArrayOfStokesVector& apm,
3499 bifstream* pbifs,
3500 const Verbosity& verbosity) {
3501 ArtsXMLTag tag(verbosity);
3502 Index nelem;
3503
3504 tag.read_from_stream(is_xml);
3505 tag.check_name("Array");
3506 tag.check_attribute("type", "StokesVector");
3507
3508 tag.get_attribute_value("nelem", nelem);
3509 apm.resize(nelem);
3510
3511 Index n;
3512 try {
3513 for (n = 0; n < nelem; n++)
3514 xml_read_from_stream(is_xml, apm[n], pbifs, verbosity);
3515 } catch (const std::runtime_error& e) {
3516 ostringstream os;
3517 os << "Error reading ArrayOfStokesVector: "
3518 << "\n Element: " << n << "\n"
3519 << e.what();
3520 throw runtime_error(os.str());
3521 }
3522
3523 tag.read_from_stream(is_xml);
3524 tag.check_name("/Array");
3525}
3526
3528
3534void xml_write_to_stream(ostream& os_xml,
3535 const ArrayOfStokesVector& apm,
3536 bofstream* pbofs,
3537 const String& name,
3538 const Verbosity& verbosity) {
3539 ArtsXMLTag open_tag(verbosity);
3540 ArtsXMLTag close_tag(verbosity);
3541
3542 open_tag.set_name("Array");
3543 if (name.length()) open_tag.add_attribute("name", name);
3544
3545 open_tag.add_attribute("type", "StokesVector");
3546 open_tag.add_attribute("nelem", apm.nelem());
3547
3548 open_tag.write_to_stream(os_xml);
3549 os_xml << '\n';
3550
3551 for (Index n = 0; n < apm.nelem(); n++)
3552 xml_write_to_stream(os_xml, apm[n], pbofs, "", verbosity);
3553
3554 close_tag.set_name("/Array");
3555 close_tag.write_to_stream(os_xml);
3556
3557 os_xml << '\n';
3558}
3559
3560//=== ArrayOfArrayOfStokesVector ======================================================
3561
3563
3568void xml_read_from_stream(istream& is_xml,
3569 ArrayOfArrayOfStokesVector& aapm,
3570 bifstream* pbifs,
3571 const Verbosity& verbosity) {
3572 ArtsXMLTag tag(verbosity);
3573 Index nelem;
3574
3575 tag.read_from_stream(is_xml);
3576 tag.check_name("Array");
3577 tag.check_attribute("type", "ArrayOfStokesVector");
3578
3579 tag.get_attribute_value("nelem", nelem);
3580 aapm.resize(nelem);
3581
3582 Index n;
3583 try {
3584 for (n = 0; n < nelem; n++)
3585 xml_read_from_stream(is_xml, aapm[n], pbifs, verbosity);
3586 } catch (const std::runtime_error& e) {
3587 ostringstream os;
3588 os << "Error reading ArrayOfArrayOfStokesVector: "
3589 << "\n Element: " << n << "\n"
3590 << e.what();
3591 throw runtime_error(os.str());
3592 }
3593
3594 tag.read_from_stream(is_xml);
3595 tag.check_name("/Array");
3596}
3597
3599
3605void xml_write_to_stream(ostream& os_xml,
3606 const ArrayOfArrayOfStokesVector& aapm,
3607 bofstream* pbofs,
3608 const String& name,
3609 const Verbosity& verbosity) {
3610 ArtsXMLTag open_tag(verbosity);
3611 ArtsXMLTag close_tag(verbosity);
3612
3613 open_tag.set_name("Array");
3614 if (name.length()) open_tag.add_attribute("name", name);
3615
3616 open_tag.add_attribute("type", "ArrayOfStokesVector");
3617 open_tag.add_attribute("nelem", aapm.nelem());
3618
3619 open_tag.write_to_stream(os_xml);
3620 os_xml << '\n';
3621
3622 for (Index n = 0; n < aapm.nelem(); n++)
3623 xml_write_to_stream(os_xml, aapm[n], pbofs, "", verbosity);
3624
3625 close_tag.set_name("/Array");
3626 close_tag.write_to_stream(os_xml);
3627
3628 os_xml << '\n';
3629}
3630
3631//=== ArrayOfXsecRecord ======================================================
3632
3634
3639void xml_read_from_stream(istream& is_xml,
3640 ArrayOfXsecRecord& axd,
3641 bifstream* pbifs,
3642 const Verbosity& verbosity) {
3643 ArtsXMLTag tag(verbosity);
3644 Index nelem;
3645
3646 tag.read_from_stream(is_xml);
3647 tag.check_name("Array");
3648 tag.check_attribute("type", "XsecRecord");
3649
3650 tag.get_attribute_value("nelem", nelem);
3651 axd.resize(nelem);
3652
3653 Index n;
3654 try {
3655 for (n = 0; n < nelem; n++)
3656 xml_read_from_stream(is_xml, axd[n], pbifs, verbosity);
3657 } catch (const std::runtime_error& e) {
3658 ostringstream os;
3659 os << "Error reading ArrayOfXsecRecord: "
3660 << "\n Element: " << n << "\n"
3661 << e.what();
3662 throw runtime_error(os.str());
3663 }
3664
3665 tag.read_from_stream(is_xml);
3666 tag.check_name("/Array");
3667}
3668
3670
3676void xml_write_to_stream(ostream& os_xml,
3677 const ArrayOfXsecRecord& axd,
3678 bofstream* pbofs,
3679 const String& name,
3680 const Verbosity& verbosity) {
3681 ArtsXMLTag open_tag(verbosity);
3682 ArtsXMLTag close_tag(verbosity);
3683
3684 open_tag.set_name("Array");
3685 if (name.length()) open_tag.add_attribute("name", name);
3686
3687 open_tag.add_attribute("type", "XsecRecord");
3688 open_tag.add_attribute("nelem", axd.nelem());
3689
3690 open_tag.write_to_stream(os_xml);
3691 os_xml << '\n';
3692
3693 for (Index n = 0; n < axd.nelem(); n++)
3694 xml_write_to_stream(os_xml, axd[n], pbofs, "", verbosity);
3695
3696 close_tag.set_name("/Array");
3697 close_tag.write_to_stream(os_xml);
3698
3699 os_xml << '\n';
3700}
3701
3702//=== ArrayOfTime ======================================================
3703
3705
3710void xml_read_from_stream(istream& is_xml,
3711 ArrayOfTime& at,
3712 bifstream* pbifs,
3713 const Verbosity& verbosity) {
3714 ArtsXMLTag tag(verbosity);
3715 Index nelem;
3716
3717 tag.read_from_stream(is_xml);
3718 tag.check_name("Array");
3719 tag.check_attribute("type", "Time");
3720
3721 tag.get_attribute_value("nelem", nelem);
3722 at.resize(nelem);
3723
3724 Index n;
3725 try {
3726 for (n = 0; n < nelem; n++)
3727 xml_read_from_stream(is_xml, at[n], pbifs, verbosity);
3728 } catch (const std::runtime_error& e) {
3729 ostringstream os;
3730 os << "Error reading ArrayOfTime: "
3731 << "\n Element: " << n << "\n"
3732 << e.what();
3733 throw runtime_error(os.str());
3734 }
3735
3736 tag.read_from_stream(is_xml);
3737 tag.check_name("/Array");
3738}
3739
3741
3747void xml_write_to_stream(ostream& os_xml,
3748 const ArrayOfTime& at,
3749 bofstream* pbofs,
3750 const String& name,
3751 const Verbosity& verbosity) {
3752 ArtsXMLTag open_tag(verbosity);
3753 ArtsXMLTag close_tag(verbosity);
3754
3755 open_tag.set_name("Array");
3756 if (name.length()) open_tag.add_attribute("name", name);
3757
3758 open_tag.add_attribute("type", "Time");
3759 open_tag.add_attribute("nelem", at.nelem());
3760
3761 open_tag.write_to_stream(os_xml);
3762 os_xml << '\n';
3763
3764 for (Index n = 0; n < at.nelem(); n++)
3765 xml_write_to_stream(os_xml, at[n], pbofs, "", verbosity);
3766
3767 close_tag.set_name("/Array");
3768 close_tag.write_to_stream(os_xml);
3769
3770 os_xml << '\n';
3771}
3772
3773//=== ArrayOfArrayOfTime ======================================================
3774
3776
3781void xml_read_from_stream(istream& is_xml,
3782 ArrayOfArrayOfTime& at,
3783 bifstream* pbifs,
3784 const Verbosity& verbosity) {
3785 ArtsXMLTag tag(verbosity);
3786 Index nelem;
3787
3788 tag.read_from_stream(is_xml);
3789 tag.check_name("Array");
3790 tag.check_attribute("type", "ArrayOfTime");
3791
3792 tag.get_attribute_value("nelem", nelem);
3793 at.resize(nelem);
3794
3795 Index n;
3796 try {
3797 for (n = 0; n < nelem; n++)
3798 xml_read_from_stream(is_xml, at[n], pbifs, verbosity);
3799 } catch (const std::runtime_error& e) {
3800 ostringstream os;
3801 os << "Error reading ArrayOfArrayOfTime: "
3802 << "\n Element: " << n << "\n"
3803 << e.what();
3804 throw runtime_error(os.str());
3805 }
3806
3807 tag.read_from_stream(is_xml);
3808 tag.check_name("/Array");
3809}
3810
3812
3818void xml_write_to_stream(ostream& os_xml,
3819 const ArrayOfArrayOfTime& at,
3820 bofstream* pbofs,
3821 const String& name,
3822 const Verbosity& verbosity) {
3823 ArtsXMLTag open_tag(verbosity);
3824 ArtsXMLTag close_tag(verbosity);
3825
3826 open_tag.set_name("Array");
3827 if (name.length()) open_tag.add_attribute("name", name);
3828
3829 open_tag.add_attribute("type", "ArrayOfTime");
3830 open_tag.add_attribute("nelem", at.nelem());
3831
3832 open_tag.write_to_stream(os_xml);
3833 os_xml << '\n';
3834
3835 for (Index n = 0; n < at.nelem(); n++)
3836 xml_write_to_stream(os_xml, at[n], pbofs, "", verbosity);
3837
3838 close_tag.set_name("/Array");
3839 close_tag.write_to_stream(os_xml);
3840
3841 os_xml << '\n';
3842}
3843
arts.h
The global header file for ARTS.
Array
This can be used to make arrays out of anything.
Definition: array.h:31
Array::nelem
Index nelem() const ARTS_NOEXCEPT
Definition: array.h:75
ArtsXMLTag
The ARTS XML tag class.
Definition: xml_io.h:28
ArtsXMLTag::add_attribute
void add_attribute(const String &aname, const std::vector< QuantumNumberType > &value)
Adds value of attribute as type std::vector<QuantumNumberType> to tag.
Definition: xml_io.cc:25
ArtsXMLTag::get_attribute_value
void get_attribute_value(const String &aname, SpeciesTag &value)
Returns value of attribute as type SpeciesTag.
Definition: xml_io.cc:53
XMLTag
The ARTS XML tag class.
Definition: xml_io_base.h:53
XMLTag::write_to_stream
void write_to_stream(ostream &os)
Write XML tag.
Definition: xml_io_base.cc:305
XMLTag::check_name
void check_name(const String &expected_name)
Check tag name.
Definition: xml_io_base.cc:37
XMLTag::read_from_stream
void read_from_stream(istream &is)
Reads next XML tag.
Definition: xml_io_base.cc:184
XMLTag::get_attribute_value
void get_attribute_value(const String &aname, String &value)
Definition: xml_io_base.cc:123
XMLTag::set_name
void set_name(const String &new_name)
Definition: xml_io_base.h:61
XMLTag::check_attribute
void check_attribute(const String &aname, const String &value)
Checks whether attribute has the expected value.
Definition: xml_io_base.cc:94
bifstream
Binary output file stream class.
Definition: bifstream.h:26
bofstream
Binary output file stream class.
Definition: bofstream.h:25
my_basic_string< char >
_U_
#define _U_
Definition: config.h:177
QuantumIdentifier
Quantum::Number::GlobalState QuantumIdentifier
Definition: quantum_numbers.h:1222
xml_io.h
This file contains basic functions to handle XML data files.
xml_write_to_stream
void xml_write_to_stream(ostream &os_xml, const ArrayOfAgenda &aa, bofstream *pbofs, const String &name, const Verbosity &)
Writes ArrayOfAgenda to XML output stream.
Definition: xml_io_array_types.cc:42
xml_read_from_stream
void xml_read_from_stream(istream &is_xml, ArrayOfAgenda &aa, bifstream *pbifs, const Verbosity &)
Reads ArrayOfAgenda from XML input stream.
Definition: xml_io_array_types.cc:28
xml_parse_from_stream
void xml_parse_from_stream(istream &is_xml, ArrayOfString &astring, bifstream *pbifs, XMLTag &tag, const Verbosity &verbosity)
Parse ArrayOfString from XML input stream.
Definition: xml_io_array_types.cc:2771