ARTS 2.5.0 (git: 9ee3ac6c)
arts_api_classes.cc
Go to the documentation of this file.
1/* Copyright (C) 2020 Richard Larsson <ric.larsson@gmail.com>
2
3 This program is free software; you can redistribute it and/or
4 modify it under the terms of the GNU General Public License as
5 published by the Free Software Foundation; either version 2 of the
6 License, or (at your option) any 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
29#include "arts_api_classes.h"
30
31#include "absorption.h"
32#include "absorptionlines.h"
33#include "covariance_matrix.h"
34#include "energylevelmap.h"
35#include "global_data.h"
36#include "lineshapemodel.h"
37#include "quantum.h"
38#include "supergeneric.h"
39#include "xml_io.h"
40#include "zeemandata.h"
41
42#ifdef TIME_SUPPORT
43#include <unistd.h>
44#endif
45
46#define BasicInterfaceCAPI(TYPE) \
47void * create##TYPE() \
48{ \
49 return new TYPE; \
50} \
51 \
52void delete##TYPE(void * data) \
53{ \
54 delete static_cast<TYPE *>(data); \
55} \
56 \
57void print##TYPE(void * data) \
58{ \
59 std::cout << (*static_cast<TYPE *>(data)) << std::endl; \
60}
61
62
63#define GetterSetterCAPI(TYPE, VALUE, BASETYPE) \
64BASETYPE get##VALUE##TYPE(void * data) \
65{ \
66 return static_cast<TYPE *>(data) -> VALUE (); \
67} \
68void set##VALUE##TYPE(void * data, BASETYPE newval) \
69{ \
70 static_cast<TYPE *>(data) -> VALUE (newval); \
71}
72
73
74#define EnumGetterSetterCAPI(TYPE, VALUE, ENUM) \
75Index get##VALUE##TYPE(void * data) \
76{ \
77 return Index(static_cast<TYPE *>(data) -> VALUE ()); \
78} \
79Index set##VALUE##TYPE(void * data, Index newval) \
80{ \
81 if (static_cast<TYPE *>(data) -> validIndexFor##VALUE (newval)) { \
82 static_cast<TYPE *>(data) -> VALUE (ENUM(newval)); \
83 return EXIT_SUCCESS; \
84 } else { \
85 return EXIT_FAILURE; \
86 } \
87} \
88Index string2index##VALUE##TYPE(void * data, char * newval) \
89{ \
90 return Index(static_cast<TYPE *>(data) -> string2##VALUE(newval)); \
91}
92
93// WARNING: Must manually delete the strings!!!
94#define StringEnumGetterSetterCAPI(TYPE, ELEM) \
95bool enumset ## ELEM ## TYPE (void * data, char * in) { \
96 auto x = static_cast<TYPE *>(data); \
97 x -> ELEM(in); \
98 return not x -> ELEM ## OK(); \
99} \
100void * enumget ## ELEM ## TYPE (void * data) { \
101 auto x = static_cast<TYPE *>(data); \
102 String * out = new String(x -> ELEM()); \
103 return out; \
104}
105
106
107#define VoidGetterCAPI(TYPE, VALUE) \
108void * get##VALUE##TYPE(void * data) \
109{ \
110 return &static_cast<TYPE *>(data) -> VALUE(); \
111}
112
113#define VoidStructGetterCAPI(TYPE, VALUE) \
114void * get##VALUE##TYPE(void * data) \
115{ \
116 return &static_cast<TYPE *>(data) -> VALUE; \
117}
118
119
120#define BasicInputOutputCAPI(TYPE) \
121Index xmlread##TYPE(void * data, char * filepath) \
122{ \
123 try { \
124 xml_read_from_file(filepath, *static_cast<TYPE *>(data), Verbosity()); \
125 return EXIT_SUCCESS; \
126 } catch (std::runtime_error& e) { \
127 return EXIT_FAILURE; \
128 } \
129} \
130 \
131Index xmlsave##TYPE(void * data, char * filepath, Index filetype, Index clobber) \
132{ \
133 try { \
134 xml_write_to_file(filepath, *static_cast<const TYPE *>(data), FileType(filetype), not clobber, Verbosity()); \
135 return EXIT_SUCCESS; \
136 } catch (std::runtime_error& e) { \
137 return EXIT_FAILURE; \
138 } \
139}
140
141
142#define VoidArrayCAPI(TYPE) \
143Index size##TYPE(void * data) \
144{ \
145 return static_cast<TYPE *>(data) -> size(); \
146} \
147void resize##TYPE(Index n, void * data) \
148{ \
149 static_cast<TYPE *>(data) -> resize(n); \
150} \
151void * getelem##TYPE(Index i, void * data) \
152{ \
153 return &static_cast<TYPE *>(data) -> operator[](i); \
154}
155
156
157#define VoidArrayElemCAPI(TYPE, ELEM) \
158Index size##ELEM##TYPE(void * data) \
159{ \
160 return static_cast<TYPE *>(data) -> ELEM().size(); \
161} \
162void resize##ELEM##TYPE(Index n, void * data) \
163{ \
164 static_cast<TYPE *>(data) -> ELEM().resize(n); \
165} \
166void * getelem##ELEM##TYPE(Index i, void * data) \
167{ \
168 return &static_cast<TYPE *>(data) -> ELEM()[i]; \
169}
170
171
172// Index
175Index getIndex(void * data) { return *static_cast<Index *>(data); }
176void setIndex(void * data, Index newval) { *static_cast<Index *>(data) = newval; }
183
184
185// Numeric
190Index xmlreadArrayOfNumeric(void *, char *) {return 1;}
191Index xmlsaveArrayOfNumeric(void *, char *, Index, Index) {return 1;}
192Numeric getNumeric(void * data) { return *static_cast<Numeric *>(data); }
193void setNumeric(void * data, Numeric newval) { *static_cast<Numeric *>(data) = newval; }
194
195
196// ZeemanModel
200
201
202// Rational
207void simplifyRational(void * data) { static_cast<Rational *>(data)->simplify_in_place(); }
208
209// LineShapeTemperatureModel
211void * getLineShapeTemperatureModelString(void * data) {
212 return new String(toString(*static_cast<LineShapeTemperatureModel *>(data)));
213}
215 auto x = LineShape::toTemperatureModel(val);
216 if (good_enum(x)) {
217 *static_cast<LineShapeTemperatureModel *>(data) = x;
218 return EXIT_SUCCESS;
219 } else {
220 return EXIT_FAILURE;
221 }
222}
223
224
225// LineShape::ModelParameters
232
233
234// LineShape::SingleSpeciesModel
245
246
247// LineShapeType
249void * getLineShapeTypeString(void * data) {
250 return new String(toString(*static_cast<LineShapeType *>(data)));
251}
252int setLineShapeTypeString(void * data, char * val) {
253 auto x = LineShape::toType(val);
254 if (good_enum(x)) {
255 *static_cast<LineShapeType *>(data) = x;
256 return EXIT_SUCCESS;
257 } else {
258 return EXIT_FAILURE;
259 }
260}
261
262// LineShape::Model
265
266
267// Absorption::SingleLine
277VoidArrayElemCAPI(AbsorptionSingleLine, LowerQuantumNumbers)
279
280// QuantumNumberType
281BasicInterfaceCAPI(QuantumNumberType)
282void * getQuantumNumberTypeString(void * data) {
283 return new String(toString(*static_cast<QuantumNumberType *>(data)));
284}
285int setQuantumNumberTypeString(void * data, char * val) {
286 auto x = string2quantumnumbertype(val);
287 if (good_enum(x)) {
288 *static_cast<QuantumNumberType *>(data) = x;
289 return EXIT_SUCCESS;
290 } else {
291 return EXIT_FAILURE;
292 }
293}
294
295// QuantumNumbers
297void * getelemQuantumNumbers(Index i, void * data) { return &static_cast<QuantumNumbers *>(data)->operator[](i); }
298Index sizeQuantumNumbers() { return Index(QuantumNumberType::FINAL); }
299Index string2quantumnumbersindex(char * str) { return Index(string2quantumnumbertype(str)); }
300void * getQuantumNumbersString(void * data) { return new String(static_cast<QuantumNumbers *>(data) -> toString()); }
301
302// Species::Species
304 return new Species::Species(Species::Species::FINAL);
305}
306void deleteSpecies(void * data) {
307 delete static_cast<Species::Species *>(data);
308}
309void printSpecies(void * data) {
310 std::cout << *static_cast<Species::Species *>(data);
311}
312int setSpeciesLongName(void * data, char * spec) {
313 Species::Species x = Species::toSpecies(spec);
314 if (good_enum(x)) {
315 *static_cast<Species::Species *>(data) = x;
316 return EXIT_SUCCESS;
317 } else {
318 return EXIT_FAILURE;
319 }
320}
321int setSpeciesShortName(void * data, char * spec) {
322 Species::Species x = Species::fromShortName(spec);
323 if (good_enum(x)) {
324 *static_cast<Species::Species *>(data) = x;
325 return EXIT_SUCCESS;
326 } else {
327 return EXIT_FAILURE;
328 }
329}
330void * getSpeciesLongName(void * data) {
331 return new String(Species::toString(*static_cast<Species::Species *>(data)));
332}
333void * getSpeciesShortName(void * data) {
334 return new String(Species::toShortName(*static_cast<Species::Species *>(data)));
335}
337Index xmlreadArrayOfSpecies(void *, char *) {return 1;}
338Index xmlsaveArrayOfSpecies (void *, char *, Index, Index) {return 1;}
340
341// SpeciesIsotopeRecord
343Index getIndexSpeciesIsotopeRecordFromNames(char * spec, char * isot) {
344 return Species::find_species_index(spec, isot);
345}
349}
351 return Index(Species::Isotopologues.size());
352}
354 if (i < 0 or i >= nelemSpeciesIsotopeRecordDefined()) {
355 return EXIT_FAILURE;
356 } else {
358 return EXIT_SUCCESS;
359 }
360}
361
363 return new Species::Species(static_cast<SpeciesIsotopeRecord *>(data) -> spec);
364}
366 return new String(static_cast<SpeciesIsotopeRecord *>(data) -> isotname);
367}
369 return static_cast<SpeciesIsotopeRecord *>(data) -> mass;
370}
372 return static_cast<SpeciesIsotopeRecord *>(data) -> gi;
373}
374
375// SpeciesIsotopologueRatios
378Numeric * getdataSpeciesIsotopologueRatios(void * data) {return static_cast<SpeciesIsotopologueRatios *>(data) -> data.begin();}
379
380// QuantumIdentifierType
382void * getQuantumIdentifierTypeString(void * data) {
383 return new String(toString(*static_cast<QuantumIdentifierType *>(data)));
384}
385int setQuantumIdentifierTypeString(void * data, char * val) {
386 auto x = Quantum::toIdentifierType(val);
387 if (good_enum(x)) {
388 *static_cast<QuantumIdentifierType *>(data) = x;
389 return EXIT_SUCCESS;
390 } else {
391 return EXIT_FAILURE;
392 }
393}
394
395// QuantumIdentifier
402Index fromstringQuantumIdentifier(void * data, char * str) {
403 try {
404 static_cast<QuantumIdentifier *>(data) -> SetFromString(str);
405 return EXIT_SUCCESS;
406 } catch(...) {
407 }
408 return EXIT_FAILURE;
409}
410
411// ArrayOfQuantumIdentifier
415
416// SpeciesTagType
418void * getSpeciesTagTypeString(void * data) {
419 return new String(toString(*static_cast<SpeciesTagType *>(data)));
420}
421int setSpeciesTagTypeString(void * data, char * val) {
422 auto x = Species::toTagType(val);
423 if (good_enum(x)) {
424 *static_cast<SpeciesTagType *>(data) = x;
425 return EXIT_SUCCESS;
426 } else {
427 return EXIT_FAILURE;
428 }
429}
430
431// SpeciesTag
438VoidStructGetterCAPI(SpeciesTag, cia_2nd_species)
446
447void * getNameSpeciesTag(void * data)
448{
449 return new String(static_cast<SpeciesTag *>(data) -> Name());
450}
451
453{
454 try {
455 *static_cast<SpeciesTag *>(data) = SpeciesTag(newdata);
456 return EXIT_SUCCESS;
457 } catch(std::exception& e) {
458 return EXIT_FAILURE;
459 }
460}
461
462
463// AbsorptionNormalizationType
465void * getAbsorptionNormalizationTypeString(void * data) {
466 return new String(toString(*static_cast<AbsorptionNormalizationType *>(data)));
467}
469 auto x = Absorption::toNormalizationType(val);
470 if (good_enum(x)) {
471 *static_cast<AbsorptionNormalizationType *>(data) = x;
472 return EXIT_SUCCESS;
473 } else {
474 return EXIT_FAILURE;
475 }
476}
477
478
479// AbsorptionPopulationType
481void * getAbsorptionPopulationTypeString(void * data) {
482 return new String(toString(*static_cast<AbsorptionPopulationType *>(data)));
483}
485 auto x = Absorption::toPopulationType(val);
486 if (good_enum(x)) {
487 *static_cast<AbsorptionPopulationType *>(data) = x;
488 return EXIT_SUCCESS;
489 } else {
490 return EXIT_FAILURE;
491 }
492}
493
494
495// AbsorptionMirroringType
497void * getAbsorptionMirroringTypeString(void * data) {
498 return new String(toString(*static_cast<AbsorptionMirroringType *>(data)));
499}
500int setAbsorptionMirroringTypeString(void * data, char * val) {
501 auto x = Absorption::toMirroringType(val);
502 if (good_enum(x)) {
503 *static_cast<AbsorptionMirroringType *>(data) = x;
504 return EXIT_SUCCESS;
505 } else {
506 return EXIT_FAILURE;
507 }
508}
509
510
511// AbsorptionCutoffType
513void * getAbsorptionCutoffTypeString(void * data) {
514 return new String(toString(*static_cast<AbsorptionCutoffType *>(data)));
515}
516int setAbsorptionCutoffTypeString(void * data, char * val) {
517 auto x = Absorption::toCutoffType(val);
518 if (good_enum(x)) {
519 *static_cast<AbsorptionCutoffType *>(data) = x;
520 return EXIT_SUCCESS;
521 } else {
522 return EXIT_FAILURE;
523 }
524}
525
526// AbsorptionLines
535VoidGetterCAPI(AbsorptionLines, Normalization)
539VoidGetterCAPI(AbsorptionLines, QuantumIdentity)
548Index sizeLocalQuantaAbsorptionLines(void * data) { return static_cast<std::vector<QuantumNumberType> *>(data) -> size(); }
549void resizeLocalQuantaAbsorptionLines(Index n, void * data) { static_cast<std::vector<QuantumNumberType> *>(data) -> resize(n); }
551 if (i >= 0 and i < Index(static_cast<std::vector<QuantumNumberType> *>(data) -> size()))
552 return & static_cast<std::vector<QuantumNumberType> *>(data) -> operator[](i);
553 else
554 return nullptr;
555}
556void * getLocalQuantaAbsorptionLines(void * data) { return & static_cast<AbsorptionLines *>(data) -> LocalQuanta(); }
557void printmetaAbsorptionLines(void * data) { std::cout << static_cast<AbsorptionLines *>(data) -> MetaData() << std::endl; }
558Index isAbsorptionLinesOK(void * data) { return Index(static_cast<AbsorptionLines *>(data) -> OK()); }
560 String *s = new String(static_cast<AbsorptionLines *>(data)->SpeciesName());
561 return (void *)s;
562}
563
564// EnergyLevelMap
571bool getOKEnergyLevelMap(void * data) {return static_cast<EnergyLevelMap *>(data) -> OK();}
572
573
574// Vector
583void resizeVector(Index n, void * data) {static_cast<Vector *>(data) -> resize(n);}
584Index nelemVector(void * data) {return static_cast<Vector *>(data) -> nelem();}
585Numeric * getDataVector(void * data) {return static_cast<Vector *>(data) -> get_c_array();}
586
587
588// Matrix
597void resizeMatrix(Index nrows, Index ncols, void * data) {static_cast<Matrix *>(data) -> resize(nrows, ncols);}
598Index rowsMatrix(void * data) {return static_cast<Matrix *>(data) -> nrows();}
599Index colsMatrix(void * data) {return static_cast<Matrix *>(data) -> ncols();}
600Numeric * getDataMatrix(void * data) {return static_cast<Matrix *>(data) -> get_c_array();}
601
602
603// Tensor3
612void resizeTensor3(Index npages, Index nrows, Index ncols, void * data) {static_cast<Tensor3 *>(data) -> resize(npages, nrows, ncols);}
613Index pagesTensor3(void * data) {return static_cast<Tensor3 *>(data) -> npages();}
614Index rowsTensor3(void * data) {return static_cast<Tensor3 *>(data) -> nrows();}
615Index colsTensor3(void * data) {return static_cast<Tensor3 *>(data) -> ncols();}
616Numeric * getDataTensor3(void * data) {return static_cast<Tensor3 *>(data) -> get_c_array();}
617
618
619// Tensor4
625// VoidArrayCAPI(ArrayOfArrayOfTensor4)
626// BasicInterfaceCAPI(ArrayOfArrayOfTensor4)
627// BasicInputOutputCAPI(ArrayOfArrayOfTensor4)
628void resizeTensor4(Index nbooks, Index npages, Index nrows, Index ncols, void * data) {static_cast<Tensor4 *>(data) -> resize(nbooks, npages, nrows, ncols);}
629Index booksTensor4(void * data) {return static_cast<Tensor4 *>(data) -> nbooks();}
630Index pagesTensor4(void * data) {return static_cast<Tensor4 *>(data) -> npages();}
631Index rowsTensor4(void * data) {return static_cast<Tensor4 *>(data) -> nrows();}
632Index colsTensor4(void * data) {return static_cast<Tensor4 *>(data) -> ncols();}
633Numeric * getDataTensor4(void * data) {return static_cast<Tensor4 *>(data) -> get_c_array();}
634
635
636// Tensor5
642// VoidArrayCAPI(ArrayOfArrayOfTensor5)
643// BasicInterfaceCAPI(ArrayOfArrayOfTensor5)
644// BasicInputOutputCAPI(ArrayOfArrayOfTensor5)
645void resizeTensor5(Index nshelves, Index nbooks, Index npages, Index nrows, Index ncols, void * data) {static_cast<Tensor5 *>(data) -> resize(nshelves, nbooks, npages, nrows, ncols);}
646Index shelvesTensor5(void * data) {return static_cast<Tensor5 *>(data) -> nshelves();}
647Index booksTensor5(void * data) {return static_cast<Tensor5 *>(data) -> nbooks();}
648Index pagesTensor5(void * data) {return static_cast<Tensor5 *>(data) -> npages();}
649Index rowsTensor5(void * data) {return static_cast<Tensor5 *>(data) -> nrows();}
650Index colsTensor5(void * data) {return static_cast<Tensor5 *>(data) -> ncols();}
651Numeric * getDataTensor5(void * data) {return static_cast<Tensor5 *>(data) -> get_c_array();}
652
653
654// Tensor6
663void resizeTensor6(Index nvitrines, Index nshelves, Index nbooks, Index npages, Index nrows, Index ncols, void * data) {static_cast<Tensor6 *>(data) -> resize(nvitrines, nshelves, nbooks, npages, nrows, ncols);}
664Index vitrinesTensor6(void * data) {return static_cast<Tensor6 *>(data) -> nvitrines();}
665Index shelvesTensor6(void * data) {return static_cast<Tensor6 *>(data) -> nshelves();}
666Index booksTensor6(void * data) {return static_cast<Tensor6 *>(data) -> nbooks();}
667Index pagesTensor6(void * data) {return static_cast<Tensor6 *>(data) -> npages();}
668Index rowsTensor6(void * data) {return static_cast<Tensor6 *>(data) -> nrows();}
669Index colsTensor6(void * data) {return static_cast<Tensor6 *>(data) -> ncols();}
670Numeric * getDataTensor6(void * data) {return static_cast<Tensor6 *>(data) -> get_c_array();}
671
672
673// Tensor7
679// VoidArrayCAPI(ArrayOfArrayOfTensor7)
680// BasicInterfaceCAPI(ArrayOfArrayOfTensor7)
681// BasicInputOutputCAPI(ArrayOfArrayOfTensor7)
682void resizeTensor7(Index nlibraries, Index nvitrines, Index nshelves, Index nbooks, Index npages, Index nrows, Index ncols, void * data) {static_cast<Tensor7 *>(data) -> resize(nlibraries, nvitrines, nshelves, nbooks, npages, nrows, ncols);}
683Index librariesTensor7(void * data) {return static_cast<Tensor7 *>(data) -> nlibraries();}
684Index vitrinesTensor7(void * data) {return static_cast<Tensor7 *>(data) -> nvitrines();}
685Index shelvesTensor7(void * data) {return static_cast<Tensor7 *>(data) -> nshelves();}
686Index booksTensor7(void * data) {return static_cast<Tensor7 *>(data) -> nbooks();}
687Index pagesTensor7(void * data) {return static_cast<Tensor7 *>(data) -> npages();}
688Index rowsTensor7(void * data) {return static_cast<Tensor7 *>(data) -> nrows();}
689Index colsTensor7(void * data) {return static_cast<Tensor7 *>(data) -> ncols();}
690Numeric * getDataTensor7(void * data) {return static_cast<Tensor7 *>(data) -> get_c_array();}
691
692
693// PropagationMatrix
703Index stokesPropagationMatrix(void * data) {return static_cast<PropagationMatrix *>(data) -> StokesDimensions();}
704Index frequenciesPropagationMatrix(void * data) {return static_cast<PropagationMatrix *>(data) -> NumberOfFrequencies();}
705Index zenithsPropagationMatrix(void * data) {return static_cast<PropagationMatrix *>(data) -> NumberOfZenithAngles();}
706Index azimuthsPropagationMatrix(void * data) {return static_cast<PropagationMatrix *>(data) -> NumberOfAzimuthAngles();}
708{
709 if (s >= 0 and s < 5 and f >= 0 and z >= 0 and a >= 0) {
710 static_cast<PropagationMatrix *>(data) -> operator=(PropagationMatrix(f, s, z, a, v));
711 return EXIT_SUCCESS;
712 } else {
713 return EXIT_FAILURE;
714 }
715}
716bool getOKPropagationMatrix(void * data) {return static_cast<PropagationMatrix *>(data) -> OK();}
717
718
719// StokesVector
729Index stokesStokesVector(void * data) {return static_cast<StokesVector *>(data) -> StokesDimensions();}
730Index frequenciesStokesVector(void * data) {return static_cast<StokesVector *>(data) -> NumberOfFrequencies();}
731Index zenithsStokesVector(void * data) {return static_cast<StokesVector *>(data) -> NumberOfZenithAngles();}
732Index azimuthsStokesVector(void * data) {return static_cast<StokesVector *>(data) -> NumberOfAzimuthAngles();}
734{
735 if (s >= 0 and s < 5 and f >= 0 and z >= 0 and a >= 0) {
736 static_cast<StokesVector *>(data) -> operator=(StokesVector(f, s, z, a, v));
737 return EXIT_SUCCESS;
738 } else {
739 return EXIT_FAILURE;
740 }
741}
742bool getOKStokesVector(void * data) {return static_cast<StokesVector *>(data) -> OK();}
743
744
745// String
754void setString(void * data, char * newdata) {static_cast<String *>(data) -> operator=(String(newdata));}
755char * getString(void * data) {return const_cast<char *>(static_cast<String *>(data) -> data());}
756
757
758// GridPos
766
767
768// LagrangeInterpolation
775Index xmlreadArrayOfLagrangeInterpolation(void *, char *) {return 1;}
777
778
779// Ppath
780// BasicInterfaceCAPI(Ppath)
781void * createPpath() {return new Ppath;}
782void deletePpath(void * data) {delete static_cast<Ppath *>(data);}
783void printPpath(void *) {std::cout << std::endl;}
789VoidStructGetterCAPI(Ppath, start_pos)
791VoidStructGetterCAPI(Ppath, start_lstep)
805void * createArrayOfPpath() {return new ArrayOfPpath;}
806void deleteArrayOfPpath(void * data) {delete static_cast<ArrayOfPpath *>(data);}
807void printArrayOfPpath(void *) {std::cout << std::endl;}
809
810
811// TransmissionMatrix
820Numeric * getMat1TransmissionMatrix(Index i, void * data) {return static_cast<TransmissionMatrix *>(data) -> Mat1(i).data();}
821Numeric * getMat2TransmissionMatrix(Index i, void * data) {return static_cast<TransmissionMatrix *>(data) -> Mat2(i).data();}
822Numeric * getMat3TransmissionMatrix(Index i, void * data) {return static_cast<TransmissionMatrix *>(data) -> Mat3(i).data();}
823Numeric * getMat4TransmissionMatrix(Index i, void * data) {return static_cast<TransmissionMatrix *>(data) -> Mat4(i).data();}
824void setTransmissionMatrix(void * data, Index stokes, Index freqs) {static_cast<TransmissionMatrix *>(data) -> operator=(TransmissionMatrix(freqs, stokes));}
825Index getStokesDimTransmissionMatrix(void * data) {return static_cast<TransmissionMatrix *>(data) -> StokesDim();}
826Index getFrequenciesTransmissionMatrix(void * data) {return static_cast<TransmissionMatrix *>(data) -> Frequencies();}
827
828
829// RadiationVector
838Numeric * getVec1RadiationVector(Index i, void * data) {return static_cast<RadiationVector *>(data) -> Vec1(i).data();}
839Numeric * getVec2RadiationVector(Index i, void * data) {return static_cast<RadiationVector *>(data) -> Vec2(i).data();}
840Numeric * getVec3RadiationVector(Index i, void * data) {return static_cast<RadiationVector *>(data) -> Vec3(i).data();}
841Numeric * getVec4RadiationVector(Index i, void * data) {return static_cast<RadiationVector *>(data) -> Vec4(i).data();}
842void setRadiationVector(void * data, Index stokes, Index freqs) {static_cast<RadiationVector *>(data) -> operator=(RadiationVector(freqs, stokes));}
843Index getStokesDimRadiationVector(void * data) {return static_cast<RadiationVector *>(data) -> StokesDim();}
844Index getFrequenciesRadiationVector(void * data) {return static_cast<RadiationVector *>(data) -> Frequencies();}
845
846
847// GriddedField1
856Index get_dimGriddedField1(void * data) {return static_cast<GriddedField1 *>(data) -> get_dim();}
857Index get_grid_typeIndexGriddedField1(Index i, void * data) {return Index(static_cast<GriddedField1 *>(data) -> get_grid_type(i));}
858Index get_grid_sizeGriddedField1(Index i, void * data) {return static_cast<GriddedField1 *>(data) -> get_grid_size(i);}
859char * get_nameGriddedField1(void * data) {return const_cast<char *>(static_cast<GriddedField1 *>(data) -> get_name().data());}
860void set_nameGriddedField1(void * data, char * newdata) {static_cast<GriddedField1 *>(data) -> set_name(newdata);}
861char * get_grid_nameGriddedField1(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField1 *>(data) -> get_grid_name(i).data());}
862void set_grid_nameGriddedField1(Index i, void * data, char * newdata) {static_cast<GriddedField1 *>(data) -> set_grid_name(i, newdata);}
863void * get_numeric_gridGriddedField1(Index i, void * data) {return &static_cast<GriddedField1 *>(data) -> get_numeric_grid(i);}
864void * get_string_gridGriddedField1(Index i, void * data) {return &static_cast<GriddedField1 *>(data) -> get_string_grid(i);}
865void set_gridGriddedField1(Index i, void * data, void * newdata, bool NumericType)
866{
867 if (NumericType)
868 static_cast<GriddedField1 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
869 else
870 static_cast<GriddedField1 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
871}
872void * dataGriddedField1(void * data) {return &static_cast<GriddedField1 *>(data) -> data;}
873bool checksizeGriddedField1(void * data) {return static_cast<GriddedField1 *>(data) -> checksize();}
874
875
876// GriddedField2
885Index get_dimGriddedField2(void * data) {return static_cast<GriddedField2 *>(data) -> get_dim();}
886Index get_grid_typeIndexGriddedField2(Index i, void * data) {return Index(static_cast<GriddedField2 *>(data) -> get_grid_type(i));}
887Index get_grid_sizeGriddedField2(Index i, void * data) {return static_cast<GriddedField2 *>(data) -> get_grid_size(i);}
888char * get_nameGriddedField2(void * data) {return const_cast<char *>(static_cast<GriddedField2 *>(data) -> get_name().data());}
889void set_nameGriddedField2(void * data, char * newdata) {static_cast<GriddedField2 *>(data) -> set_name(newdata);}
890char * get_grid_nameGriddedField2(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField2 *>(data) -> get_grid_name(i).data());}
891void set_grid_nameGriddedField2(Index i, void * data, char * newdata) {static_cast<GriddedField2 *>(data) -> set_grid_name(i, newdata);}
892void * get_numeric_gridGriddedField2(Index i, void * data) {return &static_cast<GriddedField2 *>(data) -> get_numeric_grid(i);}
893void * get_string_gridGriddedField2(Index i, void * data) {return &static_cast<GriddedField2 *>(data) -> get_string_grid(i);}
894void set_gridGriddedField2(Index i, void * data, void * newdata, bool NumericType)
895{
896 if (NumericType)
897 static_cast<GriddedField2 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
898 else
899 static_cast<GriddedField2 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
900}
901void * dataGriddedField2(void * data) {return &static_cast<GriddedField2 *>(data) -> data;}
902bool checksizeGriddedField2(void * data) {return static_cast<GriddedField2 *>(data) -> checksize();}
903
904
905// GriddedField3
914Index get_dimGriddedField3(void * data) {return static_cast<GriddedField3 *>(data) -> get_dim();}
915Index get_grid_typeIndexGriddedField3(Index i, void * data) {return Index(static_cast<GriddedField3 *>(data) -> get_grid_type(i));}
916Index get_grid_sizeGriddedField3(Index i, void * data) {return static_cast<GriddedField3 *>(data) -> get_grid_size(i);}
917char * get_nameGriddedField3(void * data) {return const_cast<char *>(static_cast<GriddedField3 *>(data) -> get_name().data());}
918void set_nameGriddedField3(void * data, char * newdata) {static_cast<GriddedField3 *>(data) -> set_name(newdata);}
919char * get_grid_nameGriddedField3(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField3 *>(data) -> get_grid_name(i).data());}
920void set_grid_nameGriddedField3(Index i, void * data, char * newdata) {static_cast<GriddedField3 *>(data) -> set_grid_name(i, newdata);}
921void * get_numeric_gridGriddedField3(Index i, void * data) {return &static_cast<GriddedField3 *>(data) -> get_numeric_grid(i);}
922void * get_string_gridGriddedField3(Index i, void * data) {return &static_cast<GriddedField3 *>(data) -> get_string_grid(i);}
923void set_gridGriddedField3(Index i, void * data, void * newdata, bool NumericType)
924{
925 if (NumericType)
926 static_cast<GriddedField3 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
927 else
928 static_cast<GriddedField3 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
929}
930void * dataGriddedField3(void * data) {return &static_cast<GriddedField3 *>(data) -> data;}
931bool checksizeGriddedField3(void * data) {return static_cast<GriddedField3 *>(data) -> checksize();}
932
933
934// GriddedField4
940Index get_dimGriddedField4(void * data) {return static_cast<GriddedField4 *>(data) -> get_dim();}
941Index get_grid_typeIndexGriddedField4(Index i, void * data) {return Index(static_cast<GriddedField4 *>(data) -> get_grid_type(i));}
942Index get_grid_sizeGriddedField4(Index i, void * data) {return static_cast<GriddedField4 *>(data) -> get_grid_size(i);}
943char * get_nameGriddedField4(void * data) {return const_cast<char *>(static_cast<GriddedField4 *>(data) -> get_name().data());}
944void set_nameGriddedField4(void * data, char * newdata) {static_cast<GriddedField4 *>(data) -> set_name(newdata);}
945char * get_grid_nameGriddedField4(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField4 *>(data) -> get_grid_name(i).data());}
946void set_grid_nameGriddedField4(Index i, void * data, char * newdata) {static_cast<GriddedField4 *>(data) -> set_grid_name(i, newdata);}
947void * get_numeric_gridGriddedField4(Index i, void * data) {return &static_cast<GriddedField4 *>(data) -> get_numeric_grid(i);}
948void * get_string_gridGriddedField4(Index i, void * data) {return &static_cast<GriddedField4 *>(data) -> get_string_grid(i);}
949void set_gridGriddedField4(Index i, void * data, void * newdata, bool NumericType)
950{
951 if (NumericType)
952 static_cast<GriddedField4 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
953 else
954 static_cast<GriddedField4 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
955}
956void * dataGriddedField4(void * data) {return &static_cast<GriddedField4 *>(data) -> data;}
957bool checksizeGriddedField4(void * data) {return static_cast<GriddedField4 *>(data) -> checksize();}
958
959
960// GriddedField5
963Index get_dimGriddedField5(void * data) {return static_cast<GriddedField5 *>(data) -> get_dim();}
964Index get_grid_typeIndexGriddedField5(Index i, void * data) {return Index(static_cast<GriddedField5 *>(data) -> get_grid_type(i));}
965Index get_grid_sizeGriddedField5(Index i, void * data) {return static_cast<GriddedField5 *>(data) -> get_grid_size(i);}
966char * get_nameGriddedField5(void * data) {return const_cast<char *>(static_cast<GriddedField5 *>(data) -> get_name().data());}
967void set_nameGriddedField5(void * data, char * newdata) {static_cast<GriddedField5 *>(data) -> set_name(newdata);}
968char * get_grid_nameGriddedField5(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField5 *>(data) -> get_grid_name(i).data());}
969void set_grid_nameGriddedField5(Index i, void * data, char * newdata) {static_cast<GriddedField5 *>(data) -> set_grid_name(i, newdata);}
970void * get_numeric_gridGriddedField5(Index i, void * data) {return &static_cast<GriddedField5 *>(data) -> get_numeric_grid(i);}
971void * get_string_gridGriddedField5(Index i, void * data) {return &static_cast<GriddedField5 *>(data) -> get_string_grid(i);}
972void set_gridGriddedField5(Index i, void * data, void * newdata, bool NumericType)
973{
974 if (NumericType)
975 static_cast<GriddedField5 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
976 else
977 static_cast<GriddedField5 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
978}
979void * dataGriddedField5(void * data) {return &static_cast<GriddedField5 *>(data) -> data;}
980bool checksizeGriddedField5(void * data) {return static_cast<GriddedField5 *>(data) -> checksize();}
981
982
983// GriddedField6
986Index get_dimGriddedField6(void * data) {return static_cast<GriddedField6 *>(data) -> get_dim();}
987Index get_grid_typeIndexGriddedField6(Index i, void * data) {return Index(static_cast<GriddedField6 *>(data) -> get_grid_type(i));}
988Index get_grid_sizeGriddedField6(Index i, void * data) {return static_cast<GriddedField6 *>(data) -> get_grid_size(i);}
989char * get_nameGriddedField6(void * data) {return const_cast<char *>(static_cast<GriddedField6 *>(data) -> get_name().data());}
990void set_nameGriddedField6(void * data, char * newdata) {static_cast<GriddedField6 *>(data) -> set_name(newdata);}
991char * get_grid_nameGriddedField6(Index i, void * data) {return const_cast<char *>(static_cast<GriddedField6 *>(data) -> get_grid_name(i).data());}
992void set_grid_nameGriddedField6(Index i, void * data, char * newdata) {static_cast<GriddedField6 *>(data) -> set_grid_name(i, newdata);}
993void * get_numeric_gridGriddedField6(Index i, void * data) {return &static_cast<GriddedField6 *>(data) -> get_numeric_grid(i);}
994void * get_string_gridGriddedField6(Index i, void * data) {return &static_cast<GriddedField6 *>(data) -> get_string_grid(i);}
995void set_gridGriddedField6(Index i, void * data, void * newdata, bool NumericType)
996{
997 if (NumericType)
998 static_cast<GriddedField6 *>(data) -> set_grid(i, *static_cast<Vector *>(newdata));
999 else
1000 static_cast<GriddedField6 *>(data) -> set_grid(i, *static_cast<ArrayOfString *>(newdata));
1001}
1002void * dataGriddedField6(void * data) {return &static_cast<GriddedField6 *>(data) -> data;}
1003bool checksizeGriddedField6(void * data) {return static_cast<GriddedField6 *>(data) -> checksize();}
1004
1005
1006// CIARecord
1011 return new Species::Species(static_cast<CIARecord *>(data) -> Species(0));
1012}
1014 return new Species::Species(static_cast<CIARecord *>(data) -> Species(1));
1015}
1016void setSpeciesCIARecord(void * data, void * s1, void * s2) {
1017 static_cast<CIARecord *>(data) -> SetSpecies(
1018 *static_cast<Species::Species *>(s1),
1019 *static_cast<Species::Species *>(s2));
1020}
1024
1025
1026// Verbosity
1029Index getAgendaVerbosity(void * data) {return static_cast<Verbosity *>(data) -> get_agenda_verbosity();}
1030Index getScreenVerbosity(void * data) {return static_cast<Verbosity *>(data) -> get_screen_verbosity();}
1031Index getFileVerbosity(void * data) {return static_cast<Verbosity *>(data) -> get_file_verbosity();}
1032bool getMainVerbosity(void * data) {return static_cast<Verbosity *>(data) -> is_main_agenda();}
1033void setVerbosity(void * data, Index a, Index s, Index f, bool m) {
1034 auto x = static_cast<Verbosity *>(data);
1035 x -> set_agenda_verbosity(a);
1036 x -> set_screen_verbosity(s);
1037 x -> set_file_verbosity(f);
1038 x -> set_main_agenda(m);
1039}
1040
1041
1042// TessemNN
1043void * createTessemNN() {return new TessemNN;}
1044void deleteTessemNN(void * data) {delete static_cast<TessemNN *>(data);}
1045void printTessemNN(void *) {std::cout << std::endl;}
1058
1059
1060// SingleScatteringData
1078
1079
1080// ScatteringMetaData
1089VoidStructGetterCAPI(ScatteringMetaData, diameter_area_equ_aerodynamical)
1096
1097
1098// Timer
1099void * createTimer() {return new Timer;}
1100void deleteTimer(void * data) {delete static_cast<Timer *>(data);}
1101void printTimer(void *) {std::cout << std::endl;}
1103bool getrunningTimer(void * data) {return static_cast<Timer *>(data) -> running;}
1104bool getfinishedTimer(void * data) {return static_cast<Timer *>(data) -> finished;}
1106{
1107#ifdef TIME_SUPPORT
1108 return static_cast<Timer *>(data) -> cputime_start.tms_utime;
1109#else
1110 return 0;
1111#endif
1112}
1114{
1115#ifdef TIME_SUPPORT
1116 return static_cast<Timer *>(data) -> cputime_start.tms_stime;
1117#else
1118 return 0;
1119#endif
1120}
1122{
1123#ifdef TIME_SUPPORT
1124 return static_cast<Timer *>(data) -> cputime_start.tms_cutime;
1125#else
1126 return 0;
1127#endif
1128}
1130{
1131#ifdef TIME_SUPPORT
1132 return static_cast<Timer *>(data) -> cputime_start.tms_cstime;
1133#else
1134 return 0;
1135#endif
1136}
1138{
1139#ifdef TIME_SUPPORT
1140 return static_cast<Timer *>(data) -> realtime_start;
1141#else
1142 return 0;
1143#endif
1144}
1146{
1147#ifdef TIME_SUPPORT
1148 return static_cast<Timer *>(data) -> cputime_end.tms_utime;
1149#else
1150 return 0;
1151#endif
1152}
1154{
1155#ifdef TIME_SUPPORT
1156 return static_cast<Timer *>(data) -> cputime_end.tms_stime;
1157#else
1158 return 0;
1159#endif
1160}
1162{
1163#ifdef TIME_SUPPORT
1164 return static_cast<Timer *>(data) -> cputime_end.tms_cutime;
1165#else
1166 return 0;
1167#endif
1168}
1170{
1171#ifdef TIME_SUPPORT
1172 return static_cast<Timer *>(data) -> cputime_end.tms_cstime;
1173#else
1174 return 0;
1175#endif
1176}
1178{
1179#ifdef TIME_SUPPORT
1180 return static_cast<Timer *>(data) -> realtime_end;
1181#else
1182 return 0;
1183#endif
1184}
1185void setrunningTimer(void * data, bool newdata) {static_cast<Timer *>(data) -> running = newdata;}
1186void setfinishedTimer(void * data, bool newdata) {static_cast<Timer *>(data) -> finished = newdata;}
1188{
1189#ifdef TIME_SUPPORT
1190 static_cast<Timer *>(data) -> cputime_start.tms_utime = clock_t(newdata);
1191#endif
1192}
1194{
1195#ifdef TIME_SUPPORT
1196 static_cast<Timer *>(data) -> cputime_start.tms_stime = clock_t(newdata);
1197#endif
1198}
1200{
1201#ifdef TIME_SUPPORT
1202 static_cast<Timer *>(data) -> cputime_start.tms_cutime = clock_t(newdata);
1203#endif
1204}
1206{
1207#ifdef TIME_SUPPORT
1208 static_cast<Timer *>(data) -> cputime_start.tms_cstime = clock_t(newdata);
1209#endif
1210}
1212{
1213#ifdef TIME_SUPPORT
1214 static_cast<Timer *>(data) -> realtime_start = clock_t(newdata);
1215#endif
1216}
1218{
1219#ifdef TIME_SUPPORT
1220 static_cast<Timer *>(data) -> cputime_end.tms_utime = clock_t(newdata);
1221#endif
1222}
1224{
1225#ifdef TIME_SUPPORT
1226 static_cast<Timer *>(data) -> cputime_end.tms_stime = clock_t(newdata);
1227#endif
1228}
1230{
1231#ifdef TIME_SUPPORT
1232 static_cast<Timer *>(data) -> cputime_end.tms_cutime = clock_t(newdata);
1233#endif
1234}
1236{
1237#ifdef TIME_SUPPORT
1238 static_cast<Timer *>(data) -> cputime_end.tms_cstime = clock_t(newdata);
1239#endif
1240}
1242{
1243#ifdef TIME_SUPPORT
1244 static_cast<Timer *>(data) -> realtime_end = clock_t(newdata);
1245#endif
1246}
1248{
1249#ifdef TIME_SUPPORT
1250 return true;
1251#else
1252 return false;
1253#endif
1254}
1256{
1257#ifdef TIME_SUPPORT
1258 return sysconf(_SC_CLK_TCK);
1259#else
1260 return 0;
1261#endif
1262}
1263
1264
1265// TelsemAtlas
1268VoidGetterCAPI(TelsemAtlas, DataCount)
1274VoidGetterCAPI(TelsemAtlas, FirstCells)
1276VoidGetterCAPI(TelsemAtlas, Emis_err)
1278VoidGetterCAPI(TelsemAtlas, Classes1)
1280VoidGetterCAPI(TelsemAtlas, Cellnumber)
1285Numeric getA0_K0TelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A0_K0(i);}
1286Numeric getA0_K1TelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A0_K1(i);}
1287Numeric getA0_K2TelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A0_K2(i);}
1288Numeric getA0_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A0_EVEH(i);}
1289Numeric getA1_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A1_EVEH(i);}
1290Numeric getA2_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A2_EVEH(i);}
1291Numeric getA3_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> A3_EVEH(i);}
1292Numeric getB0_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> B0_EVEH(i);}
1293Numeric getB1_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> B1_EVEH(i);}
1294Numeric getB2_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> B2_EVEH(i);}
1295Numeric getB3_EVEHTelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> B3_EVEH(i);}
1296Numeric getRAPPORT43_32TelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> RAPPORT43_32(i);}
1297Numeric getRAPPORT54_43TelsemAtlas(Index i, void* data) {return static_cast<TelsemAtlas *>(data) -> RAPPORT54_43(i);}
1298
1299
1300// MCAntenna
1308Index getTypeMCAntenna(void * data) {return Index(static_cast<MCAntenna *>(data) -> Type());}
1309Index setTypeMCAntenna(void * data, Index newval) {return Index(static_cast<MCAntenna *>(data) -> Type(AntennaType(newval)));}
1310
1311
1312// GasAbsLookup
1326
1327
1328// XsecRecord
1331void * getSpeciesXsecRecord(void * data) {
1332 return new Species::Species(static_cast<XsecRecord *>(data) -> Species());
1333}
1334void setSpeciesXsecRecord(void * data, void * val) {
1335 static_cast<XsecRecord *>(data) -> SetSpecies(*static_cast<Species::Species *>(val));
1336}
1338VoidGetterCAPI(XsecRecord, RefPressure)
1342VoidGetterCAPI(XsecRecord, TemperatureSlope)
1343VoidGetterCAPI(XsecRecord, TemperatureIntersect)
1347
1348
1349// Sparse
1355void resizeSparse(Index nrows, Index ncols, void * data) {static_cast<Sparse *>(data) -> resize(nrows, ncols);}
1356Index rowsSparse(void * data) {return static_cast<Sparse *>(data) -> nrows();}
1357Index colsSparse(void * data) {return static_cast<Sparse *>(data) -> ncols();}
1358Index sizeSparse(void * data) {return static_cast<Sparse *>(data) -> nnz();}
1359int * rowsptrSparse(void * data) {return static_cast<Sparse *>(data) -> get_row_start_pointer();}
1360int * colsptrSparse(void * data) {return static_cast<Sparse *>(data) -> get_column_index_pointer();}
1361Numeric * getDataSparse(void * data) {return static_cast<Sparse *>(data) -> get_element_pointer();}
1362void setDataSparse(void * data, Index r, Index c, Numeric v) {(static_cast<Sparse *>(data) -> rw(r, c)) = v;}
1363
1364
1365// CovarianceMatrix
1368Index sizeget_blocksCovarianceMatrix(void * data) { return static_cast<CovarianceMatrix *>(data) -> get_blocks().size(); }
1369void resizeget_blocksCovarianceMatrix(Index n, void * data) { static_cast<CovarianceMatrix *>(data) -> get_blocks() = std::vector<Block>(n, Block(Range(joker), Range(joker), {0, 0}, std::make_shared<Matrix>(Matrix()))); }
1370void * getelemget_blocksCovarianceMatrix(Index i, void * data) { return &static_cast<CovarianceMatrix *>(data) -> get_blocks()[i]; }
1371Index sizeget_inverse_blocksCovarianceMatrix(void * data) { return static_cast<CovarianceMatrix *>(data) -> get_inverse_blocks().size(); }
1372void resizeget_inverse_blocksCovarianceMatrix(Index n, void * data) { static_cast<CovarianceMatrix *>(data) -> get_inverse_blocks() = std::vector<Block>(n, Block(Range(joker), Range(joker), {0, 0}, std::make_shared<Matrix>(Matrix()))); }
1373void * getelemget_inverse_blocksCovarianceMatrix(Index i, void * data) { return &static_cast<CovarianceMatrix *>(data) -> get_inverse_blocks()[i]; }
1374
1375
1376// Any
1377void * createAny() {return new Any;}
1378void deleteAny(void * data) {delete static_cast<Any *>(data);}
1379void printAny(void *) {std::cout << std::endl;}
1380Index xmlreadAny(void *, char *) {return 1;}
1381Index xmlsaveAny(void *, char *, Index, Index) {return 1;}
1382
1383
1384// Agenda
1390
1391
1392// Jacobian::Target
1395VoidGetterCAPI(JacobianTarget, Perturbation)
1404
1405
1406// RetrievalQuantity
1415VoidGetterCAPI(RetrievalQuantity, TFuncParameters)
1421
1422
1423// Range
1424void * createRange() {return new Range(joker);}
1425void deleteRange(void * data) {delete static_cast<Range *>(data);}
1426void printRange(void * data) {std::cout << (*static_cast<Range *>(data)) << std::endl;}
1427Index get_startRange(void * data) {return static_cast<Range *>(data) -> get_start();}
1428Index get_strideRange(void * data) {return static_cast<Range *>(data) -> get_stride();}
1429Index get_extentRange(void * data) {return static_cast<Range *>(data) -> get_extent();}
1430void setRange(void * data, Index start, Index extent, Index stride)
1431{
1432 if (extent >= 0)
1433 static_cast<Range *>(data) -> operator=(Range(start, extent, stride));
1434 else
1435 static_cast<Range *>(data) -> operator=(Range(start, joker, stride));
1436}
1437
1438
1439// Block
1440void * createBlock() {return new Block(Range(joker), Range(joker), {0, 0}, std::make_shared<Matrix>(Matrix()));}
1441void deleteBlock(void * data) {delete static_cast<Block *>(data);}
1442void printBlock(void *) {std::cout << std::endl;}
1443VoidGetterCAPI(Block, get_row_range)
1444VoidGetterCAPI(Block, get_column_range)
1446VoidGetterCAPI(Block, get_sparse)
1447Index get_matrix_typeBlock(void * data) {return Index(static_cast<Block *>(data) -> get_matrix_type());}
1448Index get_index1Block(void * data) {return static_cast<Block *>(data) -> get_indices().first;}
1449Index get_index2Block(void * data) {return static_cast<Block *>(data) -> get_indices().second;}
1450void set_indicesBlock(void * data, Index i1, Index i2) {static_cast<Block *>(data) -> set_indices(i1, i2);}
1451void set_matrixBlock(void * data, void * newdata, bool dense)
1452{
1453 auto x = static_cast<Block *>(data);
1454 if (dense) {
1455 x -> operator=(Block(x -> get_row_range(), x -> get_column_range(), x -> get_indices(), std::make_shared<Matrix>(*static_cast<Matrix *>(newdata))));
1456 } else {
1457 x -> operator=(Block(x -> get_row_range(), x -> get_column_range(), x -> get_indices(), std::make_shared<Sparse>(*static_cast<Sparse *>(newdata))));
1458 }
1459}
1460
1461
1462// Time
1472Index setTimeFromString(void * data, char * newdata) {
1473 try {
1474 *static_cast<Time *>(data) = Time(newdata);
1475 return EXIT_SUCCESS;
1476 } catch(...) {
1477 return EXIT_FAILURE;
1478 }
1479}
1480void setTime(void * data, void * newdata) {*static_cast<Time *>(data) = *static_cast<Time *>(newdata);}
1481bool equalTime(void * data, void * otherdata) {return *static_cast<Time *>(data) == *static_cast<Time *>(otherdata);}
1482bool lessTime(void * data, void * otherdata) {return *static_cast<Time *>(data) < *static_cast<Time *>(otherdata);}
1483
1484
1485// HitranRelaxationMatrixData
1506
1507
1508// PartitionFunctionsType
1510void * getPartitionFunctionsTypeString(void * data) {
1511 return new String(toString(*static_cast<PartitionFunctionsType *>(data)));
1512}
1513int setPartitionFunctionsTypeString(void * data, char * val) {
1514 auto x = PartitionFunctions::toType(val);
1515 if (good_enum(x)) {
1516 *static_cast<PartitionFunctionsType *>(data) = x;
1517 return EXIT_SUCCESS;
1518 } else {
1519 return EXIT_FAILURE;
1520 }
1521}
1522
1523
1524// PartitionFunctionsData
1529
1530// SpeciesErrorCorrectedSuddenData
1538
1539// ErrorCorrectedSuddenData
1542void * getErrorCorrectedSuddenData(void * data, void * id) {
1543 return & static_cast<ErrorCorrectedSuddenData *>(data) -> operator[](*static_cast<Species::Species *>(id));
1544}
1545Index getnelemErrorCorrectedSuddenData(void * data) {return static_cast<ErrorCorrectedSuddenData *>(data) -> data.nelem();}
1547{
1548 if (i < static_cast<ErrorCorrectedSuddenData *>(data) -> data.nelem() and i >= 0) {
1549 return & static_cast<ErrorCorrectedSuddenData *>(data) -> data[i];
1550 } else {
1551 return nullptr;
1552 }
1553}
1554
1555// MapOfErrorCorrectedSuddenData
1558void * getMapOfErrorCorrectedSuddenData(void * data, void * id) {
1559 return & static_cast<MapOfErrorCorrectedSuddenData *>(data) -> operator[](*static_cast<QuantumIdentifier *>(id));
1560}
1563{
1564 if (i < static_cast<MapOfErrorCorrectedSuddenData *>(data) -> nelem() and i >= 0) {
1565 return & static_cast<MapOfErrorCorrectedSuddenData *>(data) -> operator[](i);
1566 } else {
1567 return nullptr;
1568 }
1569}
1570
1571// generic
1572Index string2filetypeindex(char * data) { try { return Index(string2filetype(data)); } catch (std::runtime_error& e) { return -1; } }
1574
1575#undef BasicInterfaceCAPI
1576#undef GetterSetterCAPI
1577#undef EnumGetterSetterCAPI
1578#undef StringEnumGetterSetterCAPI
1579#undef VoidGetterCAPI
1580#undef VoidStructGetterCAPI
1581#undef BasicInputOutputCAPI
1582#undef VoidArrayCAPI
1583#undef VoidArrayElemCAPI
Declarations required for the calculation of absorption coefficients.
Contains the absorption namespace.
Absorption::CutoffType AbsorptionCutoffType
Absorption::NormalizationType AbsorptionNormalizationType
Absorption::PopulationType AbsorptionPopulationType
Absorption::MirroringType AbsorptionMirroringType
void * get_numeric_gridGriddedField4(Index i, void *data)
Index rowsTensor3(void *data)
Numeric E0
Index getGSpeciesIsotopeRecord(void *data)
Numeric * getDataMatrix(void *data)
void * createSpecies()
Index get_grid_typeIndexGriddedField5(Index i, void *data)
void set_nameGriddedField2(void *data, char *newdata)
char * get_grid_nameGriddedField2(Index i, void *data)
Index azimuthsStokesVector(void *data)
char * get_nameGriddedField2(void *data)
Index get_grid_sizeGriddedField3(Index i, void *data)
void setcputime_end_cutimeTimer(void *data, Index newdata)
Index nrows
Numeric getA3_EVEHTelsemAtlas(Index i, void *data)
Index nbooks
int setLineShapeTemperatureModelString(void *data, char *val)
Data void * getSpecies1CIARecord(void *data)
int setAbsorptionMirroringTypeString(void *data, char *val)
void printTessemNN(void *)
void * get_numeric_gridGriddedField2(Index i, void *data)
char *Index xmlsaveArrayOfSpecies(void *, char *, Index, Index)
Index colsSparse(void *data)
void printSpecies(void *data)
Numeric getA0_K2TelsemAtlas(Index i, void *data)
Numeric getRAPPORT54_43TelsemAtlas(Index i, void *data)
Index get_grid_sizeGriddedField6(Index i, void *data)
#define VoidStructGetterCAPI(TYPE, VALUE)
Index get_grid_sizeGriddedField4(Index i, void *data)
void deleteAny(void *data)
void * createTessemNN()
Index frequenciesStokesVector(void *data)
void printBlock(void *)
void * createBlock()
Index npages
void * getSpeciesLongName(void *data)
Index pagesTensor5(void *data)
Index get_grid_typeIndexGriddedField6(Index i, void *data)
void * data
void setSpeciesCIARecord(void *data, void *s1, void *s2)
void setNumeric(void *data, Numeric newval)
char * get_nameGriddedField3(void *data)
Index booksTensor7(void *data)
void * createPpath()
Index sizeQuantumNumbers()
void set_gridGriddedField2(Index i, void *data, void *newdata, bool NumericType)
int setSpeciesIsotopeRecordToIndex(void *data, Index i)
Numeric * getVec2RadiationVector(Index i, void *data)
Index sizeget_inverse_blocksCovarianceMatrix(void *data)
char *Index xmlsaveArrayOfNumeric(void *, char *, Index, Index)
void printAny(void *)
void * dataGriddedField4(void *data)
void set_grid_nameGriddedField6(Index i, void *data, char *newdata)
Numeric * getVec3RadiationVector(Index i, void *data)
Index get_index2Block(void *data)
void setDataSparse(void *data, Index r, Index c, Numeric v)
Index getcputime_end_stimeTimer(void *data)
int setAbsorptionCutoffTypeString(void *data, char *val)
#define VoidArrayCAPI(TYPE)
void set_gridGriddedField4(Index i, void *data, void *newdata, bool NumericType)
void * dataGriddedField6(void *data)
Index vitrinesTensor7(void *data)
void setcputime_end_cstimeTimer(void *data, Index newdata)
Numeric getB1_EVEHTelsemAtlas(Index i, void *data)
Index booksTensor4(void *data)
Index tickTimer()
Index string2quantumnumbersindex(char *str)
Index getcputime_start_cutimeTimer(void *data)
bool getMainVerbosity(void *data)
Index colsMatrix(void *data)
void setrealtime_endTimer(void *data, Index newdata)
void set_grid_nameGriddedField5(Index i, void *data, char *newdata)
void setRange(void *data, Index start, Index extent, Index stride)
void setcputime_end_utimeTimer(void *data, Index newdata)
int setQuantumIdentifierTypeString(void *data, char *val)
void * createAny()
bool getOKPropagationMatrix(void *data)
void * get_numeric_gridGriddedField6(Index i, void *data)
Index frequenciesPropagationMatrix(void *data)
void deleteBlock(void *data)
Index rowsTensor6(void *data)
Index rowsSparse(void *data)
#define StringEnumGetterSetterCAPI(TYPE, ELEM)
void * getLocalQuantaAbsorptionLines(void *data)
Numeric getA0_EVEHTelsemAtlas(Index i, void *data)
char * isot
Numeric * getDataVector(void *data)
Index vitrinesTensor6(void *data)
Index getcputime_end_cstimeTimer(void *data)
void * get_string_gridGriddedField2(Index i, void *data)
Numeric * getDataSparse(void *data)
void setIndex(void *data, Index newval)
void * getIsotnameSpeciesIsotopeRecord(void *)
void deleteRange(void *data)
void setrunningTimer(void *data, bool newdata)
Index rowsTensor7(void *data)
void * getSpeciesNameAbsorptionLines(void *data)
void * dataGriddedField5(void *data)
Index colsTensor4(void *data)
Index sizeSparse(void *data)
bool Cutoff Mirroring Normalization CutoffFreqValue
void * get_string_gridGriddedField4(Index i, void *data)
Index setStokesVector(void *data, Index f, Index s, Index z, Index a, Numeric v)
Numeric * getMat2TransmissionMatrix(Index i, void *data)
Index get_strideRange(void *data)
Numeric * getDataTensor5(void *data)
bool checksizeGriddedField3(void *data)
Index get_grid_sizeGriddedField5(Index i, void *data)
Index get_index1Block(void *data)
Index get_startRange(void *data)
Numeric * getDataTensor3(void *data)
void set_gridGriddedField6(Index i, void *data, void *newdata, bool NumericType)
void set_gridGriddedField3(Index i, void *data, void *newdata, bool NumericType)
void * get_string_gridGriddedField1(Index i, void *data)
void set_nameGriddedField5(void *data, char *newdata)
#define BasicInterfaceCAPI(TYPE)
Index colsTensor7(void *data)
void set_indicesBlock(void *data, Index i1, Index i2)
int setQuantumNumberTypeString(void *data, char *val)
Index booksTensor5(void *data)
#define VoidArrayElemCAPI(TYPE, ELEM)
void setcputime_start_cstimeTimer(void *data, Index newdata)
Index zenithsPropagationMatrix(void *data)
void * get_string_gridGriddedField3(Index i, void *data)
Index get_grid_typeIndexGriddedField4(Index i, void *data)
Index colsTensor5(void *data)
Numeric Nom
bool supportTimer()
void set_nameGriddedField1(void *data, char *newdata)
Index getStokesDimRadiationVector(void *data)
Index rowsTensor4(void *data)
void setcputime_start_utimeTimer(void *data, Index newdata)
void printRange(void *data)
void printArrayOfPpath(void *)
Index shelvesTensor7(void *data)
Index getIndexSpeciesIsotopeRecordFromData(void *data)
#define BasicInputOutputCAPI(TYPE)
#define VoidGetterCAPI(TYPE, VALUE)
Numeric getMassSpeciesIsotopeRecord(void *data)
bool getfinishedTimer(void *data)
Index getcputime_end_utimeTimer(void *data)
get_column_range get_sparse Index get_matrix_typeBlock(void *data)
void setcputime_end_stimeTimer(void *data, Index newdata)
char * newdata
Numeric Numeric g_upp
Index colsTensor3(void *data)
void set_gridGriddedField1(Index i, void *data, void *newdata, bool NumericType)
void * dataGriddedField1(void *data)
Index getFrequenciesRadiationVector(void *data)
void * get_string_gridGriddedField6(Index i, void *data)
Numeric * getDataTensor7(void *data)
void * getSpecies2CIARecord(void *data)
#define EnumGetterSetterCAPI(TYPE, VALUE, ENUM)
Index getrealtime_startTimer(void *data)
Index shelvesTensor5(void *data)
Index get_grid_typeIndexGriddedField2(Index i, void *data)
Index nvitrines
Index get_grid_sizeGriddedField1(Index i, void *data)
Index xmlsaveAny(void *, char *, Index, Index)
Index getrealtime_endTimer(void *data)
int setSpeciesShortName(void *data, char *spec)
Index get_grid_typeIndexGriddedField3(Index i, void *data)
void printPpath(void *)
bool checksizeGriddedField4(void *data)
Index colsTensor6(void *data)
int * colsptrSparse(void *data)
void * get_numeric_gridGriddedField3(Index i, void *data)
char * get_nameGriddedField5(void *data)
char * get_grid_nameGriddedField5(Index i, void *data)
void * get_string_gridGriddedField5(Index i, void *data)
bool checksizeGriddedField2(void *data)
void deleteTimer(void *data)
void setcputime_start_cutimeTimer(void *data, Index newdata)
void deleteTessemNN(void *data)
bool checksizeGriddedField5(void *data)
void setVerbosity(void *data, Index a, Index s, Index f, bool m)
Index booksTensor6(void *data)
void set_nameGriddedField3(void *data, char *newdata)
saa aag G Index getTypeMCAntenna(void *data)
void * getQuantumNumberTypeLocalQuantaAbsorptionLines(void *data, Index i)
Numeric getB0_EVEHTelsemAtlas(Index i, void *data)
void set_nameGriddedField6(void *data, char *newdata)
Numeric * getMat3TransmissionMatrix(Index i, void *data)
Index getcputime_end_cutimeTimer(void *data)
int * rowsptrSparse(void *data)
void set_grid_nameGriddedField3(Index i, void *data, char *newdata)
Index pagesTensor3(void *data)
void deletePpath(void *data)
idx pos dlx char *Index xmlsaveArrayOfLagrangeInterpolation(void *, char *, Index, Index)
Index setSpeciesTag(void *data, char *newdata)
Index setPropagationMatrix(void *data, Index f, Index s, Index z, Index a, Numeric v)
Index zenithsStokesVector(void *data)
void setrealtime_startTimer(void *data, Index newdata)
void * get_numeric_gridGriddedField5(Index i, void *data)
#define GetterSetterCAPI(TYPE, VALUE, BASETYPE)
void set_grid_nameGriddedField2(Index i, void *data, char *newdata)
Index getScreenVerbosity(void *data)
void setcputime_start_stimeTimer(void *data, Index newdata)
Index rowsMatrix(void *data)
Index getcputime_start_cstimeTimer(void *data)
Index getStokesDimTransmissionMatrix(void *data)
Index nshelves
Index pagesTensor4(void *data)
Numeric * getDataTensor4(void *data)
void setfinishedTimer(void *data, bool newdata)
void * get_numeric_gridGriddedField1(Index i, void *data)
Index getFrequenciesTransmissionMatrix(void *data)
Index librariesTensor7(void *data)
void printTimer(void *)
char * get_nameGriddedField6(void *data)
char * getString(void *data)
void * getSpeciesSpeciesIsotopeRecord(void *data)
Numeric * getVec4RadiationVector(Index i, void *data)
Index azimuthsPropagationMatrix(void *data)
Index setTypeMCAntenna(void *data, Index newval)
type upp char * str
int setSpeciesTagTypeString(void *data, char *val)
bool checksizeGriddedField6(void *data)
void set_matrixBlock(void *data, void *newdata, bool dense)
Numeric getA1_EVEHTelsemAtlas(Index i, void *data)
int setAbsorptionNormalizationTypeString(void *data, char *val)
Numeric getA2_EVEHTelsemAtlas(Index i, void *data)
void * getSpeciesShortName(void *data)
void * getelemget_blocksCovarianceMatrix(Index i, void *data)
void * dataGriddedField3(void *data)
int setAbsorptionPopulationTypeString(void *data, char *val)
Numeric getRAPPORT43_32TelsemAtlas(Index i, void *data)
Index get_extentRange(void *data)
bool getOKStokesVector(void *data)
Index get_grid_sizeGriddedField2(Index i, void *data)
int setSpeciesLongName(void *data, char *spec)
Index pagesTensor7(void *data)
char * get_grid_nameGriddedField4(Index i, void *data)
Numeric getA0_K1TelsemAtlas(Index i, void *data)
char * get_grid_nameGriddedField6(Index i, void *data)
void set_nameGriddedField4(void *data, char *newdata)
char * get_grid_nameGriddedField1(Index i, void *data)
Index ncols
Index getcputime_start_stimeTimer(void *data)
void * getQuantumNumbersString(void *data)
Index getcputime_start_utimeTimer(void *data)
Index isAbsorptionLinesOK(void *data)
Index get_grid_typeIndexGriddedField1(Index i, void *data)
void setTransmissionMatrix(void *data, Index stokes, Index freqs)
bool checksizeGriddedField1(void *data)
void setSpeciesXsecRecord(void *data, void *val)
Index nelemSpeciesIsotopeRecordDefined()
Index pagesTensor6(void *data)
char * get_grid_nameGriddedField3(Index i, void *data)
Index rowsTensor5(void *data)
void * dataGriddedField2(void *data)
void printmetaAbsorptionLines(void *data)
Index nelemVector(void *data)
void resizeLocalQuantaAbsorptionLines(Index n, void *data)
void deleteSpecies(void *data)
void set_gridGriddedField5(Index i, void *data, void *newdata, bool NumericType)
Index getFileVerbosity(void *data)
void set_grid_nameGriddedField1(Index i, void *data, char *newdata)
int setLineShapeTypeString(void *data, char *val)
void resizeget_blocksCovarianceMatrix(Index n, void *data)
Index xmlreadAny(void *, char *)
void setRadiationVector(void *data, Index stokes, Index freqs)
char * get_nameGriddedField1(void *data)
Numeric * getDataTensor6(void *data)
Numeric getB2_EVEHTelsemAtlas(Index i, void *data)
char * get_nameGriddedField4(void *data)
void resizeget_inverse_blocksCovarianceMatrix(Index n, void *data)
Numeric getB3_EVEHTelsemAtlas(Index i, void *data)
Numeric * getMat4TransmissionMatrix(Index i, void *data)
Numeric getNumeric(void *data)
Index shelvesTensor6(void *data)
void deleteArrayOfPpath(void *data)
void * getelemget_inverse_blocksCovarianceMatrix(Index i, void *data)
void set_grid_nameGriddedField4(Index i, void *data, char *newdata)
This file contains all declarations of the ARTS C API class interface.
DLL_PUBLIC bool lessTime(void *, void *)
void *DLL_PUBLIC Index getnelemMapOfErrorCorrectedSuddenData(void *)
DLL_PUBLIC void * getErrorCorrectedSuddenDataAtMapOfErrorCorrectedSuddenData(void *, Index)
Numeric char *DLL_PUBLIC void setTime(void *, void *)
DLL_PUBLIC Index getnelemErrorCorrectedSuddenData(void *)
DLL_PUBLIC Index string2filetypeindex(char *)
W0rr W0rq W0rp W0qr W0qq W0qp W0pr W0pq W0pp type spec beta collisional_distance id DLL_PUBLIC void * getErrorCorrectedSuddenData(void *, void *)
DLL_PUBLIC bool equalTime(void *, void *)
DLL_PUBLIC void * get_list_of_all_workspace_classes()
DLL_PUBLIC void * getSpeciesErrorCorrectedSuddenDataAtErrorCorrectedSuddenData(void *, Index)
Computations and data for a single absorption line.
The Agenda class.
Definition: agenda_class.h:44
A placeholder for any type.
Definition: supergeneric.h:36
CIA data for a single pair of molecules.
Definition: cia.h:68
An absorption lookup table.
Main line shape model class.
Compute the line shape parameters for a single broadening species.
An Antenna object used by MCGeneral.
Definition: mc_antenna.h:51
The Matrix class.
Definition: matpackI.h:1225
Container class for Quantum Numbers.
Definition: quantum.h:112
Radiation Vector for Stokes dimension 1-4.
The range class.
Definition: matpackI.h:165
Implements rational numbers to work with other ARTS types.
Definition: rational.h:52
Deals with internal derivatives, Jacobian definition, and OEM calculations.
Definition: jacobian.h:345
The Sparse class.
Definition: matpackII.h:67
Stokes vector is as Propagation matrix but only has 4 possible values.
A telsem atlas.
Definition: telsem.h:59
The Tensor3 class.
Definition: matpackIII.h:339
The Tensor4 class.
Definition: matpackIV.h:421
The Tensor5 class.
Definition: matpackV.h:506
The Tensor6 class.
Definition: matpackVI.h:1088
The Tensor7 class.
Definition: matpackVII.h:2382
Class to handle time in ARTS.
Definition: artstime.h:41
Class to keep track of Transmission Matrices for Stokes Dim 1-4.
The Vector class.
Definition: matpackI.h:876
Main Zeeman Model.
Definition: zeemandata.h:357
Header files of CovarianceMatrix class.
Class to map energy levels.
EnergyLevelMapType
constexpr bool good_enum(EnumType x) noexcept
Checks if the enum number is good.
Definition: enums.h:21
Jacobian::Target JacobianTarget
Definition: jacobian.h:340
#define beta
Contains the line shape namespace.
LineShape::TemperatureModel LineShapeTemperatureModel
LineShape::Type LineShapeType
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
NUMERIC Numeric
The type to use for all floating point numbers.
Definition: matpack.h:33
#define b1
const Joker joker
#define b2
AntennaType
Definition: mc_antenna.h:41
my_basic_string< char > String
The String type for ARTS.
Definition: mystring.h:287
Index nelem(const Lines &l)
Number of lines.
char Type type
Computations of line shape derived parameters.
Definition: lineshape.cc:23
Vector mass(const ConstVectorView &atmospheric_vmrs, const ArrayOfArrayOfSpeciesTag &atmospheric_species, const ArrayOfSpecies &lineshape_species, const SpeciesIsotopologueRatios &ir) ARTS_NOEXCEPT
Returns a mass vector for this model's main calculations.
constexpr std::array Isotopologues
Definition: isotopologues.h:50
constexpr Index find_species_index(const Species spec, const std::string_view isot) noexcept
Implements Zeeman modeling.
Definition: zeemandata.cc:281
constexpr Rational start(Rational Ju, Rational Jl, Polarization type) noexcept
Gives the lowest M for a polarization type of this transition.
Definition: zeemandata.h:78
const ArrayOfString wsv_group_names
The names associated with Wsv groups as Strings.
Definition: global_data.h:90
invlib::Matrix< ArtsMatrix > Matrix
invlib wrapper type for ARTS matrices.
Definition: oem.h:33
Array< Ppath > ArrayOfPpath
An array of propagation paths.
Definition: ppath.h:90
#define v
#define a
#define c
Quantum::Identifier QuantumIdentifier
Definition: quantum.h:471
Quantum::IdentifierType QuantumIdentifierType
Definition: quantum.h:468
Species::TagType SpeciesTagType
Definition: species_tags.h:97
Species::Tag SpeciesTag
Definition: species_tags.h:99
Rovibrational line mixing data following the ideas of Collisional Effects On Molecular Spectra by J.
Definition: linemixing.h:132
Structure to store a grid position.
Definition: interpolation.h:73
A Lagrange interpolation computer.
Coefficients and temperature model for SingleSpeciesModel.
The structure to describe a propagation path and releated quantities.
Definition: ppath.h:48
Struct containing all information needed about one isotope.
Definition: isotopologues.h:14
Declarations for supergeneric methods.
PartitionFunctions::Type PartitionFunctionsType
This file contains basic functions to handle XML data files.
FileType string2filetype(const String &file_format)
Definition: xml_io_base.cc:313
NumericType
Definition: xml_io_base.h:46
Headers and class definition of Zeeman modeling.