ARTS  2.4.0(git:4fb77825)
xml_io_array_types.cc
Go to the documentation of this file.
1 /* Copyright (C) 2003-2012 Oliver Lemke <olemke@core-dump.info>
2 
3  This program is free software; you can redistribute it and/or modify it
4  under the terms of the GNU General Public License as published by the
5  Free Software Foundation; either version 2, or (at your option) any
6  later version.
7 
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  GNU General Public License for more details.
12 
13  You should have received a copy of the GNU General Public License
14  along with this program; if not, write to the Free Software
15  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16  USA. */
17 
19 // File description
21 
30 #include "arts.h"
31 #include "jacobian.h"
32 #include "xml_io_private.h"
33 #include "xml_io_types.h"
34 
36 // Overloaded functions for reading/writing data from/to XML stream
38 
39 //=== ArrayOfAgenda ===========================================
40 
42 
47 void xml_read_from_stream(istream& is_xml _U_,
48  ArrayOfAgenda& aa _U_,
49  bifstream* pbifs _U_,
50  const Verbosity&) {
51  throw runtime_error("Not supported.");
52 }
53 
55 
61 void xml_write_to_stream(ostream& os_xml _U_,
62  const ArrayOfAgenda& aa _U_,
63  bofstream* pbofs _U_,
64  const String& name _U_,
65  const Verbosity&)
66 
67 {
68  throw runtime_error("ArrayOfAgendas can't be saved.");
69 }
70 
71 //=== Array<SpeciesRecord> ================================================
72 
74 
79 void xml_read_from_stream(istream& is_xml,
80  Array<SpeciesRecord>& asrecord,
81  bifstream* pbifs,
82  const Verbosity& verbosity) {
83  ArtsXMLTag tag(verbosity);
84  Index nelem;
85 
86  tag.read_from_stream(is_xml);
87  tag.check_name("Array");
88  tag.check_attribute("type", "SpeciesData");
89 
90  tag.get_attribute_value("nelem", nelem);
91  asrecord.resize(nelem);
92 
93  Index n;
94  try {
95  for (n = 0; n < nelem; n++) {
96  xml_read_from_stream(is_xml, asrecord[n], pbifs, verbosity);
97  }
98  } catch (const std::runtime_error& e) {
99  ostringstream os;
100  os << "Error reading SpeciesData: "
101  << "\n Element: " << n << "\n"
102  << e.what();
103  throw runtime_error(os.str());
104  }
105 
106  tag.read_from_stream(is_xml);
107  tag.check_name("/Array");
108 }
109 
111 
117 void xml_write_to_stream(ostream& os_xml,
118  const Array<SpeciesRecord>& asrecord,
119  bofstream* pbofs,
120  const String& name,
121  const Verbosity& verbosity) {
122  ArtsXMLTag open_tag(verbosity);
123  ArtsXMLTag close_tag(verbosity);
124 
125  open_tag.set_name("Array");
126  if (name.length()) open_tag.add_attribute("name", name);
127 
128  open_tag.add_attribute("type", "SpeciesData");
129  open_tag.add_attribute("nelem", asrecord.nelem());
130 
131  open_tag.write_to_stream(os_xml);
132  os_xml << '\n';
133 
134  for (Index n = 0; n < asrecord.nelem(); n++) {
135  xml_write_to_stream(os_xml, asrecord[n], pbofs, "", verbosity);
136  }
137 
138  close_tag.set_name("/Array");
139  close_tag.write_to_stream(os_xml);
140 
141  os_xml << '\n';
142 }
143 
144 //=== ArrayOfArrayOfSpeciesTag ================================================
145 
147 
152 void xml_read_from_stream(istream& is_xml,
153  ArrayOfArrayOfSpeciesTag& aastag,
154  bifstream* pbifs,
155  const Verbosity& verbosity) {
156  ArtsXMLTag tag(verbosity);
157  Index nelem;
158 
159  tag.read_from_stream(is_xml);
160  tag.check_name("Array");
161  tag.check_attribute("type", "ArrayOfSpeciesTag");
162 
163  tag.get_attribute_value("nelem", nelem);
164  aastag.resize(nelem);
165 
166  Index n;
167  try {
168  for (n = 0; n < nelem; n++) {
169  xml_read_from_stream(is_xml, aastag[n], pbifs, verbosity);
170  }
171  } catch (const std::runtime_error& e) {
172  ostringstream os;
173  os << "Error reading ArrayOfArrayOfSpeciesTag: "
174  << "\n Element: " << n << "\n"
175  << e.what();
176  throw runtime_error(os.str());
177  }
178 
179  tag.read_from_stream(is_xml);
180  tag.check_name("/Array");
181 }
182 
184 
190 void xml_write_to_stream(ostream& os_xml,
191  const ArrayOfArrayOfSpeciesTag& aastag,
192  bofstream* pbofs,
193  const String& name,
194  const Verbosity& verbosity) {
195  ArtsXMLTag open_tag(verbosity);
196  ArtsXMLTag close_tag(verbosity);
197 
198  open_tag.set_name("Array");
199  if (name.length()) open_tag.add_attribute("name", name);
200 
201  open_tag.add_attribute("type", "ArrayOfSpeciesTag");
202  open_tag.add_attribute("nelem", aastag.nelem());
203 
204  open_tag.write_to_stream(os_xml);
205  os_xml << '\n';
206 
207  for (Index n = 0; n < aastag.nelem(); n++) {
208  xml_write_to_stream(os_xml, aastag[n], pbofs, "", verbosity);
209  }
210 
211  close_tag.set_name("/Array");
212  close_tag.write_to_stream(os_xml);
213 
214  os_xml << '\n';
215 }
216 
217 //=== ArrayOfArrayOfString ==========================================================
218 
220 
225 void xml_read_from_stream(istream& is_xml,
226  ArrayOfArrayOfString& aastring,
227  bifstream* pbifs,
228  const Verbosity& verbosity) {
229  ArtsXMLTag tag(verbosity);
230  Index nelem;
231 
232  tag.read_from_stream(is_xml);
233  tag.check_name("Array");
234 
235  tag.check_attribute("type", "ArrayOfString");
236 
237  tag.get_attribute_value("nelem", nelem);
238  aastring.resize(nelem);
239 
240  Index n;
241  try {
242  for (n = 0; n < nelem; n++)
243  xml_read_from_stream(is_xml, aastring[n], pbifs, verbosity);
244  } catch (const std::runtime_error& e) {
245  ostringstream os;
246  os << "Error reading ArrayOfArrayOfString: "
247  << "\n Element: " << n << "\n"
248  << e.what();
249  throw runtime_error(os.str());
250  }
251 
252  tag.read_from_stream(is_xml);
253  tag.check_name("/Array");
254 }
255 
257 
263 void xml_write_to_stream(ostream& os_xml,
264  const ArrayOfArrayOfString& aastring,
265  bofstream* pbofs,
266  const String& name,
267  const Verbosity& verbosity) {
268  ArtsXMLTag open_tag(verbosity);
269  ArtsXMLTag close_tag(verbosity);
270 
271  open_tag.set_name("Array");
272  if (name.length()) open_tag.add_attribute("name", name);
273 
274  open_tag.add_attribute("type", "ArrayOfString");
275  open_tag.add_attribute("nelem", aastring.nelem());
276 
277  open_tag.write_to_stream(os_xml);
278  os_xml << '\n';
279 
280  for (Index n = 0; n < aastring.nelem(); n++)
281  xml_write_to_stream(os_xml, aastring[n], pbofs, "", verbosity);
282 
283  close_tag.set_name("/Array");
284  close_tag.write_to_stream(os_xml);
285 
286  os_xml << '\n';
287 }
288 
289 //=== ArrayOfPpath =========================================================
290 
292 
297 void xml_read_from_stream(istream& is_xml,
298  ArrayOfPpath& appath,
299  bifstream* pbifs,
300  const Verbosity& verbosity) {
301  ArtsXMLTag tag(verbosity);
302  Index nelem;
303 
304  tag.read_from_stream(is_xml);
305  tag.check_name("Array");
306  tag.check_attribute("type", "Ppath");
307 
308  tag.get_attribute_value("nelem", nelem);
309  appath.resize(nelem);
310 
311  Index n;
312  try {
313  for (n = 0; n < nelem; n++) {
314  xml_read_from_stream(is_xml, appath[n], pbifs, verbosity);
315  }
316  } catch (const std::runtime_error& e) {
317  ostringstream os;
318  os << "Error reading ArrayOfPpath: "
319  << "\n Element: " << n << "\n"
320  << e.what();
321  throw runtime_error(os.str());
322  }
323 
324  tag.read_from_stream(is_xml);
325  tag.check_name("/Array");
326 }
327 
329 
335 void xml_write_to_stream(ostream& os_xml,
336  const ArrayOfPpath& appath,
337  bofstream* pbofs,
338  const String& name,
339  const Verbosity& verbosity) {
340  ArtsXMLTag open_tag(verbosity);
341  ArtsXMLTag close_tag(verbosity);
342 
343  open_tag.set_name("Array");
344  if (name.length()) open_tag.add_attribute("name", name);
345 
346  open_tag.add_attribute("type", "Ppath");
347  open_tag.add_attribute("nelem", appath.nelem());
348 
349  open_tag.write_to_stream(os_xml);
350  os_xml << '\n';
351 
352  for (Index n = 0; n < appath.nelem(); n++) {
353  xml_write_to_stream(os_xml, appath[n], pbofs, "", verbosity);
354  }
355 
356  close_tag.set_name("/Array");
357  close_tag.write_to_stream(os_xml);
358 
359  os_xml << '\n';
360 }
361 
362 //=== ArrayOfArrayOfTensor3==================================================
363 
365 
370 void xml_read_from_stream(istream& is_xml,
371  ArrayOfArrayOfTensor3& aatensor3,
372  bifstream* pbifs,
373  const Verbosity& verbosity) {
374  ArtsXMLTag tag(verbosity);
375  Index nelem;
376 
377  tag.read_from_stream(is_xml);
378  tag.check_name("Array");
379  tag.check_attribute("type", "ArrayOfTensor3");
380 
381  tag.get_attribute_value("nelem", nelem);
382  aatensor3.resize(nelem);
383 
384  Index n;
385  try {
386  for (n = 0; n < nelem; n++)
387  xml_read_from_stream(is_xml, aatensor3[n], pbifs, verbosity);
388  } catch (const std::runtime_error& e) {
389  ostringstream os;
390  os << "Error reading ArrayOfArrayOfTensor3: "
391  << "\n Element: " << n << "\n"
392  << e.what();
393  throw runtime_error(os.str());
394  }
395 
396  tag.read_from_stream(is_xml);
397  tag.check_name("/Array");
398 }
399 
401 
407 void xml_write_to_stream(ostream& os_xml,
408  const ArrayOfArrayOfTensor3& aatensor3,
409  bofstream* pbofs,
410  const String& name,
411  const Verbosity& verbosity) {
412  ArtsXMLTag open_tag(verbosity);
413  ArtsXMLTag close_tag(verbosity);
414 
415  open_tag.set_name("Array");
416  if (name.length()) open_tag.add_attribute("name", name);
417 
418  open_tag.add_attribute("type", "ArrayOfTensor3");
419  open_tag.add_attribute("nelem", aatensor3.nelem());
420 
421  open_tag.write_to_stream(os_xml);
422  os_xml << '\n';
423 
424  for (Index n = 0; n < aatensor3.nelem(); n++) {
425  xml_write_to_stream(os_xml, aatensor3[n], pbofs, "", verbosity);
426  }
427 
428  close_tag.set_name("/Array");
429  close_tag.write_to_stream(os_xml);
430 
431  os_xml << '\n';
432 }
433 
434 //=== ArrayOfArrayOfTensor6==================================================
435 
437 
442 void xml_read_from_stream(istream& is_xml,
443  ArrayOfArrayOfTensor6& aatensor6,
444  bifstream* pbifs,
445  const Verbosity& verbosity) {
446  ArtsXMLTag tag(verbosity);
447  Index nelem;
448 
449  tag.read_from_stream(is_xml);
450  tag.check_name("Array");
451  tag.check_attribute("type", "ArrayOfTensor6");
452 
453  tag.get_attribute_value("nelem", nelem);
454  aatensor6.resize(nelem);
455 
456  Index n;
457  try {
458  for (n = 0; n < nelem; n++)
459  xml_read_from_stream(is_xml, aatensor6[n], pbifs, verbosity);
460  } catch (const std::runtime_error& e) {
461  ostringstream os;
462  os << "Error reading ArrayOfArrayOfTensor6: "
463  << "\n Element: " << n << "\n"
464  << e.what();
465  throw runtime_error(os.str());
466  }
467 
468  tag.read_from_stream(is_xml);
469  tag.check_name("/Array");
470 }
471 
473 
479 void xml_write_to_stream(ostream& os_xml,
480  const ArrayOfArrayOfTensor6& aatensor6,
481  bofstream* pbofs,
482  const String& name,
483  const Verbosity& verbosity) {
484  ArtsXMLTag open_tag(verbosity);
485  ArtsXMLTag close_tag(verbosity);
486 
487  open_tag.set_name("Array");
488  if (name.length()) open_tag.add_attribute("name", name);
489 
490  open_tag.add_attribute("type", "ArrayOfTensor6");
491  open_tag.add_attribute("nelem", aatensor6.nelem());
492 
493  open_tag.write_to_stream(os_xml);
494  os_xml << '\n';
495 
496  for (Index n = 0; n < aatensor6.nelem(); n++)
497  xml_write_to_stream(os_xml, aatensor6[n], pbofs, "", verbosity);
498 
499  close_tag.set_name("/Array");
500  close_tag.write_to_stream(os_xml);
501 
502  os_xml << '\n';
503 }
504 
505 //=== ArrayOfGridPos =========================================================
506 
508 
513 void xml_read_from_stream(istream& is_xml,
514  ArrayOfGridPos& agpos,
515  bifstream* pbifs,
516  const Verbosity& verbosity) {
517  ArtsXMLTag tag(verbosity);
518  Index nelem;
519 
520  tag.read_from_stream(is_xml);
521  tag.check_name("Array");
522  tag.check_attribute("type", "GridPos");
523 
524  tag.get_attribute_value("nelem", nelem);
525  agpos.resize(nelem);
526 
527  Index n;
528  try {
529  for (n = 0; n < nelem; n++)
530  xml_read_from_stream(is_xml, agpos[n], pbifs, verbosity);
531  } catch (const std::runtime_error& e) {
532  ostringstream os;
533  os << "Error reading ArrayOfGridPos: "
534  << "\n Element: " << n << "\n"
535  << e.what();
536  throw runtime_error(os.str());
537  }
538 
539  tag.read_from_stream(is_xml);
540  tag.check_name("/Array");
541 }
542 
544 
550 void xml_write_to_stream(ostream& os_xml,
551  const ArrayOfGridPos& agpos,
552  bofstream* pbofs,
553  const String& name,
554  const Verbosity& verbosity) {
555  ArtsXMLTag open_tag(verbosity);
556  ArtsXMLTag close_tag(verbosity);
557 
558  open_tag.set_name("Array");
559  if (name.length()) open_tag.add_attribute("name", name);
560 
561  open_tag.add_attribute("type", "GridPos");
562  open_tag.add_attribute("nelem", agpos.nelem());
563 
564  open_tag.write_to_stream(os_xml);
565  os_xml << '\n';
566 
567  for (Index n = 0; n < agpos.nelem(); n++)
568  xml_write_to_stream(os_xml, agpos[n], pbofs, "", verbosity);
569 
570  close_tag.set_name("/Array");
571  close_tag.write_to_stream(os_xml);
572 
573  os_xml << '\n';
574 }
575 
576 //=== ArrayOfArrayOfGridPos =====================================
577 
579 
584 void xml_read_from_stream(istream& is_xml,
585  ArrayOfArrayOfGridPos& aagpos,
586  bifstream* pbifs,
587  const Verbosity& verbosity) {
588  ArtsXMLTag tag(verbosity);
589  Index nelem;
590 
591  tag.read_from_stream(is_xml);
592  tag.check_name("Array");
593  tag.check_attribute("type", "ArrayOfGridPos");
594 
595  tag.get_attribute_value("nelem", nelem);
596  aagpos.resize(nelem);
597 
598  Index n;
599  try {
600  for (n = 0; n < nelem; n++)
601  xml_read_from_stream(is_xml, aagpos[n], pbifs, verbosity);
602  } catch (const std::runtime_error& e) {
603  ostringstream os;
604  os << "Error reading ArrayOfArrayOfGridPos: "
605  << "\n Element: " << n << "\n"
606  << e.what();
607  throw runtime_error(os.str());
608  }
609 
610  tag.read_from_stream(is_xml);
611  tag.check_name("/Array");
612 }
613 
615 
621 void xml_write_to_stream(ostream& os_xml,
622  const ArrayOfArrayOfGridPos& aagpos,
623  bofstream* pbofs,
624  const String& name,
625  const Verbosity& verbosity) {
626  ArtsXMLTag open_tag(verbosity);
627  ArtsXMLTag close_tag(verbosity);
628 
629  open_tag.set_name("Array");
630  if (name.length()) open_tag.add_attribute("name", name);
631 
632  open_tag.add_attribute("type", "ArrayOfGridPos");
633  open_tag.add_attribute("nelem", aagpos.nelem());
634 
635  open_tag.write_to_stream(os_xml);
636  os_xml << '\n';
637 
638  for (Index n = 0; n < aagpos.nelem(); n++)
639  xml_write_to_stream(os_xml, aagpos[n], pbofs, "", verbosity);
640 
641  close_tag.set_name("/Array");
642  close_tag.write_to_stream(os_xml);
643 
644  os_xml << '\n';
645 }
646 
647 //=== ArrayOfArrayOfArrayOfGridPos =====================================
648 
650 
655 void xml_read_from_stream(istream& is_xml,
656  ArrayOfArrayOfArrayOfGridPos& aaagpos,
657  bifstream* pbifs,
658  const Verbosity& verbosity) {
659  ArtsXMLTag tag(verbosity);
660  Index nelem;
661 
662  tag.read_from_stream(is_xml);
663  tag.check_name("Array");
664  tag.check_attribute("type", "ArrayOfArrayOfGridPos");
665 
666  tag.get_attribute_value("nelem", nelem);
667  aaagpos.resize(nelem);
668 
669  Index n;
670  try {
671  for (n = 0; n < nelem; n++)
672  xml_read_from_stream(is_xml, aaagpos[n], pbifs, verbosity);
673  } catch (const std::runtime_error& e) {
674  ostringstream os;
675  os << "Error reading ArrayOfArrayOfArrayOfGridPos: "
676  << "\n Element: " << n << "\n"
677  << e.what();
678  throw runtime_error(os.str());
679  }
680 
681  tag.read_from_stream(is_xml);
682  tag.check_name("/Array");
683 }
684 
686 
692 void xml_write_to_stream(ostream& os_xml,
693  const ArrayOfArrayOfArrayOfGridPos& aaagpos,
694  bofstream* pbofs,
695  const String& name,
696  const Verbosity& verbosity) {
697  ArtsXMLTag open_tag(verbosity);
698  ArtsXMLTag close_tag(verbosity);
699 
700  open_tag.set_name("Array");
701  if (name.length()) open_tag.add_attribute("name", name);
702 
703  open_tag.add_attribute("type", "ArrayOfArrayOfGridPos");
704  open_tag.add_attribute("nelem", aaagpos.nelem());
705 
706  open_tag.write_to_stream(os_xml);
707  os_xml << '\n';
708 
709  for (Index n = 0; n < aaagpos.nelem(); n++)
710  xml_write_to_stream(os_xml, aaagpos[n], pbofs, "", verbosity);
711 
712  close_tag.set_name("/Array");
713  close_tag.write_to_stream(os_xml);
714 
715  os_xml << '\n';
716 }
717 
718 //=== ArrayOfArrayOfArrayOfArrayOfGridPos =====================================
719 
721 
726 void xml_read_from_stream(istream& is_xml,
727  ArrayOfArrayOfArrayOfArrayOfGridPos& aaaagpos,
728  bifstream* pbifs,
729  const Verbosity& verbosity) {
730  ArtsXMLTag tag(verbosity);
731  Index nelem;
732 
733  tag.read_from_stream(is_xml);
734  tag.check_name("Array");
735  tag.check_attribute("type", "ArrayOfArrayOfArrayOfGridPos");
736 
737  tag.get_attribute_value("nelem", nelem);
738  aaaagpos.resize(nelem);
739 
740  Index n;
741  try {
742  for (n = 0; n < nelem; n++)
743  xml_read_from_stream(is_xml, aaaagpos[n], pbifs, verbosity);
744  } catch (const std::runtime_error& e) {
745  ostringstream os;
746  os << "Error reading ArrayOfArrayOfArrayOfArrayOfGridPos: "
747  << "\n Element: " << n << "\n"
748  << e.what();
749  throw runtime_error(os.str());
750  }
751 
752  tag.read_from_stream(is_xml);
753  tag.check_name("/Array");
754 }
755 
757 
763 void xml_write_to_stream(ostream& os_xml,
764  const ArrayOfArrayOfArrayOfArrayOfGridPos& aaaagpos,
765  bofstream* pbofs,
766  const String& name,
767  const Verbosity& verbosity) {
768  ArtsXMLTag open_tag(verbosity);
769  ArtsXMLTag close_tag(verbosity);
770 
771  open_tag.set_name("Array");
772  if (name.length()) open_tag.add_attribute("name", name);
773 
774  open_tag.add_attribute("type", "ArrayOfArrayOfArrayOfGridPos");
775  open_tag.add_attribute("nelem", aaaagpos.nelem());
776 
777  open_tag.write_to_stream(os_xml);
778  os_xml << '\n';
779 
780  for (Index n = 0; n < aaaagpos.nelem(); n++)
781  xml_write_to_stream(os_xml, aaaagpos[n], pbofs, "", verbosity);
782 
783  close_tag.set_name("/Array");
784  close_tag.write_to_stream(os_xml);
785 
786  os_xml << '\n';
787 }
788 
789 //=== ArrayOfIndex ===========================================================
790 
792 
797 void xml_read_from_stream(istream& is_xml,
798  ArrayOfIndex& aindex,
799  bifstream* pbifs,
800  const Verbosity& verbosity) {
801  ArtsXMLTag tag(verbosity);
802  Index nelem;
803 
804  tag.read_from_stream(is_xml);
805  tag.check_name("Array");
806  tag.check_attribute("type", "Index");
807 
808  tag.get_attribute_value("nelem", nelem);
809  aindex.resize(nelem);
810 
811  Index n;
812  try {
813  for (n = 0; n < nelem; n++)
814  xml_read_from_stream(is_xml, aindex[n], pbifs, verbosity);
815  } catch (const std::runtime_error& e) {
816  ostringstream os;
817  os << "Error reading ArrayOfIndex: "
818  << "\n Element: " << n << "\n"
819  << e.what();
820  throw runtime_error(os.str());
821  }
822 
823  tag.read_from_stream(is_xml);
824  tag.check_name("/Array");
825 }
826 
828 
834 void xml_write_to_stream(ostream& os_xml,
835  const ArrayOfIndex& aindex,
836  bofstream* pbofs,
837  const String& name,
838  const Verbosity& verbosity) {
839  ArtsXMLTag open_tag(verbosity);
840  ArtsXMLTag close_tag(verbosity);
841 
842  open_tag.set_name("Array");
843  if (name.length()) open_tag.add_attribute("name", name);
844 
845  open_tag.add_attribute("type", "Index");
846  open_tag.add_attribute("nelem", aindex.nelem());
847 
848  open_tag.write_to_stream(os_xml);
849  os_xml << '\n';
850 
851  for (Index n = 0; n < aindex.nelem(); n++)
852  xml_write_to_stream(os_xml, aindex[n], pbofs, "", verbosity);
853 
854  close_tag.set_name("/Array");
855  close_tag.write_to_stream(os_xml);
856 
857  os_xml << '\n';
858 }
859 
860 //=== ArrayOfArrayOfIndex =====================================================
861 
863 
868 void xml_read_from_stream(istream& is_xml,
869  ArrayOfArrayOfIndex& aaindex,
870  bifstream* pbifs,
871  const Verbosity& verbosity) {
872  ArtsXMLTag tag(verbosity);
873  Index nelem;
874 
875  tag.read_from_stream(is_xml);
876  tag.check_name("Array");
877  tag.check_attribute("type", "ArrayOfIndex");
878 
879  tag.get_attribute_value("nelem", nelem);
880  aaindex.resize(nelem);
881 
882  Index n;
883  try {
884  for (n = 0; n < nelem; n++)
885  xml_read_from_stream(is_xml, aaindex[n], pbifs, verbosity);
886  } catch (const std::runtime_error& e) {
887  ostringstream os;
888  os << "Error reading ArrayOfArrayOfIndex: "
889  << "\n Element: " << n << "\n"
890  << e.what();
891  throw runtime_error(os.str());
892  }
893 
894  tag.read_from_stream(is_xml);
895  tag.check_name("/Array");
896 }
897 
899 
905 void xml_write_to_stream(ostream& os_xml,
906  const ArrayOfArrayOfIndex& aaindex,
907  bofstream* pbofs,
908  const String& name,
909  const Verbosity& verbosity) {
910  ArtsXMLTag open_tag(verbosity);
911  ArtsXMLTag close_tag(verbosity);
912 
913  open_tag.set_name("Array");
914  if (name.length()) open_tag.add_attribute("name", name);
915 
916  open_tag.add_attribute("type", "ArrayOfIndex");
917  open_tag.add_attribute("nelem", aaindex.nelem());
918 
919  open_tag.write_to_stream(os_xml);
920  os_xml << '\n';
921 
922  for (Index n = 0; n < aaindex.nelem(); n++)
923  xml_write_to_stream(os_xml, aaindex[n], pbofs, "", verbosity);
924 
925  close_tag.set_name("/Array");
926  close_tag.write_to_stream(os_xml);
927 
928  os_xml << '\n';
929 }
930 
931 //=== ArrayOfCIARecord ===========================================
932 
934 
939 void xml_read_from_stream(istream& is_xml,
940  ArrayOfCIARecord& acr,
941  bifstream* pbifs,
942  const Verbosity& verbosity) {
943  ArtsXMLTag tag(verbosity);
944  Index nelem;
945 
946  tag.read_from_stream(is_xml);
947  tag.check_name("Array");
948  tag.check_attribute("type", "CIARecord");
949 
950  tag.get_attribute_value("nelem", nelem);
951  acr.resize(nelem);
952 
953  Index n;
954  try {
955  for (n = 0; n < nelem; n++)
956  xml_read_from_stream(is_xml, acr[n], pbifs, verbosity);
957  } catch (const std::runtime_error& e) {
958  ostringstream os;
959  os << "Error reading ArrayOfCIARecord: "
960  << "\n Element: " << n << "\n"
961  << e.what();
962  throw runtime_error(os.str());
963  }
964 
965  tag.read_from_stream(is_xml);
966  tag.check_name("/Array");
967 }
968 
970 
976 void xml_write_to_stream(ostream& os_xml,
977  const ArrayOfCIARecord& acr,
978  bofstream* pbofs,
979  const String& name,
980  const Verbosity& verbosity)
981 
982 {
983  ArtsXMLTag open_tag(verbosity);
984  ArtsXMLTag close_tag(verbosity);
985 
986  open_tag.set_name("Array");
987  if (name.length()) open_tag.add_attribute("name", name);
988 
989  open_tag.add_attribute("type", "CIARecord");
990  open_tag.add_attribute("nelem", acr.nelem());
991 
992  open_tag.write_to_stream(os_xml);
993  os_xml << '\n';
994 
995  for (Index n = 0; n < acr.nelem(); n++)
996  xml_write_to_stream(os_xml, acr[n], pbofs, "", verbosity);
997 
998  close_tag.set_name("/Array");
999  close_tag.write_to_stream(os_xml);
1000 
1001  os_xml << '\n';
1002 }
1003 
1004 //=== ArrayOfIsotopologueRecord ===================================================
1005 
1007 
1012 void xml_read_from_stream(istream& is_xml,
1013  Array<IsotopologueRecord>& airecord,
1014  bifstream* pbifs,
1015  const Verbosity& verbosity) {
1016  ArtsXMLTag tag(verbosity);
1017  Index nelem;
1018 
1019  tag.read_from_stream(is_xml);
1020  tag.check_name("Array");
1021  tag.check_attribute("type", "IsotopologueRecord");
1022 
1023  tag.get_attribute_value("nelem", nelem);
1024  airecord.resize(nelem);
1025 
1026  Index n;
1027  try {
1028  for (n = 0; n < nelem; n++)
1029  xml_read_from_stream(is_xml, airecord[n], pbifs, verbosity);
1030  } catch (const std::runtime_error& e) {
1031  ostringstream os;
1032  os << "Error reading ArrayOfIsotopologueRecord: "
1033  << "\n Element: " << n << "\n"
1034  << e.what();
1035  throw runtime_error(os.str());
1036  }
1037 
1038  tag.read_from_stream(is_xml);
1039  tag.check_name("/Array");
1040 }
1041 
1043 
1049 void xml_write_to_stream(ostream& os_xml,
1050  const Array<IsotopologueRecord>& airecord,
1051  bofstream* pbofs,
1052  const String& name,
1053  const Verbosity& verbosity) {
1054  ArtsXMLTag open_tag(verbosity);
1055  ArtsXMLTag close_tag(verbosity);
1056 
1057  open_tag.set_name("Array");
1058  if (name.length()) open_tag.add_attribute("name", name);
1059 
1060  open_tag.add_attribute("type", "IsotopologueRecord");
1061  open_tag.add_attribute("nelem", airecord.nelem());
1062 
1063  open_tag.write_to_stream(os_xml);
1064  os_xml << '\n';
1065 
1066  for (Index n = 0; n < airecord.nelem(); n++)
1067  xml_write_to_stream(os_xml, airecord[n], pbofs, "", verbosity);
1068 
1069  close_tag.set_name("/Array");
1070  close_tag.write_to_stream(os_xml);
1071 
1072  os_xml << '\n';
1073 }
1074 
1075 //=== ArrayOfMatrix ==========================================================
1076 
1078 
1083 void xml_read_from_stream(istream& is_xml,
1084  ArrayOfMatrix& amatrix,
1085  bifstream* pbifs,
1086  const Verbosity& verbosity) {
1087  ArtsXMLTag tag(verbosity);
1088  Index nelem;
1089 
1090  tag.read_from_stream(is_xml);
1091  tag.check_name("Array");
1092  tag.check_attribute("type", "Matrix");
1093 
1094  tag.get_attribute_value("nelem", nelem);
1095  amatrix.resize(nelem);
1096 
1097  Index n;
1098  try {
1099  for (n = 0; n < nelem; n++)
1100  xml_read_from_stream(is_xml, amatrix[n], pbifs, verbosity);
1101  } catch (const std::runtime_error& e) {
1102  ostringstream os;
1103  os << "Error reading ArrayOfMatrix: "
1104  << "\n Element: " << n << "\n"
1105  << e.what();
1106  throw runtime_error(os.str());
1107  }
1108 
1109  tag.read_from_stream(is_xml);
1110  tag.check_name("/Array");
1111 }
1112 
1114 
1120 void xml_write_to_stream(ostream& os_xml,
1121  const ArrayOfMatrix& amatrix,
1122  bofstream* pbofs,
1123  const String& name,
1124  const Verbosity& verbosity) {
1125  ArtsXMLTag open_tag(verbosity);
1126  ArtsXMLTag close_tag(verbosity);
1127 
1128  open_tag.set_name("Array");
1129  if (name.length()) open_tag.add_attribute("name", name);
1130 
1131  open_tag.add_attribute("type", "Matrix");
1132  open_tag.add_attribute("nelem", amatrix.nelem());
1133 
1134  open_tag.write_to_stream(os_xml);
1135  os_xml << '\n';
1136 
1137  for (Index n = 0; n < amatrix.nelem(); n++)
1138  xml_write_to_stream(os_xml, amatrix[n], pbofs, "", verbosity);
1139 
1140  close_tag.set_name("/Array");
1141  close_tag.write_to_stream(os_xml);
1142 
1143  os_xml << '\n';
1144 }
1145 
1146 //=== ArrayOfArrayOfMatrix====================================================
1147 
1149 
1154 void xml_read_from_stream(istream& is_xml,
1155  ArrayOfArrayOfMatrix& aamatrix,
1156  bifstream* pbifs,
1157  const Verbosity& verbosity) {
1158  ArtsXMLTag tag(verbosity);
1159  Index nelem;
1160 
1161  tag.read_from_stream(is_xml);
1162  tag.check_name("Array");
1163  tag.check_attribute("type", "ArrayOfMatrix");
1164 
1165  tag.get_attribute_value("nelem", nelem);
1166  aamatrix.resize(nelem);
1167 
1168  Index n;
1169  try {
1170  for (n = 0; n < nelem; n++)
1171  xml_read_from_stream(is_xml, aamatrix[n], pbifs, verbosity);
1172  } catch (const std::runtime_error& e) {
1173  ostringstream os;
1174  os << "Error reading ArrayOfArrayOfMatrix: "
1175  << "\n Element: " << n << "\n"
1176  << e.what();
1177  throw runtime_error(os.str());
1178  }
1179 
1180  tag.read_from_stream(is_xml);
1181  tag.check_name("/Array");
1182 }
1183 
1185 
1191 void xml_write_to_stream(ostream& os_xml,
1192  const ArrayOfArrayOfMatrix& aamatrix,
1193  bofstream* pbofs,
1194  const String& name,
1195  const Verbosity& verbosity) {
1196  ArtsXMLTag open_tag(verbosity);
1197  ArtsXMLTag close_tag(verbosity);
1198 
1199  open_tag.set_name("Array");
1200  if (name.length()) open_tag.add_attribute("name", name);
1201 
1202  open_tag.add_attribute("type", "ArrayOfMatrix");
1203  open_tag.add_attribute("nelem", aamatrix.nelem());
1204 
1205  open_tag.write_to_stream(os_xml);
1206  os_xml << '\n';
1207 
1208  for (Index n = 0; n < aamatrix.nelem(); n++)
1209  xml_write_to_stream(os_xml, aamatrix[n], pbofs, "", verbosity);
1210 
1211  close_tag.set_name("/Array");
1212  close_tag.write_to_stream(os_xml);
1213 
1214  os_xml << '\n';
1215 }
1216 
1217 //=== ArrayOfArrayOfVector====================================================
1218 
1220 
1225 void xml_read_from_stream(istream& is_xml,
1226  ArrayOfArrayOfVector& aavector,
1227  bifstream* pbifs,
1228  const Verbosity& verbosity) {
1229  ArtsXMLTag tag(verbosity);
1230  Index nelem;
1231 
1232  tag.read_from_stream(is_xml);
1233  tag.check_name("Array");
1234  tag.check_attribute("type", "ArrayOfVector");
1235 
1236  tag.get_attribute_value("nelem", nelem);
1237  aavector.resize(nelem);
1238 
1239  Index n;
1240  try {
1241  for (n = 0; n < nelem; n++)
1242  xml_read_from_stream(is_xml, aavector[n], pbifs, verbosity);
1243  } catch (const std::runtime_error& e) {
1244  ostringstream os;
1245  os << "Error reading ArrayOfArrayOfVector: "
1246  << "\n Element: " << n << "\n"
1247  << e.what();
1248  throw runtime_error(os.str());
1249  }
1250 
1251  tag.read_from_stream(is_xml);
1252  tag.check_name("/Array");
1253 }
1254 
1256 
1262 void xml_write_to_stream(ostream& os_xml,
1263  const ArrayOfArrayOfVector& aaVector,
1264  bofstream* pbofs,
1265  const String& name,
1266  const Verbosity& verbosity) {
1267  ArtsXMLTag open_tag(verbosity);
1268  ArtsXMLTag close_tag(verbosity);
1269 
1270  open_tag.set_name("Array");
1271  if (name.length()) open_tag.add_attribute("name", name);
1272 
1273  open_tag.add_attribute("type", "ArrayOfVector");
1274  open_tag.add_attribute("nelem", aaVector.nelem());
1275 
1276  open_tag.write_to_stream(os_xml);
1277  os_xml << '\n';
1278 
1279  for (Index n = 0; n < aaVector.nelem(); n++)
1280  xml_write_to_stream(os_xml, aaVector[n], pbofs, "", verbosity);
1281 
1282  close_tag.set_name("/Array");
1283  close_tag.write_to_stream(os_xml);
1284 
1285  os_xml << '\n';
1286 }
1287 
1288 //=== ArrayOfSparse ==========================================================
1289 
1291 
1296 void xml_read_from_stream(istream& is_xml,
1297  ArrayOfSparse& asparse,
1298  bifstream* pbifs,
1299  const Verbosity& verbosity) {
1300  ArtsXMLTag tag(verbosity);
1301  Index nelem;
1302 
1303  tag.read_from_stream(is_xml);
1304  tag.check_name("Array");
1305  tag.check_attribute("type", "Sparse");
1306 
1307  tag.get_attribute_value("nelem", nelem);
1308  asparse.resize(nelem);
1309 
1310  Index n;
1311  try {
1312  for (n = 0; n < nelem; n++)
1313  xml_read_from_stream(is_xml, asparse[n], pbifs, verbosity);
1314  } catch (const std::runtime_error& e) {
1315  ostringstream os;
1316  os << "Error reading ArrayOfSparse: "
1317  << "\n Element: " << n << "\n"
1318  << e.what();
1319  throw runtime_error(os.str());
1320  }
1321 
1322  tag.read_from_stream(is_xml);
1323  tag.check_name("/Array");
1324 }
1325 
1327 
1333 void xml_write_to_stream(ostream& os_xml,
1334  const ArrayOfSparse& asparse,
1335  bofstream* pbofs,
1336  const String& name,
1337  const Verbosity& verbosity) {
1338  ArtsXMLTag open_tag(verbosity);
1339  ArtsXMLTag close_tag(verbosity);
1340 
1341  open_tag.set_name("Array");
1342  if (name.length()) open_tag.add_attribute("name", name);
1343 
1344  open_tag.add_attribute("type", "Sparse");
1345  open_tag.add_attribute("nelem", asparse.nelem());
1346 
1347  open_tag.write_to_stream(os_xml);
1348  os_xml << '\n';
1349 
1350  for (Index n = 0; n < asparse.nelem(); n++)
1351  xml_write_to_stream(os_xml, asparse[n], pbofs, "", verbosity);
1352 
1353  close_tag.set_name("/Array");
1354  close_tag.write_to_stream(os_xml);
1355 
1356  os_xml << '\n';
1357 }
1358 
1359 //=== ArrayOfQuantumIdentifier ================================================
1360 
1362 
1367 void xml_read_from_stream(istream& is_xml,
1368  ArrayOfQuantumIdentifier& aqtag,
1369  bifstream* pbifs,
1370  const Verbosity& verbosity) {
1371  ArtsXMLTag tag(verbosity);
1372  Index nelem;
1373 
1374  tag.read_from_stream(is_xml);
1375  tag.check_name("Array");
1376  tag.check_attribute("type", "QuantumIdentifier");
1377 
1378  tag.get_attribute_value("nelem", nelem);
1379  aqtag.resize(nelem);
1380 
1381  Index n;
1382  try {
1383  for (n = 0; n < nelem; n++) {
1384  aqtag[n] = QuantumIdentifier();
1385  xml_read_from_stream(is_xml, aqtag[n], pbifs, verbosity);
1386  }
1387  } catch (const std::runtime_error& e) {
1388  ostringstream os;
1389  os << "Error reading ArrayOfQuantumIdentifier: "
1390  << "\n Element: " << n << "\n"
1391  << e.what();
1392  throw runtime_error(os.str());
1393  }
1394 
1395  tag.read_from_stream(is_xml);
1396  tag.check_name("/Array");
1397 }
1398 
1400 
1406 void xml_write_to_stream(ostream& os_xml,
1407  const ArrayOfQuantumIdentifier& aqtag,
1408  bofstream* pbofs,
1409  const String& name,
1410  const Verbosity& verbosity) {
1411  ArtsXMLTag open_tag(verbosity);
1412  ArtsXMLTag close_tag(verbosity);
1413 
1414  open_tag.set_name("Array");
1415  if (name.length()) open_tag.add_attribute("name", name);
1416 
1417  open_tag.add_attribute("type", "QuantumIdentifier");
1418  open_tag.add_attribute("nelem", aqtag.nelem());
1419 
1420  open_tag.write_to_stream(os_xml);
1421  os_xml << '\n';
1422 
1423  for (Index n = 0; n < aqtag.nelem(); n++)
1424  xml_write_to_stream(os_xml, aqtag[n], pbofs, "", verbosity);
1425 
1426  close_tag.set_name("/Array");
1427  close_tag.write_to_stream(os_xml);
1428 
1429  os_xml << '\n';
1430 }
1431 
1432 //=== ArrayOfRetrievalQuantity =======================================
1433 
1435 
1440 void xml_read_from_stream(istream& is_xml,
1441  ArrayOfRetrievalQuantity& arq,
1442  bifstream* pbifs,
1443  const Verbosity& verbosity) {
1444  ArtsXMLTag tag(verbosity);
1445  Index nelem;
1446 
1447  tag.read_from_stream(is_xml);
1448  tag.check_name("Array");
1449  tag.check_attribute("type", "RetrievalQuantity");
1450 
1451  tag.get_attribute_value("nelem", nelem);
1452  arq.resize(nelem);
1453 
1454  Index n;
1455  try {
1456  for (n = 0; n < nelem; n++)
1457  xml_read_from_stream(is_xml, arq[n], pbifs, verbosity);
1458  } catch (const std::runtime_error& e) {
1459  ostringstream os;
1460  os << "Error reading ArrayOfRetrievalQuantity: "
1461  << "\n Element: " << n << "\n"
1462  << e.what();
1463  throw runtime_error(os.str());
1464  }
1465 
1466  tag.read_from_stream(is_xml);
1467  tag.check_name("/Array");
1468 }
1469 
1471 
1477 void xml_write_to_stream(ostream& os_xml,
1478  const ArrayOfRetrievalQuantity& arq,
1479  bofstream* pbofs,
1480  const String& name,
1481  const Verbosity& verbosity) {
1482  ArtsXMLTag open_tag(verbosity);
1483  ArtsXMLTag close_tag(verbosity);
1484 
1485  open_tag.set_name("Array");
1486  if (name.length()) open_tag.add_attribute("name", name);
1487 
1488  open_tag.add_attribute("type", "RetrievalQuantity");
1489  open_tag.add_attribute("nelem", arq.nelem());
1490 
1491  open_tag.write_to_stream(os_xml);
1492  os_xml << '\n';
1493 
1494  for (Index n = 0; n < arq.nelem(); n++)
1495  xml_write_to_stream(os_xml, arq[n], pbofs, "", verbosity);
1496 
1497  close_tag.set_name("/Array");
1498  close_tag.write_to_stream(os_xml);
1499 
1500  os_xml << '\n';
1501 }
1502 
1503 //=== ArrayOfSpeciesTag ================================================
1504 
1506 
1511 void xml_read_from_stream(istream& is_xml,
1512  ArrayOfSpeciesTag& astag,
1513  bifstream* pbifs,
1514  const Verbosity& verbosity) {
1515  ArtsXMLTag tag(verbosity);
1516  Index nelem;
1517 
1518  tag.read_from_stream(is_xml);
1519  tag.check_name("Array");
1520  tag.check_attribute("type", "SpeciesTag");
1521 
1522  tag.get_attribute_value("nelem", nelem);
1523  astag.resize(nelem);
1524 
1525  Index n;
1526  try {
1527  for (n = 0; n < nelem; n++)
1528  xml_read_from_stream(is_xml, astag[n], pbifs, verbosity);
1529  } catch (const std::runtime_error& e) {
1530  ostringstream os;
1531  os << "Error reading ArrayOfSpeciesTag: "
1532  << "\n Element: " << n << "\n"
1533  << e.what();
1534  throw runtime_error(os.str());
1535  }
1536 
1537  tag.read_from_stream(is_xml);
1538  tag.check_name("/Array");
1539 }
1540 
1542 
1548 void xml_write_to_stream(ostream& os_xml,
1549  const ArrayOfSpeciesTag& astag,
1550  bofstream* pbofs,
1551  const String& name,
1552  const Verbosity& verbosity) {
1553  ArtsXMLTag open_tag(verbosity);
1554  ArtsXMLTag close_tag(verbosity);
1555 
1556  open_tag.set_name("Array");
1557  if (name.length()) open_tag.add_attribute("name", name);
1558 
1559  open_tag.add_attribute("type", "SpeciesTag");
1560  open_tag.add_attribute("nelem", astag.nelem());
1561 
1562  open_tag.write_to_stream(os_xml);
1563  os_xml << '\n';
1564 
1565  for (Index n = 0; n < astag.nelem(); n++)
1566  xml_write_to_stream(os_xml, astag[n], pbofs, "", verbosity);
1567 
1568  close_tag.set_name("/Array");
1569  close_tag.write_to_stream(os_xml);
1570 
1571  os_xml << '\n';
1572 }
1573 
1574 //=== ArrayOfSingleScatteringData===========================================
1575 
1577 
1582 void xml_read_from_stream(istream& is_xml,
1583  ArrayOfSingleScatteringData& assdata,
1584  bifstream* pbifs,
1585  const Verbosity& verbosity) {
1586  ArtsXMLTag tag(verbosity);
1587  Index nelem;
1588 
1589  tag.read_from_stream(is_xml);
1590  tag.check_name("Array");
1591  tag.check_attribute("type", "SingleScatteringData");
1592 
1593  tag.get_attribute_value("nelem", nelem);
1594  assdata.resize(nelem);
1595 
1596  Index n;
1597  try {
1598  for (n = 0; n < nelem; n++)
1599  xml_read_from_stream(is_xml, assdata[n], pbifs, verbosity);
1600  } catch (const std::runtime_error& e) {
1601  ostringstream os;
1602  os << "Error reading ArrayOfSingleScatteringData: "
1603  << "\n Element: " << n << "\n"
1604  << e.what();
1605  throw runtime_error(os.str());
1606  }
1607 
1608  tag.read_from_stream(is_xml);
1609  tag.check_name("/Array");
1610 }
1611 
1613 
1619 void xml_write_to_stream(ostream& os_xml,
1620  const ArrayOfSingleScatteringData& assdata,
1621  bofstream* pbofs,
1622  const String& name,
1623  const Verbosity& verbosity) {
1624  ArtsXMLTag open_tag(verbosity);
1625  ArtsXMLTag close_tag(verbosity);
1626 
1627  open_tag.set_name("Array");
1628  if (name.length()) open_tag.add_attribute("name", name);
1629 
1630  open_tag.add_attribute("type", "SingleScatteringData");
1631  open_tag.add_attribute("nelem", assdata.nelem());
1632 
1633  open_tag.write_to_stream(os_xml);
1634  os_xml << '\n';
1635 
1636  for (Index n = 0; n < assdata.nelem(); n++)
1637  xml_write_to_stream(os_xml, assdata[n], pbofs, "", verbosity);
1638 
1639  close_tag.set_name("/Array");
1640  close_tag.write_to_stream(os_xml);
1641 
1642  os_xml << '\n';
1643 }
1644 
1645 //=== ArrayOfArrayOfSingleScatteringData===========================================
1646 
1648 
1653 void xml_read_from_stream(istream& is_xml,
1654  ArrayOfArrayOfSingleScatteringData& assdata,
1655  bifstream* pbifs,
1656  const Verbosity& verbosity) {
1657  ArtsXMLTag tag(verbosity);
1658  Index nelem;
1659 
1660  tag.read_from_stream(is_xml);
1661  tag.check_name("Array");
1662  tag.check_attribute("type", "ArrayOfSingleScatteringData");
1663 
1664  tag.get_attribute_value("nelem", nelem);
1665  assdata.resize(nelem);
1666 
1667  Index n;
1668  try {
1669  for (n = 0; n < nelem; n++)
1670  xml_read_from_stream(is_xml, assdata[n], pbifs, verbosity);
1671  } catch (const std::runtime_error& e) {
1672  ostringstream os;
1673  os << "Error reading ArrayOfArrayOfSingleScatteringData: "
1674  << "\n Element: " << n << "\n"
1675  << e.what();
1676  throw runtime_error(os.str());
1677  }
1678 
1679  tag.read_from_stream(is_xml);
1680  tag.check_name("/Array");
1681 }
1682 
1684 
1690 void xml_write_to_stream(ostream& os_xml,
1691  const ArrayOfArrayOfSingleScatteringData& assdata,
1692  bofstream* pbofs,
1693  const String& name,
1694  const Verbosity& verbosity) {
1695  ArtsXMLTag open_tag(verbosity);
1696  ArtsXMLTag close_tag(verbosity);
1697 
1698  open_tag.set_name("Array");
1699  if (name.length()) open_tag.add_attribute("name", name);
1700 
1701  open_tag.add_attribute("type", "ArrayOfSingleScatteringData");
1702  open_tag.add_attribute("nelem", assdata.nelem());
1703 
1704  open_tag.write_to_stream(os_xml);
1705  os_xml << '\n';
1706 
1707  for (Index n = 0; n < assdata.nelem(); n++)
1708  xml_write_to_stream(os_xml, assdata[n], pbofs, "", verbosity);
1709 
1710  close_tag.set_name("/Array");
1711  close_tag.write_to_stream(os_xml);
1712 
1713  os_xml << '\n';
1714 }
1715 
1716 //=== ArrayOfScatteringMetaData===========================================
1717 
1719 
1724 void xml_read_from_stream(istream& is_xml,
1725  ArrayOfScatteringMetaData& asmdata,
1726  bifstream* pbifs,
1727  const Verbosity& verbosity) {
1728  ArtsXMLTag tag(verbosity);
1729  Index nelem;
1730 
1731  tag.read_from_stream(is_xml);
1732  tag.check_name("Array");
1733  tag.check_attribute("type", "ScatteringMetaData");
1734 
1735  tag.get_attribute_value("nelem", nelem);
1736  asmdata.resize(nelem);
1737 
1738  Index n;
1739  try {
1740  for (n = 0; n < nelem; n++)
1741  xml_read_from_stream(is_xml, asmdata[n], pbifs, verbosity);
1742  } catch (const std::runtime_error& e) {
1743  ostringstream os;
1744  os << "Error reading ArrayOfScatteringMetaData: "
1745  << "\n Element: " << n << "\n"
1746  << e.what();
1747  throw runtime_error(os.str());
1748  }
1749 
1750  tag.read_from_stream(is_xml);
1751  tag.check_name("/Array");
1752 }
1753 
1755 
1761 void xml_write_to_stream(ostream& os_xml,
1762  const ArrayOfScatteringMetaData& asmdata,
1763  bofstream* pbofs,
1764  const String& name,
1765  const Verbosity& verbosity) {
1766  ArtsXMLTag open_tag(verbosity);
1767  ArtsXMLTag close_tag(verbosity);
1768 
1769  open_tag.set_name("Array");
1770  if (name.length()) open_tag.add_attribute("name", name);
1771 
1772  open_tag.add_attribute("type", "ScatteringMetaData");
1773  open_tag.add_attribute("nelem", asmdata.nelem());
1774 
1775  open_tag.write_to_stream(os_xml);
1776  os_xml << '\n';
1777 
1778  for (Index n = 0; n < asmdata.nelem(); n++)
1779  xml_write_to_stream(os_xml, asmdata[n], pbofs, "", verbosity);
1780 
1781  close_tag.set_name("/Array");
1782  close_tag.write_to_stream(os_xml);
1783 
1784  os_xml << '\n';
1785 }
1786 
1787 //=== ArrayOfArrayOfScatteringMetaData===========================================
1788 
1790 
1795 void xml_read_from_stream(istream& is_xml,
1796  ArrayOfArrayOfScatteringMetaData& asmdata,
1797  bifstream* pbifs,
1798  const Verbosity& verbosity) {
1799  ArtsXMLTag tag(verbosity);
1800  Index nelem;
1801 
1802  tag.read_from_stream(is_xml);
1803  tag.check_name("Array");
1804  tag.check_attribute("type", "ArrayOfScatteringMetaData");
1805 
1806  tag.get_attribute_value("nelem", nelem);
1807  asmdata.resize(nelem);
1808 
1809  Index n;
1810  try {
1811  for (n = 0; n < nelem; n++)
1812  xml_read_from_stream(is_xml, asmdata[n], pbifs, verbosity);
1813  } catch (const std::runtime_error& e) {
1814  ostringstream os;
1815  os << "Error reading ArrayOfArrayOfScatteringMetaData: "
1816  << "\n Element: " << n << "\n"
1817  << e.what();
1818  throw runtime_error(os.str());
1819  }
1820 
1821  tag.read_from_stream(is_xml);
1822  tag.check_name("/Array");
1823 }
1824 
1826 
1832 void xml_write_to_stream(ostream& os_xml,
1833  const ArrayOfArrayOfScatteringMetaData& asmdata,
1834  bofstream* pbofs,
1835  const String& name,
1836  const Verbosity& verbosity) {
1837  ArtsXMLTag open_tag(verbosity);
1838  ArtsXMLTag close_tag(verbosity);
1839 
1840  open_tag.set_name("Array");
1841  if (name.length()) open_tag.add_attribute("name", name);
1842 
1843  open_tag.add_attribute("type", "ArrayOfScatteringMetaData");
1844  open_tag.add_attribute("nelem", asmdata.nelem());
1845 
1846  open_tag.write_to_stream(os_xml);
1847  os_xml << '\n';
1848 
1849  for (Index n = 0; n < asmdata.nelem(); n++)
1850  xml_write_to_stream(os_xml, asmdata[n], pbofs, "", verbosity);
1851 
1852  close_tag.set_name("/Array");
1853  close_tag.write_to_stream(os_xml);
1854 
1855  os_xml << '\n';
1856 }
1857 
1858 //=== ArrayOfGriddedField1 ===========================================
1859 
1861 
1866 void xml_read_from_stream(istream& is_xml,
1867  ArrayOfGriddedField1& agfield,
1868  bifstream* pbifs,
1869  const Verbosity& verbosity) {
1870  ArtsXMLTag tag(verbosity);
1871  Index nelem;
1872 
1873  tag.read_from_stream(is_xml);
1874  tag.check_name("Array");
1875  tag.check_attribute("type", "GriddedField1");
1876 
1877  tag.get_attribute_value("nelem", nelem);
1878  agfield.resize(nelem);
1879 
1880  Index n;
1881  try {
1882  for (n = 0; n < nelem; n++)
1883  xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
1884  } catch (const std::runtime_error& e) {
1885  ostringstream os;
1886  os << "Error reading ArrayOfGriddedField1: "
1887  << "\n Element: " << n << "\n"
1888  << e.what();
1889  throw runtime_error(os.str());
1890  }
1891 
1892  tag.read_from_stream(is_xml);
1893  tag.check_name("/Array");
1894 }
1895 
1897 
1903 void xml_write_to_stream(ostream& os_xml,
1904  const ArrayOfGriddedField1& agfield,
1905  bofstream* pbofs,
1906  const String& name,
1907  const Verbosity& verbosity) {
1908  ArtsXMLTag open_tag(verbosity);
1909  ArtsXMLTag close_tag(verbosity);
1910 
1911  open_tag.set_name("Array");
1912  if (name.length()) open_tag.add_attribute("name", name);
1913 
1914  open_tag.add_attribute("type", "GriddedField1");
1915  open_tag.add_attribute("nelem", agfield.nelem());
1916 
1917  open_tag.write_to_stream(os_xml);
1918  os_xml << '\n';
1919 
1920  for (Index n = 0; n < agfield.nelem(); n++)
1921  xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
1922 
1923  close_tag.set_name("/Array");
1924  close_tag.write_to_stream(os_xml);
1925 
1926  os_xml << '\n';
1927 }
1928 
1929 //=== ArrayOfGriddedField2 ===========================================
1930 
1932 
1937 void xml_read_from_stream(istream& is_xml,
1938  ArrayOfGriddedField2& agfield,
1939  bifstream* pbifs,
1940  const Verbosity& verbosity) {
1941  ArtsXMLTag tag(verbosity);
1942  Index nelem;
1943 
1944  tag.read_from_stream(is_xml);
1945  tag.check_name("Array");
1946  tag.check_attribute("type", "GriddedField2");
1947 
1948  tag.get_attribute_value("nelem", nelem);
1949  agfield.resize(nelem);
1950 
1951  Index n;
1952  try {
1953  for (n = 0; n < nelem; n++)
1954  xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
1955  } catch (const std::runtime_error& e) {
1956  ostringstream os;
1957  os << "Error reading ArrayOfGriddedField2: "
1958  << "\n Element: " << n << "\n"
1959  << e.what();
1960  throw runtime_error(os.str());
1961  }
1962 
1963  tag.read_from_stream(is_xml);
1964  tag.check_name("/Array");
1965 }
1966 
1968 
1974 void xml_write_to_stream(ostream& os_xml,
1975  const ArrayOfGriddedField2& agfield,
1976  bofstream* pbofs,
1977  const String& name,
1978  const Verbosity& verbosity) {
1979  ArtsXMLTag open_tag(verbosity);
1980  ArtsXMLTag close_tag(verbosity);
1981 
1982  open_tag.set_name("Array");
1983  if (name.length()) open_tag.add_attribute("name", name);
1984 
1985  open_tag.add_attribute("type", "GriddedField2");
1986  open_tag.add_attribute("nelem", agfield.nelem());
1987 
1988  open_tag.write_to_stream(os_xml);
1989  os_xml << '\n';
1990 
1991  for (Index n = 0; n < agfield.nelem(); n++)
1992  xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
1993 
1994  close_tag.set_name("/Array");
1995  close_tag.write_to_stream(os_xml);
1996 
1997  os_xml << '\n';
1998 }
1999 
2000 //=== ArrayOfGriddedField3 ===========================================
2001 
2003 
2008 void xml_read_from_stream(istream& is_xml,
2009  ArrayOfGriddedField3& agfield,
2010  bifstream* pbifs,
2011  const Verbosity& verbosity) {
2012  ArtsXMLTag tag(verbosity);
2013  Index nelem;
2014 
2015  tag.read_from_stream(is_xml);
2016  tag.check_name("Array");
2017  tag.check_attribute("type", "GriddedField3");
2018 
2019  tag.get_attribute_value("nelem", nelem);
2020  agfield.resize(nelem);
2021 
2022  Index n;
2023  try {
2024  for (n = 0; n < nelem; n++)
2025  xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
2026  } catch (const std::runtime_error& e) {
2027  ostringstream os;
2028  os << "Error reading ArrayOfGriddedField3: "
2029  << "\n Element: " << n << "\n"
2030  << e.what();
2031  throw runtime_error(os.str());
2032  }
2033 
2034  tag.read_from_stream(is_xml);
2035  tag.check_name("/Array");
2036 }
2037 
2039 
2045 void xml_write_to_stream(ostream& os_xml,
2046  const ArrayOfGriddedField3& agfield,
2047  bofstream* pbofs,
2048  const String& name,
2049  const Verbosity& verbosity) {
2050  ArtsXMLTag open_tag(verbosity);
2051  ArtsXMLTag close_tag(verbosity);
2052 
2053  open_tag.set_name("Array");
2054  if (name.length()) open_tag.add_attribute("name", name);
2055 
2056  open_tag.add_attribute("type", "GriddedField3");
2057  open_tag.add_attribute("nelem", agfield.nelem());
2058 
2059  open_tag.write_to_stream(os_xml);
2060  os_xml << '\n';
2061 
2062  for (Index n = 0; n < agfield.nelem(); n++)
2063  xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
2064 
2065  close_tag.set_name("/Array");
2066  close_tag.write_to_stream(os_xml);
2067 
2068  os_xml << '\n';
2069 }
2070 
2071 //=== ArrayOfArrayOfGriddedField1 ===========================================
2072 
2074 
2079 void xml_read_from_stream(istream& is_xml,
2080  ArrayOfArrayOfGriddedField1& aagfield,
2081  bifstream* pbifs,
2082  const Verbosity& verbosity) {
2083  ArtsXMLTag tag(verbosity);
2084  Index nelem;
2085 
2086  tag.read_from_stream(is_xml);
2087  tag.check_name("Array");
2088  tag.check_attribute("type", "ArrayOfGriddedField1");
2089 
2090  tag.get_attribute_value("nelem", nelem);
2091  aagfield.resize(nelem);
2092 
2093  Index n;
2094  try {
2095  for (n = 0; n < nelem; n++)
2096  xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2097  } catch (const std::runtime_error& e) {
2098  ostringstream os;
2099  os << "Error reading ArrayOfArrayOfGriddedField1: "
2100  << "\n Element: " << n << "\n"
2101  << e.what();
2102  throw runtime_error(os.str());
2103  }
2104 
2105  tag.read_from_stream(is_xml);
2106  tag.check_name("/Array");
2107 }
2108 
2110 
2116 void xml_write_to_stream(ostream& os_xml,
2117  const ArrayOfArrayOfGriddedField1& aagfield,
2118  bofstream* pbofs,
2119  const String& name,
2120  const Verbosity& verbosity) {
2121  ArtsXMLTag open_tag(verbosity);
2122  ArtsXMLTag close_tag(verbosity);
2123 
2124  open_tag.set_name("Array");
2125  if (name.length()) open_tag.add_attribute("name", name);
2126 
2127  open_tag.add_attribute("type", "ArrayGriddedField1");
2128  open_tag.add_attribute("nelem", aagfield.nelem());
2129 
2130  open_tag.write_to_stream(os_xml);
2131  os_xml << '\n';
2132 
2133  for (Index n = 0; n < aagfield.nelem(); n++)
2134  xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2135 
2136  close_tag.set_name("/Array");
2137  close_tag.write_to_stream(os_xml);
2138 
2139  os_xml << '\n';
2140 }
2141 
2142 //=== ArrayOfArrayOfGriddedField2 ===========================================
2143 
2145 
2150 void xml_read_from_stream(istream& is_xml,
2151  ArrayOfArrayOfGriddedField2& aagfield,
2152  bifstream* pbifs,
2153  const Verbosity& verbosity) {
2154  ArtsXMLTag tag(verbosity);
2155  Index nelem;
2156 
2157  tag.read_from_stream(is_xml);
2158  tag.check_name("Array");
2159  tag.check_attribute("type", "ArrayOfGriddedField2");
2160 
2161  tag.get_attribute_value("nelem", nelem);
2162  aagfield.resize(nelem);
2163 
2164  Index n;
2165  try {
2166  for (n = 0; n < nelem; n++)
2167  xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2168  } catch (const std::runtime_error& e) {
2169  ostringstream os;
2170  os << "Error reading ArrayOfArrayOfGriddedField2: "
2171  << "\n Element: " << n << "\n"
2172  << e.what();
2173  throw runtime_error(os.str());
2174  }
2175 
2176  tag.read_from_stream(is_xml);
2177  tag.check_name("/Array");
2178 }
2179 
2181 
2187 void xml_write_to_stream(ostream& os_xml,
2188  const ArrayOfArrayOfGriddedField2& aagfield,
2189  bofstream* pbofs,
2190  const String& name,
2191  const Verbosity& verbosity) {
2192  ArtsXMLTag open_tag(verbosity);
2193  ArtsXMLTag close_tag(verbosity);
2194 
2195  open_tag.set_name("Array");
2196  if (name.length()) open_tag.add_attribute("name", name);
2197 
2198  open_tag.add_attribute("type", "ArrayGriddedField2");
2199  open_tag.add_attribute("nelem", aagfield.nelem());
2200 
2201  open_tag.write_to_stream(os_xml);
2202  os_xml << '\n';
2203 
2204  for (Index n = 0; n < aagfield.nelem(); n++)
2205  xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2206 
2207  close_tag.set_name("/Array");
2208  close_tag.write_to_stream(os_xml);
2209 
2210  os_xml << '\n';
2211 }
2212 
2213 //=== ArrayOfArrayOfGriddedField3 ===========================================
2214 
2216 
2221 void xml_read_from_stream(istream& is_xml,
2222  ArrayOfArrayOfGriddedField3& aagfield,
2223  bifstream* pbifs,
2224  const Verbosity& verbosity) {
2225  ArtsXMLTag tag(verbosity);
2226  Index nelem;
2227 
2228  tag.read_from_stream(is_xml);
2229  tag.check_name("Array");
2230  tag.check_attribute("type", "ArrayOfGriddedField3");
2231 
2232  tag.get_attribute_value("nelem", nelem);
2233  aagfield.resize(nelem);
2234 
2235  Index n;
2236  try {
2237  for (n = 0; n < nelem; n++)
2238  xml_read_from_stream(is_xml, aagfield[n], pbifs, verbosity);
2239  } catch (const std::runtime_error& e) {
2240  ostringstream os;
2241  os << "Error reading ArrayOfArrayOfGriddedField3: "
2242  << "\n Element: " << n << "\n"
2243  << e.what();
2244  throw runtime_error(os.str());
2245  }
2246 
2247  tag.read_from_stream(is_xml);
2248  tag.check_name("/Array");
2249 }
2250 
2252 
2258 void xml_write_to_stream(ostream& os_xml,
2259  const ArrayOfArrayOfGriddedField3& aagfield,
2260  bofstream* pbofs,
2261  const String& name,
2262  const Verbosity& verbosity) {
2263  ArtsXMLTag open_tag(verbosity);
2264  ArtsXMLTag close_tag(verbosity);
2265 
2266  open_tag.set_name("Array");
2267  if (name.length()) open_tag.add_attribute("name", name);
2268 
2269  open_tag.add_attribute("type", "ArrayGriddedField3");
2270  open_tag.add_attribute("nelem", aagfield.nelem());
2271 
2272  open_tag.write_to_stream(os_xml);
2273  os_xml << '\n';
2274 
2275  for (Index n = 0; n < aagfield.nelem(); n++)
2276  xml_write_to_stream(os_xml, aagfield[n], pbofs, "", verbosity);
2277 
2278  close_tag.set_name("/Array");
2279  close_tag.write_to_stream(os_xml);
2280 
2281  os_xml << '\n';
2282 }
2283 
2284 //=== ArrayOfGriddedField4 ===========================================
2285 
2287 
2292 void xml_read_from_stream(istream& is_xml,
2293  ArrayOfGriddedField4& agfield,
2294  bifstream* pbifs,
2295  const Verbosity& verbosity) {
2296  ArtsXMLTag tag(verbosity);
2297  Index nelem;
2298 
2299  tag.read_from_stream(is_xml);
2300  tag.check_name("Array");
2301  tag.check_attribute("type", "GriddedField4");
2302 
2303  tag.get_attribute_value("nelem", nelem);
2304  agfield.resize(nelem);
2305 
2306  Index n;
2307  try {
2308  for (n = 0; n < nelem; n++)
2309  xml_read_from_stream(is_xml, agfield[n], pbifs, verbosity);
2310  } catch (const std::runtime_error& e) {
2311  ostringstream os;
2312  os << "Error reading ArrayOfGriddedField4: "
2313  << "\n Element: " << n << "\n"
2314  << e.what();
2315  throw runtime_error(os.str());
2316  }
2317 
2318  tag.read_from_stream(is_xml);
2319  tag.check_name("/Array");
2320 }
2321 
2323 
2329 void xml_write_to_stream(ostream& os_xml,
2330  const ArrayOfGriddedField4& agfield,
2331  bofstream* pbofs,
2332  const String& name,
2333  const Verbosity& verbosity) {
2334  ArtsXMLTag open_tag(verbosity);
2335  ArtsXMLTag close_tag(verbosity);
2336 
2337  open_tag.set_name("Array");
2338  if (name.length()) open_tag.add_attribute("name", name);
2339 
2340  open_tag.add_attribute("type", "GriddedField4");
2341  open_tag.add_attribute("nelem", agfield.nelem());
2342 
2343  open_tag.write_to_stream(os_xml);
2344  os_xml << '\n';
2345 
2346  for (Index n = 0; n < agfield.nelem(); n++)
2347  xml_write_to_stream(os_xml, agfield[n], pbofs, "", verbosity);
2348 
2349  close_tag.set_name("/Array");
2350  close_tag.write_to_stream(os_xml);
2351 
2352  os_xml << '\n';
2353 }
2354 
2355 //=== ArrayOfTelsemAtlas =========================================================
2356 
2358 
2363 void xml_read_from_stream(istream& is_xml,
2364  ArrayOfTelsemAtlas& arr_telsem,
2365  bifstream* pbifs,
2366  const Verbosity& verbosity) {
2367  ArtsXMLTag tag(verbosity);
2368  Index nelem;
2369 
2370  tag.read_from_stream(is_xml);
2371  tag.check_name("Array");
2372  tag.check_attribute("type", "TelsemAtlas");
2373 
2374  tag.get_attribute_value("nelem", nelem);
2375  arr_telsem.resize(nelem);
2376 
2377  Index n;
2378  try {
2379  for (n = 0; n < nelem; n++)
2380  xml_read_from_stream(is_xml, arr_telsem[n], pbifs, verbosity);
2381  } catch (const std::runtime_error& e) {
2382  ostringstream os;
2383  os << "Error reading ArrayOfTelsemAtlas: "
2384  << "\n Element: " << n << "\n"
2385  << e.what();
2386  throw runtime_error(os.str());
2387  }
2388 
2389  tag.read_from_stream(is_xml);
2390  tag.check_name("/Array");
2391 }
2392 
2394 
2400 void xml_write_to_stream(ostream& os_xml,
2401  const ArrayOfTelsemAtlas& arr_telsem,
2402  bofstream* pbofs,
2403  const String& name,
2404  const Verbosity& verbosity) {
2405  ArtsXMLTag open_tag(verbosity);
2406  ArtsXMLTag close_tag(verbosity);
2407 
2408  open_tag.set_name("Array");
2409  if (name.length()) open_tag.add_attribute("name", name);
2410 
2411  open_tag.add_attribute("type", "TelsemAtlas");
2412  open_tag.add_attribute("nelem", arr_telsem.nelem());
2413 
2414  open_tag.write_to_stream(os_xml);
2415  os_xml << '\n';
2416 
2417  for (Index n = 0; n < arr_telsem.nelem(); n++)
2418  xml_write_to_stream(os_xml, arr_telsem[n], pbofs, "", verbosity);
2419 
2420  close_tag.set_name("/Array");
2421  close_tag.write_to_stream(os_xml);
2422 
2423  os_xml << '\n';
2424 }
2425 
2426 //=== ArrayOfTensor3=========================================================
2427 
2429 
2434 void xml_read_from_stream(istream& is_xml,
2435  ArrayOfTensor3& atensor3,
2436  bifstream* pbifs,
2437  const Verbosity& verbosity) {
2438  ArtsXMLTag tag(verbosity);
2439  Index nelem;
2440 
2441  tag.read_from_stream(is_xml);
2442  tag.check_name("Array");
2443  tag.check_attribute("type", "Tensor3");
2444 
2445  tag.get_attribute_value("nelem", nelem);
2446  atensor3.resize(nelem);
2447 
2448  Index n;
2449  try {
2450  for (n = 0; n < nelem; n++)
2451  xml_read_from_stream(is_xml, atensor3[n], pbifs, verbosity);
2452  } catch (const std::runtime_error& e) {
2453  ostringstream os;
2454  os << "Error reading ArrayOfTensor3: "
2455  << "\n Element: " << n << "\n"
2456  << e.what();
2457  throw runtime_error(os.str());
2458  }
2459 
2460  tag.read_from_stream(is_xml);
2461  tag.check_name("/Array");
2462 }
2463 
2465 
2471 void xml_write_to_stream(ostream& os_xml,
2472  const ArrayOfTensor3& atensor3,
2473  bofstream* pbofs,
2474  const String& name,
2475  const Verbosity& verbosity) {
2476  ArtsXMLTag open_tag(verbosity);
2477  ArtsXMLTag close_tag(verbosity);
2478 
2479  open_tag.set_name("Array");
2480  if (name.length()) open_tag.add_attribute("name", name);
2481 
2482  open_tag.add_attribute("type", "Tensor3");
2483  open_tag.add_attribute("nelem", atensor3.nelem());
2484 
2485  open_tag.write_to_stream(os_xml);
2486  os_xml << '\n';
2487 
2488  for (Index n = 0; n < atensor3.nelem(); n++)
2489  xml_write_to_stream(os_xml, atensor3[n], pbofs, "", verbosity);
2490 
2491  close_tag.set_name("/Array");
2492  close_tag.write_to_stream(os_xml);
2493 
2494  os_xml << '\n';
2495 }
2496 
2497 //=== ArrayOfTensor4=========================================================
2498 
2500 
2505 void xml_read_from_stream(istream& is_xml,
2506  ArrayOfTensor4& atensor4,
2507  bifstream* pbifs,
2508  const Verbosity& verbosity) {
2509  ArtsXMLTag tag(verbosity);
2510  Index nelem;
2511 
2512  tag.read_from_stream(is_xml);
2513  tag.check_name("Array");
2514  tag.check_attribute("type", "Tensor4");
2515 
2516  tag.get_attribute_value("nelem", nelem);
2517  atensor4.resize(nelem);
2518 
2519  Index n;
2520  try {
2521  for (n = 0; n < nelem; n++)
2522  xml_read_from_stream(is_xml, atensor4[n], pbifs, verbosity);
2523  } catch (const std::runtime_error& e) {
2524  ostringstream os;
2525  os << "Error reading ArrayOfTensor4: "
2526  << "\n Element: " << n << "\n"
2527  << e.what();
2528  throw runtime_error(os.str());
2529  }
2530 
2531  tag.read_from_stream(is_xml);
2532  tag.check_name("/Array");
2533 }
2534 
2536 
2542 void xml_write_to_stream(ostream& os_xml,
2543  const ArrayOfTensor4& atensor4,
2544  bofstream* pbofs,
2545  const String& name,
2546  const Verbosity& verbosity) {
2547  ArtsXMLTag open_tag(verbosity);
2548  ArtsXMLTag close_tag(verbosity);
2549 
2550  open_tag.set_name("Array");
2551  if (name.length()) open_tag.add_attribute("name", name);
2552 
2553  open_tag.add_attribute("type", "Tensor4");
2554  open_tag.add_attribute("nelem", atensor4.nelem());
2555 
2556  open_tag.write_to_stream(os_xml);
2557  os_xml << '\n';
2558 
2559  for (Index n = 0; n < atensor4.nelem(); n++)
2560  xml_write_to_stream(os_xml, atensor4[n], pbofs, "", verbosity);
2561 
2562  close_tag.set_name("/Array");
2563  close_tag.write_to_stream(os_xml);
2564 
2565  os_xml << '\n';
2566 }
2567 
2568 //=== ArrayOfTensor5=========================================================
2569 
2571 
2576 void xml_read_from_stream(istream& is_xml,
2577  ArrayOfTensor5& atensor5,
2578  bifstream* pbifs,
2579  const Verbosity& verbosity) {
2580  ArtsXMLTag tag(verbosity);
2581  Index nelem;
2582 
2583  tag.read_from_stream(is_xml);
2584  tag.check_name("Array");
2585  tag.check_attribute("type", "Tensor5");
2586 
2587  tag.get_attribute_value("nelem", nelem);
2588  atensor5.resize(nelem);
2589 
2590  Index n;
2591  try {
2592  for (n = 0; n < nelem; n++)
2593  xml_read_from_stream(is_xml, atensor5[n], pbifs, verbosity);
2594  } catch (const std::runtime_error& e) {
2595  ostringstream os;
2596  os << "Error reading ArrayOfTensor5: "
2597  << "\n Element: " << n << "\n"
2598  << e.what();
2599  throw runtime_error(os.str());
2600  }
2601 
2602  tag.read_from_stream(is_xml);
2603  tag.check_name("/Array");
2604 }
2605 
2607 
2613 void xml_write_to_stream(ostream& os_xml,
2614  const ArrayOfTensor5& atensor5,
2615  bofstream* pbofs,
2616  const String& name,
2617  const Verbosity& verbosity) {
2618  ArtsXMLTag open_tag(verbosity);
2619  ArtsXMLTag close_tag(verbosity);
2620 
2621  open_tag.set_name("Array");
2622  if (name.length()) open_tag.add_attribute("name", name);
2623 
2624  open_tag.add_attribute("type", "Tensor5");
2625  open_tag.add_attribute("nelem", atensor5.nelem());
2626 
2627  open_tag.write_to_stream(os_xml);
2628  os_xml << '\n';
2629 
2630  for (Index n = 0; n < atensor5.nelem(); n++)
2631  xml_write_to_stream(os_xml, atensor5[n], pbofs, "", verbosity);
2632 
2633  close_tag.set_name("/Array");
2634  close_tag.write_to_stream(os_xml);
2635 
2636  os_xml << '\n';
2637 }
2638 
2639 //=== ArrayOfTensor6=========================================================
2640 
2642 
2647 void xml_read_from_stream(istream& is_xml,
2648  ArrayOfTensor6& atensor6,
2649  bifstream* pbifs,
2650  const Verbosity& verbosity) {
2651  ArtsXMLTag tag(verbosity);
2652  Index nelem;
2653 
2654  tag.read_from_stream(is_xml);
2655  tag.check_name("Array");
2656  tag.check_attribute("type", "Tensor6");
2657 
2658  tag.get_attribute_value("nelem", nelem);
2659  atensor6.resize(nelem);
2660 
2661  Index n;
2662  try {
2663  for (n = 0; n < nelem; n++)
2664  xml_read_from_stream(is_xml, atensor6[n], pbifs, verbosity);
2665  } catch (const std::runtime_error& e) {
2666  ostringstream os;
2667  os << "Error reading ArrayOfTensor6: "
2668  << "\n Element: " << n << "\n"
2669  << e.what();
2670  throw runtime_error(os.str());
2671  }
2672 
2673  tag.read_from_stream(is_xml);
2674  tag.check_name("/Array");
2675 }
2676 
2678 
2684 void xml_write_to_stream(ostream& os_xml,
2685  const ArrayOfTensor6& atensor6,
2686  bofstream* pbofs,
2687  const String& name,
2688  const Verbosity& verbosity) {
2689  ArtsXMLTag open_tag(verbosity);
2690  ArtsXMLTag close_tag(verbosity);
2691 
2692  open_tag.set_name("Array");
2693  if (name.length()) open_tag.add_attribute("name", name);
2694 
2695  open_tag.add_attribute("type", "Tensor6");
2696  open_tag.add_attribute("nelem", atensor6.nelem());
2697 
2698  open_tag.write_to_stream(os_xml);
2699  os_xml << '\n';
2700 
2701  for (Index n = 0; n < atensor6.nelem(); n++)
2702  xml_write_to_stream(os_xml, atensor6[n], pbofs, "", verbosity);
2703 
2704  close_tag.set_name("/Array");
2705  close_tag.write_to_stream(os_xml);
2706 
2707  os_xml << '\n';
2708 }
2709 
2710 //=== ArrayOfTensor7=========================================================
2711 
2713 
2718 void xml_read_from_stream(istream& is_xml,
2719  ArrayOfTensor7& atensor7,
2720  bifstream* pbifs,
2721  const Verbosity& verbosity) {
2722  ArtsXMLTag tag(verbosity);
2723  Index nelem;
2724 
2725  tag.read_from_stream(is_xml);
2726  tag.check_name("Array");
2727  tag.check_attribute("type", "Tensor7");
2728 
2729  tag.get_attribute_value("nelem", nelem);
2730  atensor7.resize(nelem);
2731 
2732  Index n;
2733  try {
2734  for (n = 0; n < nelem; n++)
2735  xml_read_from_stream(is_xml, atensor7[n], pbifs, verbosity);
2736  } catch (const std::runtime_error& e) {
2737  ostringstream os;
2738  os << "Error reading ArrayOfTensor7: "
2739  << "\n Element: " << n << "\n"
2740  << e.what();
2741  throw runtime_error(os.str());
2742  }
2743 
2744  tag.read_from_stream(is_xml);
2745  tag.check_name("/Array");
2746 }
2747 
2749 
2755 void xml_write_to_stream(ostream& os_xml,
2756  const ArrayOfTensor7& atensor7,
2757  bofstream* pbofs,
2758  const String& name,
2759  const Verbosity& verbosity) {
2760  ArtsXMLTag open_tag(verbosity);
2761  ArtsXMLTag close_tag(verbosity);
2762 
2763  open_tag.set_name("Array");
2764  if (name.length()) open_tag.add_attribute("name", name);
2765 
2766  open_tag.add_attribute("type", "Tensor7");
2767  open_tag.add_attribute("nelem", atensor7.nelem());
2768 
2769  open_tag.write_to_stream(os_xml);
2770  os_xml << '\n';
2771 
2772  for (Index n = 0; n < atensor7.nelem(); n++)
2773  xml_write_to_stream(os_xml, atensor7[n], pbofs, "", verbosity);
2774 
2775  close_tag.set_name("/Array");
2776  close_tag.write_to_stream(os_xml);
2777 
2778  os_xml << '\n';
2779 }
2780 
2781 //=== ArrayOfString ==========================================================
2782 
2784 
2790 void xml_parse_from_stream(istream& is_xml,
2791  ArrayOfString& astring,
2792  bifstream* pbifs,
2793  ArtsXMLTag& tag,
2794  const Verbosity& verbosity) {
2795  Index nelem;
2796 
2797  tag.check_attribute("type", "String");
2798 
2799  tag.get_attribute_value("nelem", nelem);
2800  astring.resize(nelem);
2801 
2802  Index n;
2803  try {
2804  for (n = 0; n < nelem; n++)
2805  xml_read_from_stream(is_xml, astring[n], pbifs, verbosity);
2806  } catch (const std::runtime_error& e) {
2807  ostringstream os;
2808  os << "Error reading ArrayOfString: "
2809  << "\n Element: " << n << "\n"
2810  << e.what();
2811  throw runtime_error(os.str());
2812  }
2813 }
2814 
2816 
2821 void xml_read_from_stream(istream& is_xml,
2822  ArrayOfString& astring,
2823  bifstream* pbifs,
2824  const Verbosity& verbosity) {
2825  ArtsXMLTag tag(verbosity);
2826 
2827  tag.read_from_stream(is_xml);
2828  tag.check_name("Array");
2829 
2830  xml_parse_from_stream(is_xml, astring, pbifs, tag, verbosity);
2831 
2832  tag.read_from_stream(is_xml);
2833  tag.check_name("/Array");
2834 }
2835 
2837 
2843 void xml_write_to_stream(ostream& os_xml,
2844  const ArrayOfString& astring,
2845  bofstream* pbofs,
2846  const String& name,
2847  const Verbosity& verbosity) {
2848  ArtsXMLTag open_tag(verbosity);
2849  ArtsXMLTag close_tag(verbosity);
2850 
2851  open_tag.set_name("Array");
2852  if (name.length()) open_tag.add_attribute("name", name);
2853 
2854  open_tag.add_attribute("type", "String");
2855  open_tag.add_attribute("nelem", astring.nelem());
2856 
2857  open_tag.write_to_stream(os_xml);
2858  os_xml << '\n';
2859 
2860  for (Index n = 0; n < astring.nelem(); n++)
2861  xml_write_to_stream(os_xml, astring[n], pbofs, "", verbosity);
2862 
2863  close_tag.set_name("/Array");
2864  close_tag.write_to_stream(os_xml);
2865 
2866  os_xml << '\n';
2867 }
2868 
2869 //=== ArrayOfVector ==========================================================
2870 
2872 
2877 void xml_read_from_stream(istream& is_xml,
2878  ArrayOfVector& avector,
2879  bifstream* pbifs,
2880  const Verbosity& verbosity) {
2881  ArtsXMLTag tag(verbosity);
2882  Index nelem;
2883 
2884  tag.read_from_stream(is_xml);
2885  tag.check_name("Array");
2886  tag.check_attribute("type", "Vector");
2887 
2888  tag.get_attribute_value("nelem", nelem);
2889  avector.resize(nelem);
2890 
2891  Index n;
2892  try {
2893  for (n = 0; n < nelem; n++)
2894  xml_read_from_stream(is_xml, avector[n], pbifs, verbosity);
2895  } catch (const std::runtime_error& e) {
2896  ostringstream os;
2897  os << "Error reading ArrayOfVector: "
2898  << "\n Element: " << n << "\n"
2899  << e.what();
2900  throw runtime_error(os.str());
2901  }
2902 
2903  tag.read_from_stream(is_xml);
2904  tag.check_name("/Array");
2905 }
2906 
2908 
2914 void xml_write_to_stream(ostream& os_xml,
2915  const ArrayOfVector& avector,
2916  bofstream* pbofs,
2917  const String& name,
2918  const Verbosity& verbosity) {
2919  ArtsXMLTag open_tag(verbosity);
2920  ArtsXMLTag close_tag(verbosity);
2921 
2922  open_tag.set_name("Array");
2923  if (name.length()) open_tag.add_attribute("name", name);
2924 
2925  open_tag.add_attribute("type", "Vector");
2926  open_tag.add_attribute("nelem", avector.nelem());
2927 
2928  open_tag.write_to_stream(os_xml);
2929  os_xml << '\n';
2930 
2931  for (Index n = 0; n < avector.nelem(); n++)
2932  xml_write_to_stream(os_xml, avector[n], pbofs, "", verbosity);
2933 
2934  close_tag.set_name("/Array");
2935  close_tag.write_to_stream(os_xml);
2936 
2937  os_xml << '\n';
2938 }
2939 
2940 //=== ArrayOfTransmissionMatrix ======================================================
2941 
2943 
2948 void xml_read_from_stream(istream& is_xml,
2949  ArrayOfTransmissionMatrix& atm,
2950  bifstream* pbifs,
2951  const Verbosity& verbosity) {
2952  ArtsXMLTag tag(verbosity);
2953  Index nelem;
2954 
2955  tag.read_from_stream(is_xml);
2956  tag.check_name("Array");
2957  tag.check_attribute("type", "TransmissionMatrix");
2958 
2959  tag.get_attribute_value("nelem", nelem);
2960  atm.resize(nelem);
2961 
2962  Index n;
2963  try {
2964  for (n = 0; n < nelem; n++)
2965  xml_read_from_stream(is_xml, atm[n], pbifs, verbosity);
2966  } catch (const std::runtime_error& e) {
2967  ostringstream os;
2968  os << "Error reading ArrayOfTransmissionMatrix: "
2969  << "\n Element: " << n << "\n"
2970  << e.what();
2971  throw runtime_error(os.str());
2972  }
2973 
2974  tag.read_from_stream(is_xml);
2975  tag.check_name("/Array");
2976 }
2977 
2979 
2985 void xml_write_to_stream(ostream& os_xml,
2986  const ArrayOfTransmissionMatrix& atm,
2987  bofstream* pbofs,
2988  const String& name,
2989  const Verbosity& verbosity) {
2990  ArtsXMLTag open_tag(verbosity);
2991  ArtsXMLTag close_tag(verbosity);
2992 
2993  open_tag.set_name("Array");
2994  if (name.length()) open_tag.add_attribute("name", name);
2995 
2996  open_tag.add_attribute("type", "TransmissionMatrix");
2997  open_tag.add_attribute("nelem", atm.nelem());
2998 
2999  open_tag.write_to_stream(os_xml);
3000  os_xml << '\n';
3001 
3002  for (Index n = 0; n < atm.nelem(); n++)
3003  xml_write_to_stream(os_xml, atm[n], pbofs, "", verbosity);
3004 
3005  close_tag.set_name("/Array");
3006  close_tag.write_to_stream(os_xml);
3007 
3008  os_xml << '\n';
3009 }
3010 
3011 //=== ArrayOfArrayOfTransmissionMatrix ======================================================
3012 
3014 
3019 void xml_read_from_stream(istream& is_xml,
3020  ArrayOfArrayOfTransmissionMatrix& aatm,
3021  bifstream* pbifs,
3022  const Verbosity& verbosity) {
3023  ArtsXMLTag tag(verbosity);
3024  Index nelem;
3025 
3026  tag.read_from_stream(is_xml);
3027  tag.check_name("Array");
3028  tag.check_attribute("type", "ArrayOfTransmissionMatrix");
3029 
3030  tag.get_attribute_value("nelem", nelem);
3031  aatm.resize(nelem);
3032 
3033  Index n;
3034  try {
3035  for (n = 0; n < nelem; n++)
3036  xml_read_from_stream(is_xml, aatm[n], pbifs, verbosity);
3037  } catch (const std::runtime_error& e) {
3038  ostringstream os;
3039  os << "Error reading ArrayOfArrayOfTransmissionMatrix: "
3040  << "\n Element: " << n << "\n"
3041  << e.what();
3042  throw runtime_error(os.str());
3043  }
3044 
3045  tag.read_from_stream(is_xml);
3046  tag.check_name("/Array");
3047 }
3048 
3050 
3056 void xml_write_to_stream(ostream& os_xml,
3057  const ArrayOfArrayOfTransmissionMatrix& aatm,
3058  bofstream* pbofs,
3059  const String& name,
3060  const Verbosity& verbosity) {
3061  ArtsXMLTag open_tag(verbosity);
3062  ArtsXMLTag close_tag(verbosity);
3063 
3064  open_tag.set_name("Array");
3065  if (name.length()) open_tag.add_attribute("name", name);
3066 
3067  open_tag.add_attribute("type", "ArrayOfTransmissionMatrix");
3068  open_tag.add_attribute("nelem", aatm.nelem());
3069 
3070  open_tag.write_to_stream(os_xml);
3071  os_xml << '\n';
3072 
3073  for (Index n = 0; n < aatm.nelem(); n++)
3074  xml_write_to_stream(os_xml, aatm[n], pbofs, "", verbosity);
3075 
3076  close_tag.set_name("/Array");
3077  close_tag.write_to_stream(os_xml);
3078 
3079  os_xml << '\n';
3080 }
3081 
3082 //=== ArrayOfRadiationVector ======================================================
3083 
3085 
3090 void xml_read_from_stream(istream& is_xml,
3091  ArrayOfRadiationVector& arv,
3092  bifstream* pbifs,
3093  const Verbosity& verbosity) {
3094  ArtsXMLTag tag(verbosity);
3095  Index nelem;
3096 
3097  tag.read_from_stream(is_xml);
3098  tag.check_name("Array");
3099  tag.check_attribute("type", "RadiationVector");
3100 
3101  tag.get_attribute_value("nelem", nelem);
3102  arv.resize(nelem);
3103 
3104  Index n;
3105  try {
3106  for (n = 0; n < nelem; n++)
3107  xml_read_from_stream(is_xml, arv[n], pbifs, verbosity);
3108  } catch (const std::runtime_error& e) {
3109  ostringstream os;
3110  os << "Error reading ArrayOfRadiationVector: "
3111  << "\n Element: " << n << "\n"
3112  << e.what();
3113  throw runtime_error(os.str());
3114  }
3115 
3116  tag.read_from_stream(is_xml);
3117  tag.check_name("/Array");
3118 }
3119 
3121 
3127 void xml_write_to_stream(ostream& os_xml,
3128  const ArrayOfRadiationVector& arv,
3129  bofstream* pbofs,
3130  const String& name,
3131  const Verbosity& verbosity) {
3132  ArtsXMLTag open_tag(verbosity);
3133  ArtsXMLTag close_tag(verbosity);
3134 
3135  open_tag.set_name("Array");
3136  if (name.length()) open_tag.add_attribute("name", name);
3137 
3138  open_tag.add_attribute("type", "RadiationVector");
3139  open_tag.add_attribute("nelem", arv.nelem());
3140 
3141  open_tag.write_to_stream(os_xml);
3142  os_xml << '\n';
3143 
3144  for (Index n = 0; n < arv.nelem(); n++)
3145  xml_write_to_stream(os_xml, arv[n], pbofs, "", verbosity);
3146 
3147  close_tag.set_name("/Array");
3148  close_tag.write_to_stream(os_xml);
3149 
3150  os_xml << '\n';
3151 }
3152 
3153 //=== ArrayOfArrayOfRadiationVector ======================================================
3154 
3156 
3161 void xml_read_from_stream(istream& is_xml,
3162  ArrayOfArrayOfRadiationVector& aarv,
3163  bifstream* pbifs,
3164  const Verbosity& verbosity) {
3165  ArtsXMLTag tag(verbosity);
3166  Index nelem;
3167 
3168  tag.read_from_stream(is_xml);
3169  tag.check_name("Array");
3170  tag.check_attribute("type", "ArrayOfRadiationVector");
3171 
3172  tag.get_attribute_value("nelem", nelem);
3173  aarv.resize(nelem);
3174 
3175  Index n;
3176  try {
3177  for (n = 0; n < nelem; n++)
3178  xml_read_from_stream(is_xml, aarv[n], pbifs, verbosity);
3179  } catch (const std::runtime_error& e) {
3180  ostringstream os;
3181  os << "Error reading ArrayOfArrayOfRadiationVector: "
3182  << "\n Element: " << n << "\n"
3183  << e.what();
3184  throw runtime_error(os.str());
3185  }
3186 
3187  tag.read_from_stream(is_xml);
3188  tag.check_name("/Array");
3189 }
3190 
3192 
3198 void xml_write_to_stream(ostream& os_xml,
3199  const ArrayOfArrayOfRadiationVector& aarv,
3200  bofstream* pbofs,
3201  const String& name,
3202  const Verbosity& verbosity) {
3203  ArtsXMLTag open_tag(verbosity);
3204  ArtsXMLTag close_tag(verbosity);
3205 
3206  open_tag.set_name("Array");
3207  if (name.length()) open_tag.add_attribute("name", name);
3208 
3209  open_tag.add_attribute("type", "ArrayOfRadiationVector");
3210  open_tag.add_attribute("nelem", aarv.nelem());
3211 
3212  open_tag.write_to_stream(os_xml);
3213  os_xml << '\n';
3214 
3215  for (Index n = 0; n < aarv.nelem(); n++)
3216  xml_write_to_stream(os_xml, aarv[n], pbofs, "", verbosity);
3217 
3218  close_tag.set_name("/Array");
3219  close_tag.write_to_stream(os_xml);
3220 
3221  os_xml << '\n';
3222 }
3223 
3224 //=== ArrayOfPropagationMatrix ======================================================
3225 
3227 
3232 void xml_read_from_stream(istream& is_xml,
3233  ArrayOfPropagationMatrix& apm,
3234  bifstream* pbifs,
3235  const Verbosity& verbosity) {
3236  ArtsXMLTag tag(verbosity);
3237  Index nelem;
3238 
3239  tag.read_from_stream(is_xml);
3240  tag.check_name("Array");
3241  tag.check_attribute("type", "PropagationMatrix");
3242 
3243  tag.get_attribute_value("nelem", nelem);
3244  apm.resize(nelem);
3245 
3246  Index n;
3247  try {
3248  for (n = 0; n < nelem; n++)
3249  xml_read_from_stream(is_xml, apm[n], pbifs, verbosity);
3250  } catch (const std::runtime_error& e) {
3251  ostringstream os;
3252  os << "Error reading ArrayOfPropagationMatrix: "
3253  << "\n Element: " << n << "\n"
3254  << e.what();
3255  throw runtime_error(os.str());
3256  }
3257 
3258  tag.read_from_stream(is_xml);
3259  tag.check_name("/Array");
3260 }
3261 
3263 
3269 void xml_write_to_stream(ostream& os_xml,
3270  const ArrayOfPropagationMatrix& apm,
3271  bofstream* pbofs,
3272  const String& name,
3273  const Verbosity& verbosity) {
3274  ArtsXMLTag open_tag(verbosity);
3275  ArtsXMLTag close_tag(verbosity);
3276 
3277  open_tag.set_name("Array");
3278  if (name.length()) open_tag.add_attribute("name", name);
3279 
3280  open_tag.add_attribute("type", "PropagationMatrix");
3281  open_tag.add_attribute("nelem", apm.nelem());
3282 
3283  open_tag.write_to_stream(os_xml);
3284  os_xml << '\n';
3285 
3286  for (Index n = 0; n < apm.nelem(); n++)
3287  xml_write_to_stream(os_xml, apm[n], pbofs, "", verbosity);
3288 
3289  close_tag.set_name("/Array");
3290  close_tag.write_to_stream(os_xml);
3291 
3292  os_xml << '\n';
3293 }
3294 
3295 //=== ArrayOfAbsorptionLines ======================================================
3296 
3298 
3303 void xml_read_from_stream(istream& is_xml,
3304  ArrayOfAbsorptionLines& aal,
3305  bifstream* pbifs,
3306  const Verbosity& verbosity) {
3307  ArtsXMLTag tag(verbosity);
3308  Index nelem;
3309 
3310  tag.read_from_stream(is_xml);
3311  tag.check_name("Array");
3312  tag.check_attribute("type", "AbsorptionLines");
3313 
3314  tag.get_attribute_value("nelem", nelem);
3315  aal.resize(nelem);
3316 
3317  Index n;
3318  try {
3319  for (n = 0; n < nelem; n++)
3320  xml_read_from_stream(is_xml, aal[n], pbifs, verbosity);
3321  } catch (const std::runtime_error& e) {
3322  ostringstream os;
3323  os << "Error reading ArrayOfAbsorptionLines: "
3324  << "\n Element: " << n << "\n"
3325  << e.what();
3326  throw runtime_error(os.str());
3327  }
3328 
3329  tag.read_from_stream(is_xml);
3330  tag.check_name("/Array");
3331 }
3332 
3334 
3340 void xml_write_to_stream(ostream& os_xml,
3341  const ArrayOfAbsorptionLines& aal,
3342  bofstream* pbofs,
3343  const String& name,
3344  const Verbosity& verbosity) {
3345  ArtsXMLTag open_tag(verbosity);
3346  ArtsXMLTag close_tag(verbosity);
3347 
3348  open_tag.set_name("Array");
3349  if (name.length()) open_tag.add_attribute("name", name);
3350 
3351  open_tag.add_attribute("type", "AbsorptionLines");
3352  open_tag.add_attribute("nelem", aal.nelem());
3353 
3354  open_tag.write_to_stream(os_xml);
3355  os_xml << '\n';
3356 
3357  for (Index n = 0; n < aal.nelem(); n++)
3358  xml_write_to_stream(os_xml, aal[n], pbofs, "", verbosity);
3359 
3360  close_tag.set_name("/Array");
3361  close_tag.write_to_stream(os_xml);
3362 
3363  os_xml << '\n';
3364 }
3365 
3366 //=== ArrayOfArrayOfAbsorptionLines ======================================================
3367 
3369 
3374 void xml_read_from_stream(istream& is_xml,
3375  ArrayOfArrayOfAbsorptionLines& aal,
3376  bifstream* pbifs,
3377  const Verbosity& verbosity) {
3378  ArtsXMLTag tag(verbosity);
3379  Index nelem;
3380 
3381  tag.read_from_stream(is_xml);
3382  tag.check_name("Array");
3383  tag.check_attribute("type", "ArrayOfAbsorptionLines");
3384 
3385  tag.get_attribute_value("nelem", nelem);
3386  aal.resize(nelem);
3387 
3388  Index n;
3389  try {
3390  for (n = 0; n < nelem; n++)
3391  xml_read_from_stream(is_xml, aal[n], pbifs, verbosity);
3392  } catch (const std::runtime_error& e) {
3393  ostringstream os;
3394  os << "Error reading ArrayOfArrayOfAbsorptionLines: "
3395  << "\n Element: " << n << "\n"
3396  << e.what();
3397  throw runtime_error(os.str());
3398  }
3399 
3400  tag.read_from_stream(is_xml);
3401  tag.check_name("/Array");
3402 }
3403 
3405 
3411 void xml_write_to_stream(ostream& os_xml,
3412  const ArrayOfArrayOfAbsorptionLines& aal,
3413  bofstream* pbofs,
3414  const String& name,
3415  const Verbosity& verbosity) {
3416  ArtsXMLTag open_tag(verbosity);
3417  ArtsXMLTag close_tag(verbosity);
3418 
3419  open_tag.set_name("Array");
3420  if (name.length()) open_tag.add_attribute("name", name);
3421 
3422  open_tag.add_attribute("type", "ArrayOfAbsorptionLines");
3423  open_tag.add_attribute("nelem", aal.nelem());
3424 
3425  open_tag.write_to_stream(os_xml);
3426  os_xml << '\n';
3427 
3428  for (Index n = 0; n < aal.nelem(); n++)
3429  xml_write_to_stream(os_xml, aal[n], pbofs, "", verbosity);
3430 
3431  close_tag.set_name("/Array");
3432  close_tag.write_to_stream(os_xml);
3433 
3434  os_xml << '\n';
3435 }
3436 
3437 //=== ArrayOfArrayOfPropagationMatrix ======================================================
3438 
3440 
3445 void xml_read_from_stream(istream& is_xml,
3446  ArrayOfArrayOfPropagationMatrix& aapm,
3447  bifstream* pbifs,
3448  const Verbosity& verbosity) {
3449  ArtsXMLTag tag(verbosity);
3450  Index nelem;
3451 
3452  tag.read_from_stream(is_xml);
3453  tag.check_name("Array");
3454  tag.check_attribute("type", "ArrayOfPropagationMatrix");
3455 
3456  tag.get_attribute_value("nelem", nelem);
3457  aapm.resize(nelem);
3458 
3459  Index n;
3460  try {
3461  for (n = 0; n < nelem; n++)
3462  xml_read_from_stream(is_xml, aapm[n], pbifs, verbosity);
3463  } catch (const std::runtime_error& e) {
3464  ostringstream os;
3465  os << "Error reading ArrayOfArrayOfPropagationMatrix: "
3466  << "\n Element: " << n << "\n"
3467  << e.what();
3468  throw runtime_error(os.str());
3469  }
3470 
3471  tag.read_from_stream(is_xml);
3472  tag.check_name("/Array");
3473 }
3474 
3476 
3482 void xml_write_to_stream(ostream& os_xml,
3483  const ArrayOfArrayOfPropagationMatrix& aapm,
3484  bofstream* pbofs,
3485  const String& name,
3486  const Verbosity& verbosity) {
3487  ArtsXMLTag open_tag(verbosity);
3488  ArtsXMLTag close_tag(verbosity);
3489 
3490  open_tag.set_name("Array");
3491  if (name.length()) open_tag.add_attribute("name", name);
3492 
3493  open_tag.add_attribute("type", "ArrayOfPropagationMatrix");
3494  open_tag.add_attribute("nelem", aapm.nelem());
3495 
3496  open_tag.write_to_stream(os_xml);
3497  os_xml << '\n';
3498 
3499  for (Index n = 0; n < aapm.nelem(); n++)
3500  xml_write_to_stream(os_xml, aapm[n], pbofs, "", verbosity);
3501 
3502  close_tag.set_name("/Array");
3503  close_tag.write_to_stream(os_xml);
3504 
3505  os_xml << '\n';
3506 }
3507 
3508 //=== ArrayOfStokesVector ======================================================
3509 
3511 
3516 void xml_read_from_stream(istream& is_xml,
3517  ArrayOfStokesVector& apm,
3518  bifstream* pbifs,
3519  const Verbosity& verbosity) {
3520  ArtsXMLTag tag(verbosity);
3521  Index nelem;
3522 
3523  tag.read_from_stream(is_xml);
3524  tag.check_name("Array");
3525  tag.check_attribute("type", "StokesVector");
3526 
3527  tag.get_attribute_value("nelem", nelem);
3528  apm.resize(nelem);
3529 
3530  Index n;
3531  try {
3532  for (n = 0; n < nelem; n++)
3533  xml_read_from_stream(is_xml, apm[n], pbifs, verbosity);
3534  } catch (const std::runtime_error& e) {
3535  ostringstream os;
3536  os << "Error reading ArrayOfStokesVector: "
3537  << "\n Element: " << n << "\n"
3538  << e.what();
3539  throw runtime_error(os.str());
3540  }
3541 
3542  tag.read_from_stream(is_xml);
3543  tag.check_name("/Array");
3544 }
3545 
3547 
3553 void xml_write_to_stream(ostream& os_xml,
3554  const ArrayOfStokesVector& apm,
3555  bofstream* pbofs,
3556  const String& name,
3557  const Verbosity& verbosity) {
3558  ArtsXMLTag open_tag(verbosity);
3559  ArtsXMLTag close_tag(verbosity);
3560 
3561  open_tag.set_name("Array");
3562  if (name.length()) open_tag.add_attribute("name", name);
3563 
3564  open_tag.add_attribute("type", "StokesVector");
3565  open_tag.add_attribute("nelem", apm.nelem());
3566 
3567  open_tag.write_to_stream(os_xml);
3568  os_xml << '\n';
3569 
3570  for (Index n = 0; n < apm.nelem(); n++)
3571  xml_write_to_stream(os_xml, apm[n], pbofs, "", verbosity);
3572 
3573  close_tag.set_name("/Array");
3574  close_tag.write_to_stream(os_xml);
3575 
3576  os_xml << '\n';
3577 }
3578 
3579 //=== ArrayOfArrayOfStokesVector ======================================================
3580 
3582 
3587 void xml_read_from_stream(istream& is_xml,
3588  ArrayOfArrayOfStokesVector& aapm,
3589  bifstream* pbifs,
3590  const Verbosity& verbosity) {
3591  ArtsXMLTag tag(verbosity);
3592  Index nelem;
3593 
3594  tag.read_from_stream(is_xml);
3595  tag.check_name("Array");
3596  tag.check_attribute("type", "ArrayOfStokesVector");
3597 
3598  tag.get_attribute_value("nelem", nelem);
3599  aapm.resize(nelem);
3600 
3601  Index n;
3602  try {
3603  for (n = 0; n < nelem; n++)
3604  xml_read_from_stream(is_xml, aapm[n], pbifs, verbosity);
3605  } catch (const std::runtime_error& e) {
3606  ostringstream os;
3607  os << "Error reading ArrayOfArrayOfStokesVector: "
3608  << "\n Element: " << n << "\n"
3609  << e.what();
3610  throw runtime_error(os.str());
3611  }
3612 
3613  tag.read_from_stream(is_xml);
3614  tag.check_name("/Array");
3615 }
3616 
3618 
3624 void xml_write_to_stream(ostream& os_xml,
3625  const ArrayOfArrayOfStokesVector& aapm,
3626  bofstream* pbofs,
3627  const String& name,
3628  const Verbosity& verbosity) {
3629  ArtsXMLTag open_tag(verbosity);
3630  ArtsXMLTag close_tag(verbosity);
3631 
3632  open_tag.set_name("Array");
3633  if (name.length()) open_tag.add_attribute("name", name);
3634 
3635  open_tag.add_attribute("type", "ArrayOfStokesVector");
3636  open_tag.add_attribute("nelem", aapm.nelem());
3637 
3638  open_tag.write_to_stream(os_xml);
3639  os_xml << '\n';
3640 
3641  for (Index n = 0; n < aapm.nelem(); n++)
3642  xml_write_to_stream(os_xml, aapm[n], pbofs, "", verbosity);
3643 
3644  close_tag.set_name("/Array");
3645  close_tag.write_to_stream(os_xml);
3646 
3647  os_xml << '\n';
3648 }
3649 
3650 //=== ArrayOfXsecRecord ======================================================
3651 
3653 
3658 void xml_read_from_stream(istream& is_xml,
3659  ArrayOfXsecRecord& axd,
3660  bifstream* pbifs,
3661  const Verbosity& verbosity) {
3662  ArtsXMLTag tag(verbosity);
3663  Index nelem;
3664 
3665  tag.read_from_stream(is_xml);
3666  tag.check_name("Array");
3667  tag.check_attribute("type", "XsecRecord");
3668 
3669  tag.get_attribute_value("nelem", nelem);
3670  axd.resize(nelem);
3671 
3672  Index n;
3673  try {
3674  for (n = 0; n < nelem; n++)
3675  xml_read_from_stream(is_xml, axd[n], pbifs, verbosity);
3676  } catch (const std::runtime_error& e) {
3677  ostringstream os;
3678  os << "Error reading ArrayOfXsecRecord: "
3679  << "\n Element: " << n << "\n"
3680  << e.what();
3681  throw runtime_error(os.str());
3682  }
3683 
3684  tag.read_from_stream(is_xml);
3685  tag.check_name("/Array");
3686 }
3687 
3689 
3695 void xml_write_to_stream(ostream& os_xml,
3696  const ArrayOfXsecRecord& axd,
3697  bofstream* pbofs,
3698  const String& name,
3699  const Verbosity& verbosity) {
3700  ArtsXMLTag open_tag(verbosity);
3701  ArtsXMLTag close_tag(verbosity);
3702 
3703  open_tag.set_name("Array");
3704  if (name.length()) open_tag.add_attribute("name", name);
3705 
3706  open_tag.add_attribute("type", "XsecRecord");
3707  open_tag.add_attribute("nelem", axd.nelem());
3708 
3709  open_tag.write_to_stream(os_xml);
3710  os_xml << '\n';
3711 
3712  for (Index n = 0; n < axd.nelem(); n++)
3713  xml_write_to_stream(os_xml, axd[n], pbofs, "", verbosity);
3714 
3715  close_tag.set_name("/Array");
3716  close_tag.write_to_stream(os_xml);
3717 
3718  os_xml << '\n';
3719 }
3720 
3721 //=== ArrayOfTime ======================================================
3722 
3724 
3729 void xml_read_from_stream(istream& is_xml,
3730  ArrayOfTime& at,
3731  bifstream* pbifs,
3732  const Verbosity& verbosity) {
3733  ArtsXMLTag tag(verbosity);
3734  Index nelem;
3735 
3736  tag.read_from_stream(is_xml);
3737  tag.check_name("Array");
3738  tag.check_attribute("type", "Time");
3739 
3740  tag.get_attribute_value("nelem", nelem);
3741  at.resize(nelem);
3742 
3743  Index n;
3744  try {
3745  for (n = 0; n < nelem; n++)
3746  xml_read_from_stream(is_xml, at[n], pbifs, verbosity);
3747  } catch (const std::runtime_error& e) {
3748  ostringstream os;
3749  os << "Error reading ArrayOfTime: "
3750  << "\n Element: " << n << "\n"
3751  << e.what();
3752  throw runtime_error(os.str());
3753  }
3754 
3755  tag.read_from_stream(is_xml);
3756  tag.check_name("/Array");
3757 }
3758 
3760 
3766 void xml_write_to_stream(ostream& os_xml,
3767  const ArrayOfTime& at,
3768  bofstream* pbofs,
3769  const String& name,
3770  const Verbosity& verbosity) {
3771  ArtsXMLTag open_tag(verbosity);
3772  ArtsXMLTag close_tag(verbosity);
3773 
3774  open_tag.set_name("Array");
3775  if (name.length()) open_tag.add_attribute("name", name);
3776 
3777  open_tag.add_attribute("type", "Time");
3778  open_tag.add_attribute("nelem", at.nelem());
3779 
3780  open_tag.write_to_stream(os_xml);
3781  os_xml << '\n';
3782 
3783  for (Index n = 0; n < at.nelem(); n++)
3784  xml_write_to_stream(os_xml, at[n], pbofs, "", verbosity);
3785 
3786  close_tag.set_name("/Array");
3787  close_tag.write_to_stream(os_xml);
3788 
3789  os_xml << '\n';
3790 }
3791 
3792 //=== ArrayOfArrayOfTime ======================================================
3793 
3795 
3800 void xml_read_from_stream(istream& is_xml,
3801  ArrayOfArrayOfTime& at,
3802  bifstream* pbifs,
3803  const Verbosity& verbosity) {
3804  ArtsXMLTag tag(verbosity);
3805  Index nelem;
3806 
3807  tag.read_from_stream(is_xml);
3808  tag.check_name("Array");
3809  tag.check_attribute("type", "ArrayOfTime");
3810 
3811  tag.get_attribute_value("nelem", nelem);
3812  at.resize(nelem);
3813 
3814  Index n;
3815  try {
3816  for (n = 0; n < nelem; n++)
3817  xml_read_from_stream(is_xml, at[n], pbifs, verbosity);
3818  } catch (const std::runtime_error& e) {
3819  ostringstream os;
3820  os << "Error reading ArrayOfArrayOfTime: "
3821  << "\n Element: " << n << "\n"
3822  << e.what();
3823  throw runtime_error(os.str());
3824  }
3825 
3826  tag.read_from_stream(is_xml);
3827  tag.check_name("/Array");
3828 }
3829 
3831 
3837 void xml_write_to_stream(ostream& os_xml,
3838  const ArrayOfArrayOfTime& at,
3839  bofstream* pbofs,
3840  const String& name,
3841  const Verbosity& verbosity) {
3842  ArtsXMLTag open_tag(verbosity);
3843  ArtsXMLTag close_tag(verbosity);
3844 
3845  open_tag.set_name("Array");
3846  if (name.length()) open_tag.add_attribute("name", name);
3847 
3848  open_tag.add_attribute("type", "ArrayOfTime");
3849  open_tag.add_attribute("nelem", at.nelem());
3850 
3851  open_tag.write_to_stream(os_xml);
3852  os_xml << '\n';
3853 
3854  for (Index n = 0; n < at.nelem(); n++)
3855  xml_write_to_stream(os_xml, at[n], pbofs, "", verbosity);
3856 
3857  close_tag.set_name("/ArrayOfTime");
3858  close_tag.write_to_stream(os_xml);
3859 
3860  os_xml << '\n';
3861 }
3862 
ArtsXMLTag::check_name
void check_name(const String &expected_name)
Check tag name.
Definition: xml_io.cc:54
ARTS::Var::verbosity
Verbosity verbosity(Workspace &ws) noexcept
Definition: autoarts.h:7112
xml_parse_from_stream
void xml_parse_from_stream(istream &is_xml, ArrayOfString &astring, bifstream *pbifs, ArtsXMLTag &tag, const Verbosity &verbosity)
Parse ArrayOfString from XML input stream.
Definition: xml_io_array_types.cc:2790
ArtsXMLTag::get_attribute_value
void get_attribute_value(const String &aname, String &value)
Returns value of attribute as String.
Definition: xml_io.cc:153
ArtsXMLTag::check_attribute
void check_attribute(const String &aname, const String &value)
Checks whether attribute has the expected value.
Definition: xml_io.cc:131
ArtsXMLTag::write_to_stream
void write_to_stream(ostream &os)
Write XML tag.
Definition: xml_io.cc:410
Array
This can be used to make arrays out of anything.
Definition: array.h:108
xml_io_private.h
This file contains private function declarations and template instantiation to handle XML data files.
Absorption::nelem
Index nelem(const Lines &l)
Number of lines.
Definition: absorptionlines.h:1820
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:47
_U_
#define _U_
Definition: config.h:183
ArtsXMLTag::read_from_stream
void read_from_stream(istream &is)
Reads next XML tag.
Definition: xml_io.cc:289
my_basic_string< char >
xml_io_types.h
This file contains private function declarations and template instantiation to handle XML data files.
jacobian.h
Routines for setting up the jacobian.
Verbosity
Definition: messages.h:49
ArtsXMLTag::add_attribute
void add_attribute(const String &aname, const String &value)
Adds a String attribute to tag.
Definition: xml_io.cc:66
bifstream
Binary output file stream class.
Definition: bifstream.h:42
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:61
ArtsXMLTag
The ARTS XML tag class.
Definition: xml_io_private.h:90
ARTS::Group::QuantumIdentifier
QuantumIdentifier QuantumIdentifier
Definition: autoarts.h:94
Index
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
ArtsXMLTag::set_name
void set_name(const String &new_name)
Definition: xml_io_private.h:98
Array::nelem
Index nelem() const
Number of elements.
Definition: array.h:195
arts.h
The global header file for ARTS.
bofstream
Binary output file stream class.
Definition: bofstream.h:42