ARTS 2.5.4 (git: bcd8c674)
xml_io_basic_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 "absorptionlines.h"
31#include "arts.h"
32#include "debug.h"
33#include "isotopologues.h"
34#include "messages.h"
35#include "quantum_numbers.h"
36#include "xml_io.h"
37#include <algorithm>
38#include <vector>
39
41// Overloaded functions for reading/writing data from/to XML stream
43
44//=== JacobianTarget ==================================================================
45
47
52void xml_read_from_stream(istream& is_xml,
54 bifstream* pbifs,
55 const Verbosity& verbosity) {
56 ArtsXMLTag tag(verbosity);
57
58 tag.read_from_stream(is_xml);
59 tag.check_name("JacobianTarget");
60
61 // Type information
62 String typestr, subtypestr;
63 tag.get_attribute_value("Type", typestr);
64 tag.get_attribute_value("SubType", subtypestr);
65 jt.TargetType(typestr);
66 jt.TargetSubType(subtypestr);
67
69 if (jt.needQuantumIdentity()) {
70 String qid;
71 tag.get_attribute_value("id", qid);
72 jt.qid = QuantumIdentifier(qid);
73 }
74
75 if (jt.needArrayOfSpeciesTag()) {
76 String key;
77 tag.get_attribute_value("species", key);
79 }
80
81 if (jt.needString()) {
82 tag.get_attribute_value("string_key", jt.string_id);
83 }
84
85 if (pbifs) {
86 *pbifs >> jt.perturbation;
87 if (pbifs->fail()) {
88 xml_data_parse_error(tag, "");
89 }
90 } else {
91 is_xml >> double_imanip() >> jt.perturbation;
92 if (is_xml.fail()) {
93 xml_data_parse_error(tag, "");
94 }
95 }
96
97 tag.read_from_stream(is_xml);
98 tag.check_name("/JacobianTarget");
99
101 "Bad input: ", typestr, " or ", subtypestr, '\n', "\tCannot be interpreted as a type or substype...\n")
102}
103
105
111void xml_write_to_stream(ostream& os_xml,
112 const JacobianTarget& jt,
113 bofstream* pbofs,
114 const String& name,
115 const Verbosity& verbosity) {
116 ArtsXMLTag open_tag(verbosity);
117 ArtsXMLTag close_tag(verbosity);
118
119 os_xml << '\n';
120 open_tag.set_name("JacobianTarget");
121 if (name.length()) open_tag.add_attribute("name", name);
122
123 // Type information
124 open_tag.add_attribute("Type", jt.TargetType());
125 open_tag.add_attribute("SubType", jt.TargetSubType());
126
128 if (jt.needQuantumIdentity()) {
129 open_tag.add_attribute("id", var_string(jt.qid));
130 }
131
132 if (jt.needArrayOfSpeciesTag()) {
133 open_tag.add_attribute("species", jt.species_array_id.Name());
134 }
135
136 if (jt.needString()) {
137 open_tag.add_attribute("string_key", jt.string_id);
138 }
139 open_tag.write_to_stream(os_xml);
140
141 if (pbofs)
142 *pbofs << jt.perturbation;
143 else
144 os_xml << ' ' << jt.perturbation << ' ';
145
146 close_tag.set_name("/JacobianTarget");
147 close_tag.write_to_stream(os_xml);
148 os_xml << '\n';
149}
150
151//=== Rational =========================================================
152
154
159void xml_read_from_stream(istream& is_xml,
160 Rational& rational,
161 bifstream* pbifs,
162 const Verbosity& verbosity) {
163 ArtsXMLTag tag(verbosity);
164
165 tag.read_from_stream(is_xml);
166 tag.check_name("Rational");
167
168 if (pbifs) {
169 *pbifs >> rational;
170 if (pbifs->fail()) {
171 xml_data_parse_error(tag, "");
172 }
173 } else {
174 is_xml >> rational;
175 if (is_xml.fail()) {
176 xml_data_parse_error(tag, "");
177 }
178 }
179
180 tag.read_from_stream(is_xml);
181 tag.check_name("/Rational");
182}
183
185
191void xml_write_to_stream(ostream& os_xml,
192 const Rational& rational,
193 bofstream* pbofs,
194 const String& name,
195 const Verbosity& verbosity) {
196 ArtsXMLTag open_tag(verbosity);
197 ArtsXMLTag close_tag(verbosity);
198
199 open_tag.set_name("Rational");
200 if (name.length()) open_tag.add_attribute("name", name);
201
202 open_tag.write_to_stream(os_xml);
203
204 if (pbofs)
205 *pbofs << rational;
206 else
207 os_xml << ' ' << rational << ' ';
208
209 close_tag.set_name("/Rational");
210 close_tag.write_to_stream(os_xml);
211 os_xml << '\n';
212}
213
214//=== TransmissionMatrix ================================================================
215
217
222void xml_read_from_stream(istream& is_xml,
224 bifstream* pbifs,
225 const Verbosity& verbosity) {
226 ArtsXMLTag tag(verbosity);
227 Index stokes_dim, nf;
228
229 tag.read_from_stream(is_xml);
230 tag.check_name("TransmissionMatrix");
231
232 tag.get_attribute_value("Stokes", stokes_dim);
233 tag.get_attribute_value("Freqs", nf);
234 tm = TransmissionMatrix(nf, stokes_dim);
235 if (pbifs) {
236 *pbifs >> tm;
237 if (pbifs->fail()) {
238 ostringstream os;
239 os << "TransmissionMatrix has wrong dimensions";
240 xml_data_parse_error(tag, os.str());
241 }
242 } else {
243 is_xml >> tm;
244 if (is_xml.fail()) {
245 ostringstream os;
246 os << "TransmissionMatrix has wrong dimensions";
247 xml_data_parse_error(tag, os.str());
248 }
249 }
250
251 tag.read_from_stream(is_xml);
252 tag.check_name("/TransmissionMatrix");
253}
254
256
262void xml_write_to_stream(ostream& os_xml,
263 const TransmissionMatrix& tm,
264 bofstream* pbofs,
265 const String& name,
266 const Verbosity& verbosity) {
267 ArtsXMLTag open_tag(verbosity);
268 ArtsXMLTag close_tag(verbosity);
269
270 open_tag.set_name("TransmissionMatrix");
271 if (name.length()) open_tag.add_attribute("name", name);
272 open_tag.add_attribute("Stokes", tm.stokes_dim);
273 open_tag.add_attribute("Freqs", tm.Frequencies());
274
275 open_tag.write_to_stream(os_xml);
276 os_xml << '\n';
277
279 if (pbofs)
280 *pbofs << tm;
281 else
282 os_xml << tm;
283
284 close_tag.set_name("/TransmissionMatrix");
285 close_tag.write_to_stream(os_xml);
286
287 os_xml << '\n';
288}
289
290//=== RadiationVector ================================================================
291
293
298void xml_read_from_stream(istream& is_xml,
299 RadiationVector& rv,
300 bifstream* pbifs,
301 const Verbosity& verbosity) {
302 ArtsXMLTag tag(verbosity);
303 Index stokes_dim, nf;
304
305 tag.read_from_stream(is_xml);
306 tag.check_name("RadiationVector");
307
308 tag.get_attribute_value("Stokes", stokes_dim);
309 tag.get_attribute_value("Freqs", nf);
310 rv = RadiationVector(nf, stokes_dim);
311 if (pbifs) {
312 *pbifs >> rv;
313 if (pbifs->fail()) {
314 ostringstream os;
315 os << "RadiationVector has wrong dimensions";
316 xml_data_parse_error(tag, os.str());
317 }
318 } else {
319 is_xml >> rv;
320 if (is_xml.fail()) {
321 ostringstream os;
322 os << "RadiationVector has wrong dimensions";
323 xml_data_parse_error(tag, os.str());
324 }
325 }
326
327 tag.read_from_stream(is_xml);
328 tag.check_name("/RadiationVector");
329}
330
332
338void xml_write_to_stream(ostream& os_xml,
339 const RadiationVector& rv,
340 bofstream* pbofs,
341 const String& name,
342 const Verbosity& verbosity) {
343 ArtsXMLTag open_tag(verbosity);
344 ArtsXMLTag close_tag(verbosity);
345
346 open_tag.set_name("RadiationVector");
347 if (name.length()) open_tag.add_attribute("name", name);
348 open_tag.add_attribute("Stokes", rv.stokes_dim);
349 open_tag.add_attribute("Freqs", rv.Frequencies());
350
351 open_tag.write_to_stream(os_xml);
352 os_xml << '\n';
353
355 if (pbofs)
356 *pbofs << rv;
357 else
358 os_xml << rv;
359
360 close_tag.set_name("/RadiationVector");
361 close_tag.write_to_stream(os_xml);
362
363 os_xml << '\n';
364}
365
366//=== Time ================================================================
367
369
374void xml_read_from_stream(istream& is_xml,
375 Time& t,
376 bifstream* pbifs [[maybe_unused]],
377 const Verbosity& verbosity) {
378 ArtsXMLTag tag(verbosity);
379
380 tag.read_from_stream(is_xml);
381 tag.check_name("Time");
382
383 Index version;
384 tag.get_attribute_value("version", version);
385 ARTS_USER_ERROR_IF (version not_eq 1,
386 "Your version of ARTS can only handle version 1 of Time");
387
388 is_xml >> t;
389 if (is_xml.fail()) {
390 xml_data_parse_error(tag, "Time is poorly formatted");
391 }
392
393 tag.read_from_stream(is_xml);
394 tag.check_name("/Time");
395}
396
398
404void xml_write_to_stream(ostream& os_xml,
405 const Time& t,
406 bofstream* pbofs [[maybe_unused]],
407 const String&,
408 const Verbosity& verbosity) {
409 ArtsXMLTag open_tag(verbosity);
410 ArtsXMLTag close_tag(verbosity);
411
412 open_tag.set_name("Time");
413 open_tag.add_attribute("version", t.Version());
414 open_tag.write_to_stream(os_xml);
415
417
418 os_xml << ' ' << t << ' ';
419
420 close_tag.set_name("/Time");
421 close_tag.write_to_stream(os_xml);
422 os_xml << '\n';
423}
424
425//=== AbsorptionLines ================================================================
426
428
433void xml_read_from_stream(istream& is_xml,
434 AbsorptionLines& al,
435 bifstream* pbifs,
436 const Verbosity& verbosity) {
437 static_assert(AbsorptionLines::version == 2, "The reading routine expects version 1 of the absorption lines data type to work");
438
439 ArtsXMLTag tag(verbosity);
440
441 tag.read_from_stream(is_xml);
442 tag.check_name("AbsorptionLines");
443
444 Index version;
445 if (tag.has_attribute("version")) {
446 tag.get_attribute_value("version", version);
447 } else {
448 version = 0;
449 }
450
452 AbsorptionLines::version < version,
453 "The version of this catalog is too new. You need to upgrade ARTS to use it.")
454
456 version < AbsorptionLines::version - 1 or
457 (pbifs and version not_eq AbsorptionLines::version),
458 "Using descoped version of the catalog; version: ",
459 version,
460 '\n',
461 "We only ever support limited number of versions. Your compilation supports versions ",
463 " and ",
465 " in ascii but only version ",
467 " in binary\n\n",
468 "To update from versions, please check-out the following branch, compile, and save your catalog again (as ascii):\n"
469 "0 to 1: 3b6565fb93702308c4cdd660ec63c71d63dcaf26\n"
470 "1 to 2: Current version\n")
471
472 // Number of lines
474 tag.get_attribute_value("nlines", nlines);
475
476 // Identity of the lines (Changes between versions)
478 if (version == 2) {
479 String id_str;
480 tag.get_attribute_value("id", id_str);
481 id = QuantumIdentifier(id_str);
482 } else if (version == 1) {
483 String spec;
484 tag.get_attribute_value("species", spec);
485
486 Index spec_ind = Species::find_species_index(spec);
487 ARTS_USER_ERROR_IF(spec_ind < 0, "Bad species index for: ", spec)
488 id.isotopologue_index = spec_ind;
489 }
490
491 // Cutoff type
492 String s_cutoff;
493 tag.get_attribute_value("cutofftype", s_cutoff);
494 const Absorption::CutoffType cutoff = Absorption::toCutoffTypeOrThrow(s_cutoff);
495
496 // Mirroring type
497 String s_mirroring;
498 tag.get_attribute_value("mirroringtype", s_mirroring);
499 const Absorption::MirroringType mirroring = Absorption::toMirroringTypeOrThrow(s_mirroring);
500
501 // Line population type
502 String s_population;
503 tag.get_attribute_value("populationtype", s_population);
504 const Absorption::PopulationType population = Absorption::toPopulationTypeOrThrow(s_population);
505
506 // Normalization type
507 String s_normalization;
508 tag.get_attribute_value("normalizationtype", s_normalization);
509 const Absorption::NormalizationType normalization = Absorption::toNormalizationTypeOrThrow(s_normalization);
510
511 // Shape type
512 String s_lineshapetype;
513 tag.get_attribute_value("lineshapetype", s_lineshapetype);
514 const LineShape::Type lineshapetype = LineShape::toTypeOrThrow(s_lineshapetype);
515
517 Numeric T0;
518 tag.get_attribute_value("T0", T0);
519
521 Numeric cutofffreq;
522 tag.get_attribute_value("cutofffreq", cutofffreq);
523
525 Numeric linemixinglimit;
526 tag.get_attribute_value("linemixinglimit", linemixinglimit);
527
529 Quantum::Number::LocalState meta_localstate;
530 String localquanta_str;
531 tag.get_attribute_value("localquanta", localquanta_str);
532 const Index nlocal = Quantum::Number::count_items(localquanta_str);
534 for (Index i = 0; i < nlocal; i++)
535 qn_key.push_back(
536 Quantum::Number::toType(Quantum::Number::items(localquanta_str, i)));
538 std::any_of(qn_key.begin(),
539 qn_key.end(),
540 [](auto& qn) {
541 return Quantum::Number::common_value_type(
542 Quantum::Number::common_value_type(qn),
543 Quantum::Number::ValueType::H) not_eq
544 Quantum::Number::ValueType::H;
545 }),
546 "Quantum number list contains a string type, this is not allowed: [",
547 qn_key,
548 ']')
549 meta_localstate.set_unsorted_qns(qn_key);
550
552 if (version == 1) {
553 String uid, lid;
554 tag.get_attribute_value("upperglobalquanta", uid);
555 tag.get_attribute_value("lowerglobalquanta", lid);
556 id.val = Quantum::Number::ValueList(uid, lid);
557 }
558
560 ArrayOfSpecies broadeningspecies;
561 bool selfbroadening;
562 bool bathbroadening;
563 tag.get_attribute_value("broadeningspecies", broadeningspecies, selfbroadening, bathbroadening);
564 if (selfbroadening) broadeningspecies.front() = id.Species();
565
566 String temperaturemodes;
567 tag.get_attribute_value("temperaturemodes", temperaturemodes);
568 auto metamodel = LineShape::MetaData2ModelShape(temperaturemodes);
569
570 al = AbsorptionLines(selfbroadening, bathbroadening,
571 nlines, cutoff, mirroring,
572 population, normalization,
573 lineshapetype, T0, cutofffreq,
574 linemixinglimit, id,
575 broadeningspecies, meta_localstate, metamodel);
576
577 if (pbifs) {
578 al.read(*pbifs);
579 if (pbifs->fail()) {
580 ostringstream os;
581 os << "AbsorptionLines has wrong dimensions";
582 xml_data_parse_error(tag, os.str());
583 }
584 } else {
585 is_xml >> al;
586 if (is_xml.fail()) {
587 ostringstream os;
588 os << "AbsorptionLines has wrong dimensions";
589 xml_data_parse_error(tag, os.str());
590 }
591 }
592
593 // Finalize the sorting because we have to
594 for (auto& line: al.lines) line.localquanta.val.finalize();
595
596 tag.read_from_stream(is_xml);
597 tag.check_name("/AbsorptionLines");
598
600 if (out3.sufficient_priority_screen()) {
601 if (not al.quantumidentity.good()) {
602 out3 << "Bad data in absorption band " << al.MetaData() << '\n';
603 }
604 for (auto& line : al.lines) {
605 if (not line.localquanta.good()) {
606 out3 << "Bad data in absorption band " << al.MetaData() << '\n'
607 << "Line: " << line << '\n';
608 }
609 }
610 }
611}
612
614
620void xml_write_to_stream(ostream& os_xml,
621 const AbsorptionLines& al,
622 bofstream* pbofs,
623 const String&,
624 const Verbosity& verbosity) {
625 ArtsXMLTag open_comment_tag(verbosity);
626 ArtsXMLTag close_comment_tag(verbosity);
627 open_comment_tag.set_name("comment");
628 open_comment_tag.write_to_stream(os_xml);
629 os_xml << al.MetaData();
630 close_comment_tag.set_name("/comment");
631 close_comment_tag.write_to_stream(os_xml);
632 os_xml << '\n';
633
634 ArtsXMLTag open_tag(verbosity);
635 ArtsXMLTag close_tag(verbosity);
636
637 open_tag.set_name("AbsorptionLines");
638 open_tag.add_attribute("version", al.version);
639 open_tag.add_attribute("nlines", al.NumLines());
640 open_tag.add_attribute("cutofftype", Absorption::toString(al.cutoff));
641 open_tag.add_attribute("mirroringtype", Absorption::toString(al.mirroring));
642 open_tag.add_attribute("populationtype", Absorption::toString(al.population));
643 open_tag.add_attribute("normalizationtype", Absorption::toString(al.normalization));
644 open_tag.add_attribute("lineshapetype", LineShape::toString(al.lineshapetype));
645 open_tag.add_attribute("T0", al.T0);
646 open_tag.add_attribute("cutofffreq", al.cutofffreq);
647 open_tag.add_attribute("linemixinglimit", al.linemixinglimit);
648
649// open_tag.add_attribute("species", al.SpeciesName());
650// open_tag.add_attribute("localquanta", al.LocalQuanta());
651// open_tag.add_attribute("upperglobalquanta", al.UpperQuantumNumbers());
652// open_tag.add_attribute("lowerglobalquanta", al.LowerQuantumNumbers());
653 open_tag.add_attribute("id", var_string(al.quantumidentity));
654 const String localquanta_str =
655 al.NumLines() ? al.lines.front().localquanta.keys() : "";
656 open_tag.add_attribute("localquanta", localquanta_str);
657
658 open_tag.add_attribute("broadeningspecies", al.broadeningspecies, al.selfbroadening, al.bathbroadening);
659 open_tag.add_attribute("temperaturemodes", al.LineShapeMetaData());
660
661 open_tag.write_to_stream(os_xml);
662 os_xml << '\n';
663
665 if (pbofs)
666 al.write(*pbofs);
667 else
668 os_xml << al;
669
670 close_tag.set_name("/AbsorptionLines");
671 close_tag.write_to_stream(os_xml);
672
673 os_xml << '\n';
674}
675
677// Dummy funtion for groups for which
678// IO function have not yet been implemented
680
681// FIXME: These should be implemented, sooner or later...
682
684 Timer&,
685 bifstream* /* pbifs */,
686 const Verbosity&) {
687 ARTS_USER_ERROR_IF(true, "Method not implemented!");
688}
689
691 const Timer&,
692 bofstream* /* pbofs */,
693 const String& /* name */,
694 const Verbosity&) {
695 ARTS_USER_ERROR_IF(true, "Method not implemented!");
696}
Contains the absorption namespace.
Absorption::Lines AbsorptionLines
The global header file for ARTS.
This can be used to make arrays out of anything.
Definition: array.h:48
The ARTS XML tag class.
Definition: xml_io.h:45
void add_attribute(const String &aname, const std::vector< QuantumNumberType > &value)
Adds value of attribute as type std::vector<QuantumNumberType> to tag.
Definition: xml_io.cc:42
void get_attribute_value(const String &aname, SpeciesTag &value)
Returns value of attribute as type SpeciesTag.
Definition: xml_io.cc:70
A list of many quantum numbers. Should always remain sorted.
Implements rational numbers to work with other ARTS types.
Definition: rational.h:43
bool has_attribute(const String &aname) const
Returns if the attribute exists or not.
Definition: xml_io_base.cc:125
void write_to_stream(ostream &os)
Write XML tag.
Definition: xml_io_base.cc:322
void check_name(const String &expected_name)
Check tag name.
Definition: xml_io_base.cc:54
void read_from_stream(istream &is)
Reads next XML tag.
Definition: xml_io_base.cc:201
void set_name(const String &new_name)
Definition: xml_io_base.h:78
Binary output file stream class.
Definition: bifstream.h:43
Binary output file stream class.
Definition: bofstream.h:42
Input manipulator class for doubles to enable nan and inf parsing.
Definition: double_imanip.h:42
Helper macros for debugging.
std::string var_string(Args &&... args)
Definition: debug.h:36
#define ARTS_USER_ERROR_IF(condition,...)
Definition: debug.h:134
constexpr std::string_view toString(EnergyLevelMapType x) noexcept
#define nlines
NUMERIC Numeric
The type to use for all floating point numbers.
Definition: matpack.h:33
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
Declarations having to do with the four output streams.
#define CREATE_OUT3
Definition: messages.h:206
Numeric cutoff
Model MetaData2ModelShape(const String &s)
constexpr std::string_view items(std::string_view s, std::size_t i) noexcept
Get a view of a number of space-separated items from the list.
constexpr Index count_items(std::string_view s) noexcept
Count all space-separated items in s.
constexpr Index find_species_index(const Species spec, const std::string_view isot) noexcept
Quantum::Number::GlobalState QuantumIdentifier
Numeric T0
Reference temperature for all parameters of the lines.
PopulationType population
Line population distribution.
static constexpr Index version
bool bathbroadening
Does the line broadening have bath broadening.
Array< SingleLine > lines
A list of individual lines.
Index NumLines() const noexcept
Number of lines.
bofstream & write(bofstream &os) const
Binary write for Lines.
Numeric linemixinglimit
linemixing limit
NormalizationType normalization
Line normalization type.
bifstream & read(bifstream &is)
Binary read for Lines.
String LineShapeMetaData() const noexcept
Meta data for the line shape if it exists.
LineShape::Type lineshapetype
Type of line shape.
Numeric cutofffreq
cutoff frequency
MirroringType mirroring
Mirroring type.
CutoffType cutoff
cutoff type, by band or by line
ArrayOfSpecies broadeningspecies
A list of broadening species.
String MetaData() const
Returns a printable statement about the lines.
bool selfbroadening
Does the line broadening have self broadening.
QuantumIdentifier quantumidentity
Catalog ID.
Holds all information required for individual partial derivatives.
Definition: jacobian.h:107
Numeric perturbation
Perturbations for methods where theoretical computations are impossible or plain slow.
Definition: jacobian.h:124
String string_id
ID for some of the Special types of partial derivatives.
Definition: jacobian.h:133
bool needArrayOfSpeciesTag() const noexcept
Does this type need the ArrayOfSpeciesTag?
Definition: jacobian.h:306
void TargetSubType(const std::string_view &s) noexcept
Sets sub target based on a string.
Definition: jacobian.h:206
bool TargetSubTypeOK() const noexcept
Are we good?
Definition: jacobian.h:250
ArrayOfSpeciesTag species_array_id
ID for some of the Special types of partial derivatives.
Definition: jacobian.h:130
std::string_view TargetType() const noexcept
Return type as string.
Definition: jacobian.h:198
bool needString() const noexcept
Does this type need the String?
Definition: jacobian.h:311
QuantumIdentifier qid
ID for the Line types of partial derivatives.
Definition: jacobian.h:127
bool needQuantumIdentity() const noexcept
Does this type need the QuantumIdentifier?
Definition: jacobian.h:301
A logical struct for global quantum numbers with species identifiers.
bool good() const
Test if there are bad quantum numbers (undefined ones) or if the isotopologue is not a normal target.
A logical struct for local quantum numbers.
void set_unsorted_qns(const Array< Type > &vals)
Radiation Vector for Stokes dimension 1-4.
Index Frequencies() const
Get frequency count.
Class to handle time in ARTS.
Definition: artstime.h:43
Index Version() const noexcept
Definition: artstime.h:48
Class to keep track of Transmission Matrices for Stokes Dim 1-4.
Index Frequencies() const
Number of frequencies.
void xml_data_parse_error(ArtsXMLTag &tag, String str_error)
Throws XML parser runtime error.
Definition: xml_io.cc:179
This file contains basic functions to handle XML data files.
void xml_set_stream_precision(ostream &os)
Definition: xml_io_base.cc:705
void xml_write_to_stream(ostream &os_xml, const JacobianTarget &jt, bofstream *pbofs, const String &name, const Verbosity &verbosity)
Writes JacobianTarget to XML output stream.
void xml_read_from_stream(istream &is_xml, JacobianTarget &jt, bifstream *pbifs, const Verbosity &verbosity)
Reads JacobianTarget from XML input stream.