ARTS  2.3.1285(git:92a29ea9-dirty)
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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 
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
void add_attribute(const String &aname, const String &value)
Adds a String attribute to tag.
Definition: xml_io.cc:66
void xml_write_to_stream(ostream &os_xml, const ArrayOfAgenda &aa, bofstream *pbofs, const String &name, const Verbosity &)
Writes ArrayOfAgenda to XML output stream.
Index nelem() const
Number of elements.
Definition: array.h:195
void read_from_stream(istream &is)
Reads next XML tag.
Definition: xml_io.cc:289
Routines for setting up the jacobian.
This file contains private function declarations and template instantiation to handle XML data files...
The ARTS XML tag class.
The global header file for ARTS.
_CS_string_type str() const
Definition: sstream.h:491
void set_name(const String &new_name)
Binary output file stream class.
Definition: bifstream.h:42
Class to identify and match lines by their quantum numbers.
Definition: quantum.h:390
void get_attribute_value(const String &aname, String &value)
Returns value of attribute as String.
Definition: xml_io.cc:153
void check_name(const String &expected_name)
Check tag name.
Definition: xml_io.cc:54
This can be used to make arrays out of anything.
Definition: array.h:40
void xml_read_from_stream(istream &is_xml, ArrayOfAgenda &aa, bifstream *pbifs, const Verbosity &)
Reads ArrayOfAgenda from XML input stream.
void check_attribute(const String &aname, const String &value)
Checks whether attribute has the expected value.
Definition: xml_io.cc:131
void xml_parse_from_stream(istream &is_xml, ArrayOfString &astring, bifstream *pbifs, ArtsXMLTag &tag, const Verbosity &verbosity)
Parse ArrayOfString from XML input stream.
Index nelem(const Lines &l)
Number of lines.
Binary output file stream class.
Definition: bofstream.h:42
#define _U_
Definition: config.h:183
This file contains private function declarations and template instantiation to handle XML data files...
void write_to_stream(ostream &os)
Write XML tag.
Definition: xml_io.cc:410