auto_md.h

Go to the documentation of this file.

// This file was generated automatically by make_auto_md_h.cc.
// DO NOT EDIT !
// Generated: Oct  7 2020, 09:44:21

#ifndef auto_md_h
#define auto_md_h

#include "matpackI.h"
#include "matpackII.h"
#include "abs_species_tags.h"
#include "artstime.h"
#include "gas_abs_lookup.h"
#include "gridded_fields.h"
#include "linemixing_hitran.h"
#include "optproperties.h"
#include "jacobian.h"
#include "mc_antenna.h"
#include "m_general.h"
#include "parser.h"
#include "workspace_ng.h"
#include "cia.h"
#include "covariance_matrix.h"
#include "propagationmatrix.h"
#include "transmissionmatrix.h"
#include "telsem.h"
#include "tessem.h"
#include "hitran_xsec.h"
#include "absorptionlines.h"

// This is only used for a consistency check. You can get the
// number of WSMs from md_data.nelem().
#define N_MD 1972

// Method function declarations:


void AbsorptionLinesCreate(// WS Generic Output:
                           AbsorptionLines& out,
                           // Verbosity object:
                           const Verbosity& verbosity);


void AgendaCreate(// WS Generic Output:
                  Agenda& out,
                  // Verbosity object:
                  const Verbosity& verbosity);


void ArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                  ArrayOfAbsorptionLines& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void ArrayOfArrayOfAbsorptionLinesCreate(// WS Generic Output:
                                         ArrayOfArrayOfAbsorptionLines& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void ArrayOfAgendaCreate(// WS Generic Output:
                         ArrayOfAgenda& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfArrayOfGriddedField1Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField1& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void ArrayOfArrayOfGriddedField2Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField2& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void ArrayOfArrayOfGriddedField3Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField3& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void ArrayOfArrayOfIndexCreate(// WS Generic Output:
                               ArrayOfArrayOfIndex& out,
                               // Verbosity object:
                               const Verbosity& verbosity);


void ArrayOfArrayOfMatrixCreate(// WS Generic Output:
                                ArrayOfArrayOfMatrix& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfPpathCreate(// WS Generic Output:
                        ArrayOfPpath& out,
                        // Verbosity object:
                        const Verbosity& verbosity);


void ArrayOfArrayOfPropagationMatrixCreate(// WS Generic Output:
                                           ArrayOfArrayOfPropagationMatrix& out,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void ArrayOfArrayOfRadiationVectorCreate(// WS Generic Output:
                                         ArrayOfArrayOfRadiationVector& out,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void ArrayOfArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                            ArrayOfArrayOfScatteringMetaData& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);


void ArrayOfArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                              ArrayOfArrayOfSingleScatteringData& out,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void ArrayOfArrayOfSpeciesTagCreate(// WS Generic Output:
                                    ArrayOfArrayOfSpeciesTag& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void ArrayOfArrayOfStokesVectorCreate(// WS Generic Output:
                                      ArrayOfArrayOfStokesVector& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void ArrayOfArrayOfStringCreate(// WS Generic Output:
                                ArrayOfArrayOfString& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfArrayOfTensor3Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor3& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void ArrayOfArrayOfTensor6Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor6& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void ArrayOfArrayOfTimeCreate(// WS Generic Output:
                              ArrayOfArrayOfTime& out,
                              // Verbosity object:
                              const Verbosity& verbosity);


void ArrayOfArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                            ArrayOfArrayOfTransmissionMatrix& out,
                                            // Verbosity object:
                                            const Verbosity& verbosity);


void ArrayOfArrayOfVectorCreate(// WS Generic Output:
                                ArrayOfArrayOfVector& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfCIARecordCreate(// WS Generic Output:
                            ArrayOfCIARecord& out,
                            // Verbosity object:
                            const Verbosity& verbosity);


void ArrayOfGriddedField1Create(// WS Generic Output:
                                ArrayOfGriddedField1& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfGriddedField2Create(// WS Generic Output:
                                ArrayOfGriddedField2& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfGriddedField3Create(// WS Generic Output:
                                ArrayOfGriddedField3& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfGriddedField4Create(// WS Generic Output:
                                ArrayOfGriddedField4& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& out,
                        // Verbosity object:
                        const Verbosity& verbosity);


void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfPropagationMatrixCreate(// WS Generic Output:
                                    ArrayOfPropagationMatrix& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void ArrayOfQuantumIdentifierCreate(// WS Generic Output:
                                    ArrayOfQuantumIdentifier& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void ArrayOfRadiationVectorCreate(// WS Generic Output:
                                  ArrayOfRadiationVector& out,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void ArrayOfRetrievalQuantityCreate(// WS Generic Output:
                                    ArrayOfRetrievalQuantity& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void ArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                     ArrayOfScatteringMetaData& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void ArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                       ArrayOfSingleScatteringData& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void ArrayOfSparseCreate(// WS Generic Output:
                         ArrayOfSparse& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfStokesVectorCreate(// WS Generic Output:
                               ArrayOfStokesVector& out,
                               // Verbosity object:
                               const Verbosity& verbosity);


void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfTelsemAtlasCreate(// WS Generic Output:
                              ArrayOfTelsemAtlas& out,
                              // Verbosity object:
                              const Verbosity& verbosity);


void ArrayOfTensor3Create(// WS Generic Output:
                          ArrayOfTensor3& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfTensor4Create(// WS Generic Output:
                          ArrayOfTensor4& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfTensor5Create(// WS Generic Output:
                          ArrayOfTensor5& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfTensor6Create(// WS Generic Output:
                          ArrayOfTensor6& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfTensor7Create(// WS Generic Output:
                          ArrayOfTensor7& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfTimeCreate(// WS Generic Output:
                       ArrayOfTime& out,
                       // Verbosity object:
                       const Verbosity& verbosity);


void ArrayOfTransmissionMatrixCreate(// WS Generic Output:
                                     ArrayOfTransmissionMatrix& out,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfXsecRecordCreate(// WS Generic Output:
                             ArrayOfXsecRecord& out,
                             // Verbosity object:
                             const Verbosity& verbosity);


void CIARecordCreate(// WS Generic Output:
                     CIARecord& out,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CovarianceMatrixCreate(// WS Generic Output:
                            CovarianceMatrix& out,
                            // Verbosity object:
                            const Verbosity& verbosity);


void EnergyLevelMapCreate(// WS Generic Output:
                          EnergyLevelMap& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void GasAbsLookupCreate(// WS Generic Output:
                        GasAbsLookup& out,
                        // Verbosity object:
                        const Verbosity& verbosity);


void GridPosCreate(// WS Generic Output:
                   GridPos& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void GriddedField1Create(// WS Generic Output:
                         GriddedField1& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedField2Create(// WS Generic Output:
                         GriddedField2& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedField3Create(// WS Generic Output:
                         GriddedField3& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedField4Create(// WS Generic Output:
                         GriddedField4& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedField5Create(// WS Generic Output:
                         GriddedField5& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedField6Create(// WS Generic Output:
                         GriddedField6& out,
                         // Verbosity object:
                         const Verbosity& verbosity);


void HitranRelaxationMatrixDataCreate(// WS Generic Output:
                                      HitranRelaxationMatrixData& out,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void IndexCreate(// WS Generic Output:
                 Index& out,
                 // Verbosity object:
                 const Verbosity& verbosity);


void MCAntennaCreate(// WS Generic Output:
                     MCAntenna& out,
                     // Verbosity object:
                     const Verbosity& verbosity);


void MatrixCreate(// WS Generic Output:
                  Matrix& out,
                  // Verbosity object:
                  const Verbosity& verbosity);


void NumericCreate(// WS Generic Output:
                   Numeric& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void PpathCreate(// WS Generic Output:
                 Ppath& out,
                 // Verbosity object:
                 const Verbosity& verbosity);


void PropagationMatrixCreate(// WS Generic Output:
                             PropagationMatrix& out,
                             // Verbosity object:
                             const Verbosity& verbosity);


void QuantumIdentifierCreate(// WS Generic Output:
                             QuantumIdentifier& out,
                             // Verbosity object:
                             const Verbosity& verbosity);


void RadiationVectorCreate(// WS Generic Output:
                           RadiationVector& out,
                           // Verbosity object:
                           const Verbosity& verbosity);


void RationalCreate(// WS Generic Output:
                    Rational& out,
                    // Verbosity object:
                    const Verbosity& verbosity);


void ScatteringMetaDataCreate(// WS Generic Output:
                              ScatteringMetaData& out,
                              // Verbosity object:
                              const Verbosity& verbosity);


void SingleScatteringDataCreate(// WS Generic Output:
                                SingleScatteringData& out,
                                // Verbosity object:
                                const Verbosity& verbosity);


void SparseCreate(// WS Generic Output:
                  Sparse& out,
                  // Verbosity object:
                  const Verbosity& verbosity);


void SpeciesAuxDataCreate(// WS Generic Output:
                          SpeciesAuxData& out,
                          // Verbosity object:
                          const Verbosity& verbosity);


void StokesVectorCreate(// WS Generic Output:
                        StokesVector& out,
                        // Verbosity object:
                        const Verbosity& verbosity);


void StringCreate(// WS Generic Output:
                  String& out,
                  // Verbosity object:
                  const Verbosity& verbosity);


void TelsemAtlasCreate(// WS Generic Output:
                       TelsemAtlas& out,
                       // Verbosity object:
                       const Verbosity& verbosity);


void Tensor3Create(// WS Generic Output:
                   Tensor3& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void Tensor4Create(// WS Generic Output:
                   Tensor4& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void Tensor5Create(// WS Generic Output:
                   Tensor5& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void Tensor6Create(// WS Generic Output:
                   Tensor6& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void Tensor7Create(// WS Generic Output:
                   Tensor7& out,
                   // Verbosity object:
                   const Verbosity& verbosity);


void TimerCreate(// WS Generic Output:
                 Timer& out,
                 // Verbosity object:
                 const Verbosity& verbosity);


void TimeCreate(// WS Generic Output:
                Time& out,
                // Verbosity object:
                const Verbosity& verbosity);


void TessemNNCreate(// WS Generic Output:
                    TessemNN& out,
                    // Verbosity object:
                    const Verbosity& verbosity);


void TransmissionMatrixCreate(// WS Generic Output:
                              TransmissionMatrix& out,
                              // Verbosity object:
                              const Verbosity& verbosity);


void VectorCreate(// WS Generic Output:
                  Vector& out,
                  // Verbosity object:
                  const Verbosity& verbosity);


void VerbosityCreate(// WS Generic Output:
                     Verbosity& out,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AbsInputFromAtmFields(// WS Output:
                           Vector& abs_p,
                           Vector& abs_t,
                           Matrix& abs_vmrs,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Tensor3& t_field,
                           const Tensor4& vmr_field,
                           // Verbosity object:
                           const Verbosity& verbosity);


void AbsInputFromRteScalars(// WS Output:
                            Vector& abs_p,
                            Vector& abs_t,
                            Matrix& abs_vmrs,
                            // WS Input:
                            const Numeric& rtp_pressure,
                            const Numeric& rtp_temperature,
                            const Vector& rtp_vmr,
                            // Verbosity object:
                            const Verbosity& verbosity);


void abs_cia_dataAddCIARecord(// WS Output:
                              ArrayOfCIARecord& abs_cia_data,
                              // WS Generic Input:
                              const CIARecord& cia_record,
                              const Index& clobber,
                              // Verbosity object:
                              const Verbosity& verbosity);


void abs_cia_dataReadFromCIA(// WS Output:
                             ArrayOfCIARecord& abs_cia_data,
                             // WS Input:
                             const ArrayOfArrayOfSpeciesTag& abs_species,
                             // WS Generic Input:
                             const String& catalogpath,
                             // Verbosity object:
                             const Verbosity& verbosity);


void abs_cia_dataReadFromXML(// WS Output:
                             ArrayOfCIARecord& abs_cia_data,
                             // WS Input:
                             const ArrayOfArrayOfSpeciesTag& abs_species,
                             // WS Generic Input:
                             const String& filename,
                             // Verbosity object:
                             const Verbosity& verbosity);


void abs_coefCalcFromXsec(// WS Output:
                          Matrix& abs_coef,
                          Matrix& src_coef,
                          ArrayOfMatrix& dabs_coef_dx,
                          ArrayOfMatrix& dsrc_coef_dx,
                          ArrayOfMatrix& abs_coef_per_species,
                          ArrayOfMatrix& src_coef_per_species,
                          // WS Input:
                          const ArrayOfMatrix& abs_xsec_per_species,
                          const ArrayOfMatrix& src_xsec_per_species,
                          const ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                          const ArrayOfArrayOfMatrix& dsrc_xsec_per_species_dx,
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                          const Matrix& abs_vmrs,
                          const Vector& abs_p,
                          const Vector& abs_t,
                          // Verbosity object:
                          const Verbosity& verbosity);


void abs_cont_descriptionAppend(// WS Output:
                                ArrayOfString& abs_cont_names,
                                ArrayOfString& abs_cont_models,
                                ArrayOfVector& abs_cont_parameters,
                                // WS Generic Input:
                                const String& tagname,
                                const String& model,
                                const Vector& userparam,
                                // Verbosity object:
                                const Verbosity& verbosity);


void abs_cont_descriptionInit(// WS Output:
                              ArrayOfString& abs_cont_names,
                              ArrayOfString& abs_cont_models,
                              ArrayOfVector& abs_cont_parameters,
                              // Verbosity object:
                              const Verbosity& verbosity);


void abs_hitran_relmat_dataReadHitranRelmatDataAndLines(// WS Output:
                                                        HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const String& basedir,
                                                        const Numeric& linemixinglimit,
                                                        const Numeric& fmin,
                                                        const Numeric& fmax,
                                                        const Numeric& stot,
                                                        const String& mode,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);


void abs_linesCleanupEmpty(// WS Output:
                           ArrayOfAbsorptionLines& abs_lines,
                           // Verbosity object:
                           const Verbosity& verbosity);


void abs_linesKeepBands(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const QuantumIdentifier& qid,
                        const Index& ignore_spec,
                        const Index& ignore_isot,
                        // Verbosity object:
                        const Verbosity& verbosity);


void abs_linesRemoveBand(// WS Output:
                         ArrayOfAbsorptionLines& abs_lines,
                         // WS Generic Input:
                         const QuantumIdentifier& qid,
                         // Verbosity object:
                         const Verbosity& verbosity);


void abs_linesRemoveUnusedLocalQuantumNumbers(// WS Output:
                                              ArrayOfAbsorptionLines& abs_lines,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void abs_linesReplaceWithLines(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const ArrayOfAbsorptionLines& replacing_lines,
                               // Verbosity object:
                               const Verbosity& verbosity);


void abs_linesAppendWithLines(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const ArrayOfAbsorptionLines& appending_lines,
                              const Index& safe,
                              // Verbosity object:
                              const Verbosity& verbosity);


void abs_linesDeleteWithLines(// WS Output:
                              ArrayOfAbsorptionLines& abs_lines,
                              // WS Generic Input:
                              const ArrayOfAbsorptionLines& deleting_lines,
                              // Verbosity object:
                              const Verbosity& verbosity);


void abs_linesDeleteBadF0(// WS Output:
                          ArrayOfAbsorptionLines& abs_lines,
                          // WS Generic Input:
                          const Numeric& f0,
                          const Index& lower,
                          // Verbosity object:
                          const Verbosity& verbosity);


void abs_linesDeleteLinesWithUndefinedLocalQuanta(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_linesDeleteLinesWithBadOrHighChangingJs(// WS Output:
                                                 ArrayOfAbsorptionLines& abs_lines,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);


void abs_linesDeleteLinesWithQuantumNumberAbove(// WS Output:
                                                ArrayOfAbsorptionLines& abs_lines,
                                                // WS Generic Input:
                                                const String& quantumnumber,
                                                const Index& quantumnumber_value,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void abs_linesPrintDefinedQuantumNumbers(// WS Input:
                                         const ArrayOfAbsorptionLines& abs_lines,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void abs_lines_per_speciesReadSplitCatalog(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Input:
                                           const ArrayOfArrayOfSpeciesTag& abs_species,
                                           // WS Generic Input:
                                           const String& basename,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void abs_linesReadSpeciesSplitCatalog(// WS Output:
                                      ArrayOfAbsorptionLines& abs_lines,
                                      // WS Generic Input:
                                      const String& basename,
                                      const Index& robust,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void abs_lines_per_speciesReadSpeciesSplitCatalog(// WS Output:
                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  // WS Generic Input:
                                                  const String& basename,
                                                  const Index& robust,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_lines_per_speciesSetEmpty(// WS Output:
                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void abs_linesSetEmptyBroadeningParametersToEmpty(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_linesSetNormalization(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const String& option,
                               // Verbosity object:
                               const Verbosity& verbosity);


void abs_lines_per_speciesSetNormalization(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Generic Input:
                                           const String& option,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void abs_linesSetNormalizationForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& option,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void abs_lines_per_speciesSetNormalizationForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& option,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);


void abs_lines_per_speciesSetNormalizationForSpecies(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Input:
                                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                                     // WS Generic Input:
                                                     const String& option,
                                                     const String& species_tag,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);


void abs_linesSetMirroring(// WS Output:
                           ArrayOfAbsorptionLines& abs_lines,
                           // WS Generic Input:
                           const String& option,
                           // Verbosity object:
                           const Verbosity& verbosity);


void abs_lines_per_speciesSetMirroring(// WS Output:
                                       ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                       // WS Generic Input:
                                       const String& option,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void abs_linesSetMirroringForMatch(// WS Output:
                                   ArrayOfAbsorptionLines& abs_lines,
                                   // WS Generic Input:
                                   const String& option,
                                   const QuantumIdentifier& ID,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void abs_lines_per_speciesSetMirroringForMatch(// WS Output:
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Generic Input:
                                               const String& option,
                                               const QuantumIdentifier& ID,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void abs_lines_per_speciesSetMirroringForSpecies(// WS Output:
                                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                 // WS Input:
                                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                                 // WS Generic Input:
                                                 const String& option,
                                                 const String& species_tag,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);


void abs_linesSetPopulation(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const String& option,
                            // Verbosity object:
                            const Verbosity& verbosity);


void abs_lines_per_speciesSetPopulation(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const String& option,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void abs_linesSetPopulationForMatch(// WS Output:
                                    ArrayOfAbsorptionLines& abs_lines,
                                    // WS Generic Input:
                                    const String& option,
                                    const QuantumIdentifier& ID,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void abs_lines_per_speciesSetPopulationForMatch(// WS Output:
                                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                // WS Generic Input:
                                                const String& option,
                                                const QuantumIdentifier& ID,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void abs_lines_per_speciesSetPopulationForSpecies(// WS Output:
                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  // WS Generic Input:
                                                  const String& option,
                                                  const String& species_tag,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_linesSetLineShapeType(// WS Output:
                               ArrayOfAbsorptionLines& abs_lines,
                               // WS Generic Input:
                               const String& option,
                               // Verbosity object:
                               const Verbosity& verbosity);


void abs_lines_per_speciesSetLineShapeType(// WS Output:
                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                           // WS Generic Input:
                                           const String& option,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void abs_linesSetLineShapeTypeForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& option,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void abs_lines_per_speciesSetLineShapeTypeForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& option,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);


void abs_lines_per_speciesSetLineShapeTypeForSpecies(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Input:
                                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                                     // WS Generic Input:
                                                     const String& option,
                                                     const String& species_tag,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);


void abs_linesSetCutoff(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const String& option,
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void abs_lines_per_speciesSetCutoff(// WS Output:
                                    ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                    // WS Generic Input:
                                    const String& option,
                                    const Numeric& value,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void abs_linesSetCutoffForMatch(// WS Output:
                                ArrayOfAbsorptionLines& abs_lines,
                                // WS Generic Input:
                                const String& option,
                                const Numeric& value,
                                const QuantumIdentifier& ID,
                                // Verbosity object:
                                const Verbosity& verbosity);


void abs_lines_per_speciesSetCutoffForMatch(// WS Output:
                                            ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                            // WS Generic Input:
                                            const String& option,
                                            const Numeric& value,
                                            const QuantumIdentifier& ID,
                                            // Verbosity object:
                                            const Verbosity& verbosity);


void abs_lines_per_speciesSetCutoffForSpecies(// WS Output:
                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                              // WS Input:
                                              const ArrayOfArrayOfSpeciesTag& abs_species,
                                              // WS Generic Input:
                                              const String& option,
                                              const Numeric& value,
                                              const String& species_tag,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void abs_linesSetLinemixingLimit(// WS Output:
                                 ArrayOfAbsorptionLines& abs_lines,
                                 // WS Generic Input:
                                 const Numeric& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void abs_lines_per_speciesSetLinemixingLimit(// WS Output:
                                             ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                             // WS Generic Input:
                                             const Numeric& value,
                                             // Verbosity object:
                                             const Verbosity& verbosity);


void abs_linesSetLinemixingLimitForMatch(// WS Output:
                                         ArrayOfAbsorptionLines& abs_lines,
                                         // WS Generic Input:
                                         const Numeric& value,
                                         const QuantumIdentifier& ID,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void abs_lines_per_speciesSetLinemixingLimitForMatch(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Generic Input:
                                                     const Numeric& value,
                                                     const QuantumIdentifier& ID,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);


void abs_lines_per_speciesSetLinemixingLimitForSpecies(// WS Output:
                                                       ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                       // WS Input:
                                                       const ArrayOfArrayOfSpeciesTag& abs_species,
                                                       // WS Generic Input:
                                                       const Numeric& value,
                                                       const String& species_tag,
                                                       // Verbosity object:
                                                       const Verbosity& verbosity);


void abs_linesSetT0(// WS Output:
                    ArrayOfAbsorptionLines& abs_lines,
                    // WS Generic Input:
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);


void abs_lines_per_speciesSetT0(// WS Output:
                                ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                // WS Generic Input:
                                const Numeric& value,
                                // Verbosity object:
                                const Verbosity& verbosity);


void abs_linesSetT0ForMatch(// WS Output:
                            ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const Numeric& value,
                            const QuantumIdentifier& ID,
                            // Verbosity object:
                            const Verbosity& verbosity);


void abs_lines_per_speciesSetT0ForMatch(// WS Output:
                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const Numeric& value,
                                        const QuantumIdentifier& ID,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void abs_lines_per_speciesSetT0ForSpecies(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // WS Generic Input:
                                          const Numeric& value,
                                          const String& species_tag,
                                          // Verbosity object:
                                          const Verbosity& verbosity);


void abs_linesSetQuantumNumberForMatch(// WS Output:
                                       ArrayOfAbsorptionLines& abs_lines,
                                       // WS Generic Input:
                                       const String& quantum_number,
                                       const Rational& value,
                                       const QuantumIdentifier& ID,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void abs_lines_per_speciesSetQuantumNumberForMatch(// WS Output:
                                                   ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   // WS Generic Input:
                                                   const String& quantum_number,
                                                   const Rational& value,
                                                   const QuantumIdentifier& ID,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);


void abs_linesChangeBaseParameterForMatchingLevel(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_linesChangeBaseParameterForMatchingLevels(// WS Output:
                                                   ArrayOfAbsorptionLines& abs_lines,
                                                   // WS Generic Input:
                                                   const ArrayOfQuantumIdentifier& QI,
                                                   const String& parameter_name,
                                                   const Vector& change,
                                                   const Index& relative,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);


void abs_lines_per_speciesChangeBaseParameterForMatchingLevel(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);


void abs_lines_per_speciesChangeBaseParameterForMatchingLevels(// WS Output:
                                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                               // WS Generic Input:
                                                               const ArrayOfQuantumIdentifier& QI,
                                                               const String& parameter_name,
                                                               const Vector& change,
                                                               const Index& relative,
                                                               // Verbosity object:
                                                               const Verbosity& verbosity);


void abs_linesSetBaseParameterForMatchingLevel(// WS Output:
                                               ArrayOfAbsorptionLines& abs_lines,
                                               // WS Generic Input:
                                               const QuantumIdentifier& QI,
                                               const String& parameter_name,
                                               const Numeric& change,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void abs_linesSetBaseParameterForMatchingLevels(// WS Output:
                                                ArrayOfAbsorptionLines& abs_lines,
                                                // WS Generic Input:
                                                const ArrayOfQuantumIdentifier& QI,
                                                const String& parameter_name,
                                                const Vector& change,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void abs_lines_per_speciesSetBaseParameterForMatchingLevel(// WS Output:
                                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                           // WS Generic Input:
                                                           const QuantumIdentifier& QI,
                                                           const String& parameter_name,
                                                           const Numeric& change,
                                                           // Verbosity object:
                                                           const Verbosity& verbosity);


void abs_lines_per_speciesSetBaseParameterForMatchingLevels(// WS Output:
                                                            ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                            // WS Generic Input:
                                                            const ArrayOfQuantumIdentifier& QI,
                                                            const String& parameter_name,
                                                            const Vector& change,
                                                            // Verbosity object:
                                                            const Verbosity& verbosity);


void abs_linesChangeBaseParameterForMatchingLines(// WS Output:
                                                  ArrayOfAbsorptionLines& abs_lines,
                                                  // WS Generic Input:
                                                  const QuantumIdentifier& QI,
                                                  const String& parameter_name,
                                                  const Numeric& change,
                                                  const Index& relative,
                                                  const Index& loose_matching,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void abs_lines_per_speciesChangeBaseParameterForMatchingLines(// WS Output:
                                                              ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                              // WS Generic Input:
                                                              const QuantumIdentifier& QI,
                                                              const String& parameter_name,
                                                              const Numeric& change,
                                                              const Index& relative,
                                                              const Index& loose_matching,
                                                              // Verbosity object:
                                                              const Verbosity& verbosity);


void abs_lines_per_speciesChangeBaseParameterForSpecies(// WS Output:
                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                        // WS Input:
                                                        const ArrayOfArrayOfSpeciesTag& abs_species,
                                                        // WS Generic Input:
                                                        const QuantumIdentifier& QI,
                                                        const String& parameter_name,
                                                        const Numeric& change,
                                                        const Index& relative,
                                                        const Index& loose_matching,
                                                        const String& species_tag,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);


void abs_linesSetBaseParameterForMatchingLines(// WS Output:
                                               ArrayOfAbsorptionLines& abs_lines,
                                               // WS Generic Input:
                                               const QuantumIdentifier& QI,
                                               const String& parameter_name,
                                               const Numeric& change,
                                               const Index& loose_matching,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void abs_lines_per_speciesSetBaseParameterForMatchingLines(// WS Output:
                                                           ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                           // WS Generic Input:
                                                           const QuantumIdentifier& QI,
                                                           const String& parameter_name,
                                                           const Numeric& change,
                                                           const Index& loose_matching,
                                                           // Verbosity object:
                                                           const Verbosity& verbosity);


void abs_lines_per_speciesSetBaseParameterForSpecies(// WS Output:
                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                     // WS Input:
                                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                                     // WS Generic Input:
                                                     const QuantumIdentifier& QI,
                                                     const String& parameter_name,
                                                     const Numeric& change,
                                                     const Index& loose_matching,
                                                     const String& species_tag,
                                                     // Verbosity object:
                                                     const Verbosity& verbosity);


void abs_linesSetLineShapeModelParameterForMatchingLines(// WS Output:
                                                         ArrayOfAbsorptionLines& abs_lines,
                                                         // WS Generic Input:
                                                         const QuantumIdentifier& QI,
                                                         const String& parameter,
                                                         const String& coefficient,
                                                         const String& species,
                                                         const Numeric& change,
                                                         // Verbosity object:
                                                         const Verbosity& verbosity);


void abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines(// WS Output:
                                                                     ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                                     // WS Generic Input:
                                                                     const QuantumIdentifier& QI,
                                                                     const String& parameter,
                                                                     const String& coefficient,
                                                                     const String& species,
                                                                     const Numeric& change,
                                                                     // Verbosity object:
                                                                     const Verbosity& verbosity);


void abs_lines_per_speciesSetLineShapeModelParameterForSpecies(// WS Output:
                                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                               // WS Input:
                                                               const ArrayOfArrayOfSpeciesTag& abs_species,
                                                               // WS Generic Input:
                                                               const QuantumIdentifier& QI,
                                                               const String& parameter,
                                                               const String& coefficient,
                                                               const String& species,
                                                               const Numeric& change,
                                                               const String& species_tag,
                                                               // Verbosity object:
                                                               const Verbosity& verbosity);


void abs_linesChangeLineShapeModelParameterForMatchingLines(// WS Output:
                                                            ArrayOfAbsorptionLines& abs_lines,
                                                            // WS Generic Input:
                                                            const QuantumIdentifier& QI,
                                                            const String& parameter,
                                                            const String& coefficient,
                                                            const String& species,
                                                            const Numeric& change,
                                                            const Index& relative,
                                                            // Verbosity object:
                                                            const Verbosity& verbosity);


void abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines(// WS Output:
                                                                        ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                                        // WS Generic Input:
                                                                        const QuantumIdentifier& QI,
                                                                        const String& parameter,
                                                                        const String& coefficient,
                                                                        const String& species,
                                                                        const Numeric& change,
                                                                        const Index& relative,
                                                                        // Verbosity object:
                                                                        const Verbosity& verbosity);


void abs_lines_per_speciesChangeLineShapeModelParameterForSpecies(// WS Output:
                                                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                                  // WS Input:
                                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                                  // WS Generic Input:
                                                                  const QuantumIdentifier& QI,
                                                                  const String& parameter,
                                                                  const String& coefficient,
                                                                  const String& species,
                                                                  const Numeric& change,
                                                                  const Index& relative,
                                                                  const String& species_tag,
                                                                  // Verbosity object:
                                                                  const Verbosity& verbosity);


void abs_linesCompact(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Input:
                      const Vector& f_grid,
                      // Verbosity object:
                      const Verbosity& verbosity);


void abs_lines_per_speciesCompact(// WS Output:
                                  ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  // WS Input:
                                  const Vector& f_grid,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void abs_lines_per_speciesCreateFromLines(// WS Output:
                                          ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfAbsorptionLines& abs_lines,
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // Verbosity object:
                                          const Verbosity& verbosity);


void abs_lookupAdapt(// WS Output:
                     GasAbsLookup& abs_lookup,
                     Index& abs_lookup_is_adapted,
                     // WS Input:
                     const ArrayOfArrayOfSpeciesTag& abs_species,
                     const Vector& f_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);


void abs_lookupCalc(// Workspace reference:
                    Workspace& ws,
                    // WS Output:
                    GasAbsLookup& abs_lookup,
                    Index& abs_lookup_is_adapted,
                    // WS Input:
                    const ArrayOfArrayOfSpeciesTag& abs_species,
                    const ArrayOfArrayOfSpeciesTag& abs_nls,
                    const Vector& f_grid,
                    const Vector& abs_p,
                    const Matrix& abs_vmrs,
                    const Vector& abs_t,
                    const Vector& abs_t_pert,
                    const Vector& abs_nls_pert,
                    const Agenda& abs_xsec_agenda,
                    // Verbosity object:
                    const Verbosity& verbosity);


void abs_lookupInit(// WS Output:
                    GasAbsLookup& abs_lookup,
                    // Verbosity object:
                    const Verbosity& verbosity);


void abs_lookupSetup(// WS Output:
                     Vector& abs_p,
                     Vector& abs_t,
                     Vector& abs_t_pert,
                     Matrix& abs_vmrs,
                     ArrayOfArrayOfSpeciesTag& abs_nls,
                     Vector& abs_nls_pert,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Tensor3& t_field,
                     const Tensor4& vmr_field,
                     const Index& atmfields_checked,
                     const ArrayOfArrayOfSpeciesTag& abs_species,
                     const Index& abs_p_interp_order,
                     const Index& abs_t_interp_order,
                     const Index& abs_nls_interp_order,
                     // WS Generic Input:
                     const Numeric& p_step,
                     const Numeric& t_step,
                     const Numeric& h2o_step,
                     // Verbosity object:
                     const Verbosity& verbosity);


void abs_lookupSetupBatch(// WS Output:
                          Vector& abs_p,
                          Vector& abs_t,
                          Vector& abs_t_pert,
                          Matrix& abs_vmrs,
                          ArrayOfArrayOfSpeciesTag& abs_nls,
                          Vector& abs_nls_pert,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const ArrayOfGriddedField4& batch_atm_fields_compact,
                          const Index& abs_p_interp_order,
                          const Index& abs_t_interp_order,
                          const Index& abs_nls_interp_order,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Numeric& t_step,
                          const Numeric& h2o_step,
                          const Vector& extremes,
                          const Index& robust,
                          const Index& check_gridnames,
                          // Verbosity object:
                          const Verbosity& verbosity);


void abs_lookupSetupWide(// WS Output:
                         Vector& abs_p,
                         Vector& abs_t,
                         Vector& abs_t_pert,
                         Matrix& abs_vmrs,
                         ArrayOfArrayOfSpeciesTag& abs_nls,
                         Vector& abs_nls_pert,
                         // WS Input:
                         const ArrayOfArrayOfSpeciesTag& abs_species,
                         const Index& abs_p_interp_order,
                         const Index& abs_t_interp_order,
                         const Index& abs_nls_interp_order,
                         // WS Generic Input:
                         const Numeric& p_min,
                         const Numeric& p_max,
                         const Numeric& p_step,
                         const Numeric& t_min,
                         const Numeric& t_max,
                         const Numeric& h2o_min,
                         const Numeric& h2o_max,
                         // Verbosity object:
                         const Verbosity& verbosity);


void abs_lookupTestAccuracy(// Workspace reference:
                            Workspace& ws,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            const Index& abs_lookup_is_adapted,
                            const Index& abs_p_interp_order,
                            const Index& abs_t_interp_order,
                            const Index& abs_nls_interp_order,
                            const Agenda& abs_xsec_agenda,
                            // Verbosity object:
                            const Verbosity& verbosity);


void abs_lookupTestAccMC(// Workspace reference:
                         Workspace& ws,
                         // WS Input:
                         const GasAbsLookup& abs_lookup,
                         const Index& abs_lookup_is_adapted,
                         const Index& abs_p_interp_order,
                         const Index& abs_t_interp_order,
                         const Index& abs_nls_interp_order,
                         const Index& mc_seed,
                         const Agenda& abs_xsec_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);


void abs_nlteFromRaw(// WS Output:
                     EnergyLevelMap& abs_nlte,
                     // WS Input:
                     const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                     const Vector& nlte_vibrational_energies,
                     // WS Generic Input:
                     const Matrix& data,
                     // Verbosity object:
                     const Verbosity& verbosity);


void abs_speciesAdd(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    Index& propmat_clearsky_agenda_checked,
                    Index& abs_xsec_agenda_checked,
                    // WS Generic Input:
                    const ArrayOfString& species,
                    // Verbosity object:
                    const Verbosity& verbosity);


void abs_speciesAdd2(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species,
                     ArrayOfRetrievalQuantity& jacobian_quantities,
                     Agenda& jacobian_agenda,
                     Index& propmat_clearsky_agenda_checked,
                     Index& abs_xsec_agenda_checked,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Vector& gin1,
                     const Vector& gin2,
                     const Vector& gin3,
                     const String& species,
                     const String& unit,
                     // Verbosity object:
                     const Verbosity& verbosity);


void abs_speciesDefineAllInScenario(// WS Output:
                                    ArrayOfArrayOfSpeciesTag& abs_species,
                                    Index& propmat_clearsky_agenda_checked,
                                    Index& abs_xsec_agenda_checked,
                                    // WS Generic Input:
                                    const String& basename,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void abs_speciesDefineAll(// WS Output:
                          ArrayOfArrayOfSpeciesTag& abs_species,
                          Index& propmat_clearsky_agenda_checked,
                          Index& abs_xsec_agenda_checked,
                          // Verbosity object:
                          const Verbosity& verbosity);


void abs_speciesInit(// WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species,
                     // Verbosity object:
                     const Verbosity& verbosity);


void abs_speciesSet(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    Index& abs_xsec_agenda_checked,
                    Index& propmat_clearsky_agenda_checked,
                    // WS Generic Input:
                    const ArrayOfString& species,
                    // Verbosity object:
                    const Verbosity& verbosity);


void abs_vecAddGas(// WS Output:
                   StokesVector& abs_vec,
                   // WS Input:
                   const ArrayOfPropagationMatrix& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);


void abs_xsec_agenda_checkedCalc(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Index& abs_xsec_agenda_checked,
                                 // WS Input:
                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                 const Agenda& abs_xsec_agenda,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void abs_xsec_per_speciesAddCIA(// WS Output:
                                ArrayOfMatrix& abs_xsec_per_species,
                                ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                // WS Input:
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                const ArrayOfIndex& abs_species_active,
                                const Vector& f_grid,
                                const Vector& abs_p,
                                const Vector& abs_t,
                                const Matrix& abs_vmrs,
                                const ArrayOfCIARecord& abs_cia_data,
                                // WS Generic Input:
                                const Numeric& T_extrapolfac,
                                const Index& robust,
                                // Verbosity object:
                                const Verbosity& verbosity);


void abs_xsec_per_speciesAddHitranXsec(// WS Output:
                                       ArrayOfMatrix& abs_xsec_per_species,
                                       ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                       // WS Input:
                                       const ArrayOfArrayOfSpeciesTag& abs_species,
                                       const ArrayOfRetrievalQuantity& jacobian_quantities,
                                       const ArrayOfIndex& abs_species_active,
                                       const Vector& f_grid,
                                       const Vector& abs_p,
                                       const Vector& abs_t,
                                       const ArrayOfXsecRecord& hitran_xsec_data,
                                       // WS Generic Input:
                                       const Index& apply_tfit,
                                       const Numeric& force_p,
                                       const Numeric& force_t,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void abs_xsec_per_speciesAddConts(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfIndex& abs_species_active,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfString& abs_cont_names,
                                  const ArrayOfVector& abs_cont_parameters,
                                  const ArrayOfString& abs_cont_models,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void abs_xsec_per_speciesAddLines(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  ArrayOfMatrix& src_xsec_per_species,
                                  ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                  ArrayOfArrayOfMatrix& dsrc_xsec_per_species_dx,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfIndex& abs_species_active,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const EnergyLevelMap& abs_nlte,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                  const SpeciesAuxData& isotopologue_ratios,
                                  const SpeciesAuxData& partition_functions,
                                  const Index& lbl_checked,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void abs_xsec_per_speciesAddPredefinedO2MPM2020(// WS Output:
                                                ArrayOfMatrix& abs_xsec_per_species,
                                                ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                                                // WS Input:
                                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                                const Vector& f_grid,
                                                const Vector& abs_p,
                                                const Vector& abs_t,
                                                const Matrix& abs_vmrs,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void abs_xsec_per_speciesInit(// WS Output:
                              ArrayOfMatrix& abs_xsec_per_species,
                              ArrayOfMatrix& src_xsec_per_species,
                              ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
                              ArrayOfArrayOfMatrix& dsrc_xsec_per_species_dx,
                              // WS Input:
                              const ArrayOfArrayOfSpeciesTag& abs_species,
                              const ArrayOfRetrievalQuantity& jacobian_quantities,
                              const ArrayOfIndex& abs_species_active,
                              const Vector& f_grid,
                              const Vector& abs_p,
                              const Index& abs_xsec_agenda_checked,
                              const Index& nlte_do,
                              // Verbosity object:
                              const Verbosity& verbosity);


void AddZaAa(// WS Generic Output:
             Matrix& new_los,
             // WS Generic Input:
             const Vector& ref_los,
             const Matrix& dlos,
             // Verbosity object:
             const Verbosity& verbosity);


void AgendaAppend(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& out,
                  // WS Generic Output Names:
                  const String& out_wsvname,
                  // WS Generic Input:
                  const Agenda& in,
                  // WS Generic Input Names:
                  const String& in_wsvname,
                  // Agenda from controlfile:
                  const Agenda& input_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);


void AgendaExecute(// Workspace reference:
                   Workspace& ws,
                   // WS Generic Input:
                   const Agenda& a,
                   // Verbosity object:
                   const Verbosity& verbosity);


void AgendaExecuteExclusive(// Workspace reference:
                            Workspace& ws,
                            // WS Generic Input:
                            const Agenda& a,
                            // Verbosity object:
                            const Verbosity& verbosity);


void AgendaSet(// Workspace reference:
               Workspace& ws,
               // WS Generic Output:
               Agenda& out,
               // WS Generic Output Names:
               const String& out_wsvname,
               // Agenda from controlfile:
               const Agenda& input_agenda,
               // Verbosity object:
               const Verbosity& verbosity);


void AngularGridsSetFluxCalc(// WS Output:
                             Vector& za_grid,
                             Vector& aa_grid,
                             Vector& za_grid_weights,
                             // WS Generic Input:
                             const Index& N_za_grid,
                             const Index& N_aa_grid,
                             const String& za_grid_type,
                             // Verbosity object:
                             const Verbosity& verbosity);


void ArrayOfAgendaAppend(// Workspace reference:
                         Workspace& ws,
                         // WS Generic Output:
                         ArrayOfAgenda& out,
                         // WS Generic Output Names:
                         const String& out_wsvname,
                         // Agenda from controlfile:
                         const Agenda& input_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ArrayOfAgendaExecute(// Workspace reference:
                          Workspace& ws,
                          // WS Input:
                          const Index& agenda_array_index,
                          // WS Generic Input:
                          const ArrayOfAgenda& agendas,
                          // Verbosity object:
                          const Verbosity& verbosity);


void AntennaConstantGaussian1D(// WS Output:
                               Index& antenna_dim,
                               Matrix& mblock_dlos_grid,
                               GriddedField4& antenna_response,
                               Matrix& antenna_dlos,
                               // WS Generic Input:
                               const Index& n_za_grid,
                               const Numeric& fwhm,
                               const Numeric& xwidth_si,
                               const Numeric& dx_si,
                               // Verbosity object:
                               const Verbosity& verbosity);


void AntennaMultiBeamsToPencilBeams(// WS Output:
                                    Matrix& sensor_pos,
                                    Matrix& sensor_los,
                                    Matrix& antenna_dlos,
                                    Index& antenna_dim,
                                    Matrix& mblock_dlos_grid,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void AntennaOff(// WS Output:
                Index& antenna_dim,
                Matrix& mblock_dlos_grid,
                // Verbosity object:
                const Verbosity& verbosity);


void antenna_responseGaussian(// WS Output:
                              GriddedField4& antenna_response,
                              // WS Generic Input:
                              const Numeric& fwhm,
                              const Numeric& xwidth_si,
                              const Numeric& dx_si,
                              const Index& do_2d,
                              // Verbosity object:
                              const Verbosity& verbosity);


void antenna_responseVaryingGaussian(// WS Output:
                                     GriddedField4& antenna_response,
                                     // WS Generic Input:
                                     const Numeric& leff,
                                     const Numeric& xwidth_si,
                                     const Numeric& dx_si,
                                     const Index& nf,
                                     const Numeric& fstart,
                                     const Numeric& fstop,
                                     const Index& do_2d,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void ArrayOfIndexLinSpace(// WS Generic Output:
                          ArrayOfIndex& out,
                          // WS Generic Input:
                          const Index& start,
                          const Index& stop,
                          const Index& step,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfIndexSet(// WS Generic Output:
                     ArrayOfIndex& out,
                     // WS Generic Input:
                     const ArrayOfIndex& value,
                     // Verbosity object:
                     const Verbosity& verbosity);


void ArrayOfIndexSetConstant(// WS Generic Output:
                             ArrayOfIndex& out,
                             // WS Input:
                             const Index& nelem,
                             // WS Generic Input:
                             const Index& value,
                             // Verbosity object:
                             const Verbosity& verbosity);


void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString& out,
                      // WS Generic Input:
                      const ArrayOfString& value,
                      // Verbosity object:
                      const Verbosity& verbosity);


void Arts(// Workspace reference:
          Workspace& ws,
          // Agenda from controlfile:
          const Agenda& input_agenda,
          // Verbosity object:
          const Verbosity& verbosity);


void Arts2(// Workspace reference:
           Workspace& ws,
           // Agenda from controlfile:
           const Agenda& input_agenda,
           // Verbosity object:
           const Verbosity& verbosity);


void AtmFieldPerturb(// WS Generic Output:
                     Tensor3& perturbed_field,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Tensor3& original_field,
                     const Vector& p_ret_grid,
                     const Vector& lat_ret_grid,
                     const Vector& lon_ret_grid,
                     const Index& pert_index,
                     const Numeric& pert_size,
                     const String& pert_mode,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmFieldPerturbAtmGrids(// WS Generic Output:
                             Tensor3& perturbed_field,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             // WS Generic Input:
                             const Tensor3& original_field,
                             const Index& pert_index,
                             const Numeric& pert_size,
                             const String& pert_mode,
                             // Verbosity object:
                             const Verbosity& verbosity);


void AtmFieldPRegrid(// WS Generic Output:
                     Tensor3& out,
                     // WS Generic Input:
                     const Tensor3& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmFieldPRegrid(// WS Generic Output:
                     Tensor4& out,
                     // WS Generic Input:
                     const Tensor4& in,
                     const Vector& p_grid_new,
                     const Vector& p_grid_old,
                     const Index& interp_order,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmFieldsCalc(// WS Output:
                   Tensor3& t_field,
                   Tensor3& z_field,
                   Tensor4& vmr_field,
                   EnergyLevelMap& nlte_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const GriddedField3& t_field_raw,
                   const GriddedField3& z_field_raw,
                   const ArrayOfGriddedField3& vmr_field_raw,
                   const ArrayOfGriddedField3& nlte_field_raw,
                   const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                   const Vector& nlte_vibrational_energies,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   const Index& vmr_zeropadding,
                   const Index& vmr_nonegative,
                   const Index& nlte_when_negative,
                   // Verbosity object:
                   const Verbosity& verbosity);


void AtmFieldsCalcExpand1D(// WS Output:
                           Tensor3& t_field,
                           Tensor3& z_field,
                           Tensor4& vmr_field,
                           EnergyLevelMap& nlte_field,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const GriddedField3& t_field_raw,
                           const GriddedField3& z_field_raw,
                           const ArrayOfGriddedField3& vmr_field_raw,
                           const ArrayOfGriddedField3& nlte_field_raw,
                           const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                           const Vector& nlte_vibrational_energies,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           const Index& vmr_zeropadding,
                           const Index& vmr_nonegative,
                           const Index& nlte_when_negative,
                           // Verbosity object:
                           const Verbosity& verbosity);


void AtmFieldsExpand1D(// WS Output:
                       Tensor3& t_field,
                       Tensor3& z_field,
                       Tensor4& vmr_field,
                       // WS Input:
                       const Vector& p_grid,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Index& atmosphere_dim,
                       // WS Generic Input:
                       const Index& chk_vmr_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);


void AtmFieldsExtract1D(// WS Output:
                        Index& atmosphere_dim,
                        Vector& lat_grid,
                        Vector& lon_grid,
                        Tensor3& t_field,
                        Tensor3& z_field,
                        Tensor4& vmr_field,
                        // WS Generic Input:
                        const Index& ilat,
                        const Index& ilon,
                        // Verbosity object:
                        const Verbosity& verbosity);


void AtmFieldsRefinePgrid(// WS Output:
                          Vector& p_grid,
                          Tensor3& t_field,
                          Tensor3& z_field,
                          Tensor4& vmr_field,
                          Index& atmfields_checked,
                          Index& atmgeom_checked,
                          Index& cloudbox_checked,
                          // WS Input:
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Index& interp_order,
                          // Verbosity object:
                          const Verbosity& verbosity);


void AtmFieldsAndParticleBulkPropFieldFromCompact(// WS Output:
                                                  Vector& p_grid,
                                                  Vector& lat_grid,
                                                  Vector& lon_grid,
                                                  Tensor3& t_field,
                                                  Tensor3& z_field,
                                                  Tensor4& vmr_field,
                                                  Tensor4& particle_bulkprop_field,
                                                  ArrayOfString& particle_bulkprop_names,
                                                  // WS Input:
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  const GriddedField4& atm_fields_compact,
                                                  const Index& atmosphere_dim,
                                                  // WS Generic Input:
                                                  const String& delim,
                                                  const Numeric& p_min,
                                                  const Index& check_gridnames,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void atmfields_checkedCalc(// WS Output:
                           Index& atmfields_checked,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const ArrayOfArrayOfSpeciesTag& abs_species,
                           const Tensor3& t_field,
                           const Tensor4& vmr_field,
                           const Tensor3& wind_u_field,
                           const Tensor3& wind_v_field,
                           const Tensor3& wind_w_field,
                           const Tensor3& mag_u_field,
                           const Tensor3& mag_v_field,
                           const Tensor3& mag_w_field,
                           const SpeciesAuxData& partition_functions,
                           const Index& abs_f_interp_order,
                           // WS Generic Input:
                           const Index& negative_vmr_ok,
                           const Index& bad_partition_functions_ok,
                           // Verbosity object:
                           const Verbosity& verbosity);


void atmgeom_checkedCalc(// WS Output:
                         Index& atmgeom_checked,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Tensor3& z_field,
                         const Vector& refellipsoid,
                         const Matrix& z_surface,
                         const Vector& lat_true,
                         const Vector& lon_true,
                         // Verbosity object:
                         const Verbosity& verbosity);


void AtmosphereSet1D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_grid,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmosphereSet2D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lon_grid,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmosphereSet3D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lat_true,
                     Vector& lon_true,
                     // Verbosity object:
                     const Verbosity& verbosity);


void AtmRawRead(// WS Output:
                GriddedField3& t_field_raw,
                GriddedField3& z_field_raw,
                ArrayOfGriddedField3& vmr_field_raw,
                ArrayOfGriddedField3& nlte_field_raw,
                ArrayOfQuantumIdentifier& nlte_level_identifiers,
                Vector& nlte_vibrational_energies,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                // WS Generic Input:
                const String& basename,
                // Verbosity object:
                const Verbosity& verbosity);


void AtmWithNLTERawRead(// WS Output:
                        GriddedField3& t_field_raw,
                        GriddedField3& z_field_raw,
                        ArrayOfGriddedField3& vmr_field_raw,
                        ArrayOfGriddedField3& nlte_field_raw,
                        ArrayOfQuantumIdentifier& nlte_level_identifiers,
                        Vector& nlte_vibrational_energies,
                        // WS Input:
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        // WS Generic Input:
                        const String& basename,
                        const Index& expect_vibrational_energies,
                        // Verbosity object:
                        const Verbosity& verbosity);


void atm_fields_compactAddConstant(// WS Output:
                                   GriddedField4& atm_fields_compact,
                                   // WS Generic Input:
                                   const String& name,
                                   const Numeric& value,
                                   const Index& prepend,
                                   const ArrayOfString& condensibles,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void atm_fields_compactAddSpecies(// WS Output:
                                  GriddedField4& atm_fields_compact,
                                  // WS Generic Input:
                                  const String& name,
                                  const GriddedField3& value,
                                  const Index& prepend,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void atm_fields_compactCleanup(// WS Output:
                               GriddedField4& atm_fields_compact,
                               // WS Generic Input:
                               const Numeric& threshold,
                               // Verbosity object:
                               const Verbosity& verbosity);


void atm_fields_compactCreateFromField(// WS Output:
                                       GriddedField4& atm_fields_compact,
                                       // WS Generic Input:
                                       const String& name,
                                       const GriddedField3& field,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void atm_fields_compactFromMatrix(// WS Output:
                                  GriddedField4& atm_fields_compact,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  // WS Generic Input:
                                  const Matrix& gin1,
                                  const ArrayOfString& field_names,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void backend_channel_responseFlat(// WS Output:
                                  ArrayOfGriddedField1& backend_channel_response,
                                  // WS Generic Input:
                                  const Numeric& resolution,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void backend_channel_responseGaussian(// WS Output:
                                      ArrayOfGriddedField1& backend_channel_response,
                                      // WS Generic Input:
                                      const Vector& fwhm,
                                      const Vector& xwidth_si,
                                      const Vector& dx_si,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void batch_atm_fields_compactAddConstant(// WS Output:
                                         ArrayOfGriddedField4& batch_atm_fields_compact,
                                         // WS Generic Input:
                                         const String& name,
                                         const Numeric& value,
                                         const Index& prepend,
                                         const ArrayOfString& condensibles,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void batch_atm_fields_compactAddSpecies(// WS Output:
                                        ArrayOfGriddedField4& batch_atm_fields_compact,
                                        // WS Generic Input:
                                        const String& name,
                                        const GriddedField3& value,
                                        const Index& prepend,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void batch_atm_fields_compactCleanup(// WS Output:
                                     ArrayOfGriddedField4& batch_atm_fields_compact,
                                     // WS Generic Input:
                                     const Numeric& threshold,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void batch_atm_fields_compactFromArrayOfMatrix(// WS Output:
                                               ArrayOfGriddedField4& batch_atm_fields_compact,
                                               // WS Input:
                                               const Index& atmosphere_dim,
                                               // WS Generic Input:
                                               const ArrayOfMatrix& atmospheres_fields,
                                               const ArrayOfString& field_names,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void CIAInfo(// WS Generic Input:
             const String& catalogpath,
             const ArrayOfString& cia_tags,
             // Verbosity object:
             const Verbosity& verbosity);


void CIARecordReadFromFile(// WS Generic Output:
                           CIARecord& cia_record,
                           // WS Generic Input:
                           const String& species_tag,
                           const String& filename,
                           // Verbosity object:
                           const Verbosity& verbosity);


void cloudboxOff(// WS Output:
                 Index& cloudbox_on,
                 Index& ppath_inside_cloudbox_do,
                 ArrayOfIndex& cloudbox_limits,
                 Agenda& iy_cloudbox_agenda,
                 Tensor4& pnd_field,
                 ArrayOfTensor4& dpnd_field_dx,
                 ArrayOfString& scat_species,
                 ArrayOfArrayOfSingleScatteringData& scat_data,
                 ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                 Index& scat_data_checked,
                 Matrix& particle_masses,
                 // WS Input:
                 const ArrayOfRetrievalQuantity& jacobian_quantities,
                 // Verbosity object:
                 const Verbosity& verbosity);


void cloudboxSetAutomatically(// WS Output:
                              Index& cloudbox_on,
                              ArrayOfIndex& cloudbox_limits,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& p_grid,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              // WS Generic Input:
                              const Tensor4& particle_field,
                              const ArrayOfIndex& cloudbox_limits_old,
                              const Numeric& cloudbox_margin,
                              // Verbosity object:
                              const Verbosity& verbosity);


void cloudboxSetFullAtm(// WS Output:
                        Index& cloudbox_on,
                        ArrayOfIndex& cloudbox_limits,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Vector& p_grid,
                        const Vector& lat_grid,
                        const Vector& lon_grid,
                        // Verbosity object:
                        const Verbosity& verbosity);


void cloudboxSetManually(// WS Output:
                         Index& cloudbox_on,
                         ArrayOfIndex& cloudbox_limits,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         // WS Generic Input:
                         const Numeric& p1,
                         const Numeric& p2,
                         const Numeric& lat1,
                         const Numeric& lat2,
                         const Numeric& lon1,
                         const Numeric& lon2,
                         // Verbosity object:
                         const Verbosity& verbosity);


void cloudboxSetManuallyAltitude(// WS Output:
                                 Index& cloudbox_on,
                                 ArrayOfIndex& cloudbox_limits,
                                 // WS Input:
                                 const Index& atmosphere_dim,
                                 const Tensor3& z_field,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 // WS Generic Input:
                                 const Numeric& z1,
                                 const Numeric& z2,
                                 const Numeric& lat1,
                                 const Numeric& lat2,
                                 const Numeric& lon1,
                                 const Numeric& lon2,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void cloudbox_checkedCalc(// WS Output:
                          Index& cloudbox_checked,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmosphere_dim,
                          const Vector& p_grid,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& z_field,
                          const Matrix& z_surface,
                          const Tensor3& wind_u_field,
                          const Tensor3& wind_v_field,
                          const Tensor3& wind_w_field,
                          const Index& cloudbox_on,
                          const ArrayOfIndex& cloudbox_limits,
                          const Tensor4& pnd_field,
                          const ArrayOfTensor4& dpnd_field_dx,
                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                          const ArrayOfArrayOfSingleScatteringData& scat_data,
                          const ArrayOfString& scat_species,
                          const Matrix& particle_masses,
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          // WS Generic Input:
                          const Index& negative_pnd_ok,
                          // Verbosity object:
                          const Verbosity& verbosity);


void cloudbox_field_monoIterate(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                Tensor6& cloudbox_field_mono,
                                // WS Input:
                                const Agenda& doit_scat_field_agenda,
                                const Agenda& doit_rte_agenda,
                                const Agenda& doit_conv_test_agenda,
                                // WS Generic Input:
                                const Index& accelerated,
                                // Verbosity object:
                                const Verbosity& verbosity);


void cloudbox_fieldCrop(// WS Output:
                        Tensor7& cloudbox_field,
                        ArrayOfIndex& cloudbox_limits,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Index& cloudbox_on,
                        // WS Generic Input:
                        const Index& new_limit0,
                        const Index& new_limit1,
                        const Index& new_limit2,
                        const Index& new_limit3,
                        const Index& new_limit4,
                        const Index& new_limit5,
                        // Verbosity object:
                        const Verbosity& verbosity);


void cloudbox_fieldSetFromPrecalc(// WS Output:
                                  Tensor7& cloudbox_field,
                                  // WS Input:
                                  const Vector& za_grid,
                                  const Vector& f_grid,
                                  const Index& atmosphere_dim,
                                  const Index& stokes_dim,
                                  const ArrayOfIndex& cloudbox_limits,
                                  const Index& doit_is_initialized,
                                  // WS Generic Input:
                                  const Tensor7& cloudbox_field_precalc,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void cloudbox_fieldSetClearsky(// WS Output:
                               Tensor7& cloudbox_field,
                               // WS Input:
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const ArrayOfIndex& cloudbox_limits,
                               const Index& atmosphere_dim,
                               const Index& cloudbox_on,
                               const Index& doit_is_initialized,
                               // WS Generic Input:
                               const Index& all_frequencies,
                               // Verbosity object:
                               const Verbosity& verbosity);


void cloudbox_field_monoSetConst(// WS Output:
                                 Tensor6& cloudbox_field_mono,
                                 // WS Input:
                                 const Vector& p_grid,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 const ArrayOfIndex& cloudbox_limits,
                                 const Index& atmosphere_dim,
                                 const Index& stokes_dim,
                                 // WS Generic Input:
                                 const Vector& value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void cloudbox_fieldSetConst(// WS Output:
                            Tensor7& cloudbox_field,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const ArrayOfIndex& cloudbox_limits,
                            const Index& atmosphere_dim,
                            const Index& stokes_dim,
                            // WS Generic Input:
                            const Vector& value,
                            // Verbosity object:
                            const Verbosity& verbosity);


void cloudbox_fieldSetConstPerFreq(// WS Output:
                                   Tensor7& cloudbox_field,
                                   // WS Input:
                                   const Vector& p_grid,
                                   const Vector& lat_grid,
                                   const Vector& lon_grid,
                                   const ArrayOfIndex& cloudbox_limits,
                                   const Index& atmosphere_dim,
                                   const Index& stokes_dim,
                                   // WS Generic Input:
                                   const Matrix& value,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void cloudbox_fieldUpdate1D(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Tensor6& cloudbox_field_mono,
                            // WS Input:
                            const Tensor6& doit_scat_field,
                            const ArrayOfIndex& cloudbox_limits,
                            const Agenda& propmat_clearsky_agenda,
                            const Tensor4& vmr_field,
                            const Agenda& spt_calc_agenda,
                            const Vector& za_grid,
                            const Tensor4& pnd_field,
                            const Agenda& ppath_step_agenda,
                            const Numeric& ppath_lmax,
                            const Numeric& ppath_lraytrace,
                            const Vector& p_grid,
                            const Tensor3& z_field,
                            const Vector& refellipsoid,
                            const Tensor3& t_field,
                            const Vector& f_grid,
                            const Index& f_index,
                            const Agenda& surface_rtprop_agenda,
                            const Index& doit_za_interp,
                            // Verbosity object:
                            const Verbosity& verbosity);


void cloudbox_fieldUpdateSeq1D(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor6& cloudbox_field_mono,
                               Tensor6& doit_scat_field,
                               // WS Input:
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Tensor4& vmr_field,
                               const Agenda& spt_calc_agenda,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Tensor4& pnd_field,
                               const Agenda& ppath_step_agenda,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               const Vector& p_grid,
                               const Tensor3& z_field,
                               const Vector& refellipsoid,
                               const Tensor3& t_field,
                               const Vector& f_grid,
                               const Index& f_index,
                               const Agenda& surface_rtprop_agenda,
                               const Index& doit_za_interp,
                               // WS Generic Input:
                               const Index& normalize,
                               const Numeric& norm_error_threshold,
                               const Index& norm_debug,
                               // Verbosity object:
                               const Verbosity& verbosity);


void cloudbox_fieldUpdateSeq1DPP(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Tensor6& cloudbox_field_mono,
                                 Index& za_index,
                                 // WS Input:
                                 const Tensor6& doit_scat_field,
                                 const ArrayOfIndex& cloudbox_limits,
                                 const Agenda& propmat_clearsky_agenda,
                                 const Tensor4& vmr_field,
                                 const Agenda& spt_calc_agenda,
                                 const Vector& za_grid,
                                 const Tensor4& pnd_field,
                                 const Vector& p_grid,
                                 const Tensor3& z_field,
                                 const Tensor3& t_field,
                                 const Vector& f_grid,
                                 const Index& f_index,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void cloudbox_fieldUpdateSeq3D(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor6& cloudbox_field_mono,
                               // WS Input:
                               const Tensor6& doit_scat_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Tensor4& vmr_field,
                               const Agenda& spt_calc_agenda,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Tensor4& pnd_field,
                               const Agenda& ppath_step_agenda,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const Tensor3& z_field,
                               const Vector& refellipsoid,
                               const Tensor3& t_field,
                               const Vector& f_grid,
                               const Index& f_index,
                               const Index& doit_za_interp,
                               // Verbosity object:
                               const Verbosity& verbosity);


void cloudbox_field_monoOptimizeReverse(// WS Output:
                                        Tensor6& cloudbox_field_mono,
                                        // WS Input:
                                        const Vector& p_grid_orig,
                                        const Vector& p_grid,
                                        const ArrayOfIndex& cloudbox_limits,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Numeric& var1,
             const Numeric& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Vector& var1,
             const Vector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Matrix& var1,
             const Matrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Tensor3& var1,
             const Tensor3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Tensor4& var1,
             const Tensor4& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Tensor5& var1,
             const Tensor5& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Tensor7& var1,
             const Tensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const ArrayOfVector& var1,
             const ArrayOfVector& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const ArrayOfMatrix& var1,
             const ArrayOfMatrix& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const ArrayOfTensor7& var1,
             const ArrayOfTensor7& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const GriddedField3& var1,
             const GriddedField3& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const Sparse& var1,
             const Sparse& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void Compare(// WS Generic Input:
             const SingleScatteringData& var1,
             const SingleScatteringData& var2,
             const Numeric& maxabsdiff,
             const String& error_message,
             // WS Generic Input Names:
             const String& var1_wsvname,
             const String& var2_wsvname,
             const String& maxabsdiff_wsvname,
             const String& error_message_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Numeric& var1,
                     const Numeric& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Vector& var1,
                     const Vector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Matrix& var1,
                     const Matrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Tensor3& var1,
                     const Tensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Tensor4& var1,
                     const Tensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Tensor5& var1,
                     const Tensor5& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Tensor6& var1,
                     const Tensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const Tensor7& var1,
                     const Tensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfVector& var1,
                     const ArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfMatrix& var1,
                     const ArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor3& var1,
                     const ArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor4& var1,
                     const ArrayOfTensor4& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor6& var1,
                     const ArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfTensor7& var1,
                     const ArrayOfTensor7& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfVector& var1,
                     const ArrayOfArrayOfVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfMatrix& var1,
                     const ArrayOfArrayOfMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor3& var1,
                     const ArrayOfArrayOfTensor3& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfTensor6& var1,
                     const ArrayOfArrayOfTensor6& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfPropagationMatrix& var1,
                     const ArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfPropagationMatrix& var1,
                     const ArrayOfArrayOfPropagationMatrix& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfStokesVector& var1,
                     const ArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const ArrayOfArrayOfStokesVector& var1,
                     const ArrayOfArrayOfStokesVector& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void CompareRelative(// WS Generic Input:
                     const EnergyLevelMap& var1,
                     const EnergyLevelMap& var2,
                     const Numeric& maxabsreldiff,
                     const String& error_message,
                     // WS Generic Input Names:
                     const String& var1_wsvname,
                     const String& var2_wsvname,
                     const String& maxabsreldiff_wsvname,
                     const String& error_message_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);


void complex_refr_indexConstant(// WS Output:
                                GriddedField3& complex_refr_index,
                                // WS Generic Input:
                                const Numeric& refr_index_real,
                                const Numeric& refr_index_imag,
                                // Verbosity object:
                                const Verbosity& verbosity);


void complex_refr_indexIceMatzler06(// WS Output:
                                    GriddedField3& complex_refr_index,
                                    // WS Generic Input:
                                    const Vector& data_f_grid,
                                    const Vector& data_T_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void complex_refr_indexIceWarren84(// WS Output:
                                   GriddedField3& complex_refr_index,
                                   // WS Generic Input:
                                   const Vector& data_f_grid,
                                   const Vector& data_T_grid,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void complex_refr_indexWaterLiebe93(// WS Output:
                                    GriddedField3& complex_refr_index,
                                    // WS Generic Input:
                                    const Vector& data_f_grid,
                                    const Vector& data_T_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void covmat_sxExtractSqrtDiagonal(// WS Generic Output:
                                  Vector& x_norm,
                                  // WS Input:
                                  const CovarianceMatrix& covmat_sx,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void diameter_maxFromDiameter_volume_equ(// WS Generic Output:
                                         Numeric& diameter_max,
                                         Numeric& diameter_area_equ,
                                         // WS Generic Input:
                                         const String& shape,
                                         const Numeric& diameter_volume_equ,
                                         const Numeric& aspect_ratio,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void diameter_volume_equFromDiameter_max(// WS Generic Output:
                                         Numeric& diameter_volume_equ,
                                         Numeric& volume,
                                         // WS Generic Input:
                                         const String& shape,
                                         const Numeric& diameter_max,
                                         const Numeric& aspect_ratio,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void DiagonalMatrix(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);


void DiagonalMatrix(// WS Generic Output:
                    Sparse& out,
                    // WS Generic Input:
                    const Vector& v,
                    // Verbosity object:
                    const Verbosity& verbosity);


void DiffZaAa(// WS Generic Output:
              Matrix& dlos,
              // WS Generic Input:
              const Vector& ref_los,
              const Matrix& other_los,
              // Verbosity object:
              const Verbosity& verbosity);


void DisortCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Tensor7& cloudbox_field,
                // WS Input:
                const Index& atmfields_checked,
                const Index& atmgeom_checked,
                const Index& scat_data_checked,
                const Index& cloudbox_checked,
                const Index& cloudbox_on,
                const ArrayOfIndex& cloudbox_limits,
                const Agenda& propmat_clearsky_agenda,
                const Index& atmosphere_dim,
                const Tensor4& pnd_field,
                const Tensor3& t_field,
                const Tensor3& z_field,
                const Tensor4& vmr_field,
                const Vector& p_grid,
                const ArrayOfArrayOfSingleScatteringData& scat_data,
                const Vector& f_grid,
                const Vector& za_grid,
                const Index& stokes_dim,
                const Matrix& z_surface,
                const Numeric& surface_skin_t,
                const Vector& surface_scalar_reflectivity,
                // WS Generic Input:
                const Index& nstreams,
                const String& pfct_method,
                const Index& Npfct,
                const Index& quiet,
                // Verbosity object:
                const Verbosity& verbosity);


void DisortCalcWithARTSSurface(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor7& cloudbox_field,
                               // WS Input:
                               const Index& atmfields_checked,
                               const Index& atmgeom_checked,
                               const Index& scat_data_checked,
                               const Index& cloudbox_checked,
                               const Index& cloudbox_on,
                               const ArrayOfIndex& cloudbox_limits,
                               const Agenda& propmat_clearsky_agenda,
                               const Agenda& surface_rtprop_agenda,
                               const Index& atmosphere_dim,
                               const Tensor4& pnd_field,
                               const Tensor3& t_field,
                               const Tensor3& z_field,
                               const Tensor4& vmr_field,
                               const Vector& p_grid,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Vector& f_grid,
                               const Vector& za_grid,
                               const Index& stokes_dim,
                               // WS Generic Input:
                               const Index& nstreams,
                               const String& pfct_method,
                               const Index& Npfct,
                               const Index& quiet,
                               // Verbosity object:
                               const Verbosity& verbosity);


void DisortCalcClearsky(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Tensor7& spectral_radiance_field,
                        // WS Input:
                        const Index& atmfields_checked,
                        const Index& atmgeom_checked,
                        const Agenda& propmat_clearsky_agenda,
                        const Index& atmosphere_dim,
                        const Tensor3& t_field,
                        const Tensor3& z_field,
                        const Tensor4& vmr_field,
                        const Vector& p_grid,
                        const Vector& f_grid,
                        const Vector& za_grid,
                        const Index& stokes_dim,
                        const Matrix& z_surface,
                        const Numeric& surface_skin_t,
                        const Vector& surface_scalar_reflectivity,
                        // WS Generic Input:
                        const Index& nstreams,
                        const Index& quiet,
                        // Verbosity object:
                        const Verbosity& verbosity);


void DOBatchCalc(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 ArrayOfTensor7& dobatch_cloudbox_field,
                 ArrayOfTensor5& dobatch_radiance_field,
                 ArrayOfTensor4& dobatch_irradiance_field,
                 ArrayOfTensor5& dobatch_spectral_irradiance_field,
                 // WS Input:
                 const Index& ybatch_start,
                 const Index& ybatch_n,
                 const Agenda& dobatch_calc_agenda,
                 // WS Generic Input:
                 const Index& robust,
                 // Verbosity object:
                 const Verbosity& verbosity);


void DOAngularGridsSet(// WS Output:
                       Index& doit_za_grid_size,
                       Vector& aa_grid,
                       Vector& za_grid,
                       // WS Generic Input:
                       const Index& N_za_grid,
                       const Index& N_aa_grid,
                       const String& za_grid_opt_file,
                       // Verbosity object:
                       const Verbosity& verbosity);


void DoitCalc(// Workspace reference:
              Workspace& ws,
              // WS Output:
              Tensor7& cloudbox_field,
              // WS Input:
              const Index& atmfields_checked,
              const Index& atmgeom_checked,
              const Index& cloudbox_checked,
              const Index& scat_data_checked,
              const Index& cloudbox_on,
              const Vector& f_grid,
              const Agenda& doit_mono_agenda,
              const Index& doit_is_initialized,
              // Verbosity object:
              const Verbosity& verbosity);


void DoitGetIncoming(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Tensor7& cloudbox_field,
                     // WS Input:
                     const Index& atmfields_checked,
                     const Index& atmgeom_checked,
                     const Index& cloudbox_checked,
                     const Index& doit_is_initialized,
                     const Agenda& iy_main_agenda,
                     const Index& atmosphere_dim,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     const Tensor3& z_field,
                     const EnergyLevelMap& nlte_field,
                     const Index& cloudbox_on,
                     const ArrayOfIndex& cloudbox_limits,
                     const Vector& f_grid,
                     const Index& stokes_dim,
                     const Vector& za_grid,
                     const Vector& aa_grid,
                     // WS Generic Input:
                     const Index& rigorous,
                     const Numeric& maxratio,
                     // Verbosity object:
                     const Verbosity& verbosity);


void DoitGetIncoming1DAtm(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Tensor7& cloudbox_field,
                          Index& cloudbox_on,
                          // WS Input:
                          const Index& atmfields_checked,
                          const Index& atmgeom_checked,
                          const Index& cloudbox_checked,
                          const Index& doit_is_initialized,
                          const Agenda& iy_main_agenda,
                          const Index& atmosphere_dim,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& z_field,
                          const EnergyLevelMap& nlte_field,
                          const ArrayOfIndex& cloudbox_limits,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Vector& za_grid,
                          const Vector& aa_grid,
                          // Verbosity object:
                          const Verbosity& verbosity);


void DoitInit(// WS Output:
              Tensor6& doit_scat_field,
              Tensor7& cloudbox_field,
              Index& doit_is_initialized,
              // WS Input:
              const Index& stokes_dim,
              const Index& atmosphere_dim,
              const Vector& f_grid,
              const Vector& za_grid,
              const Vector& aa_grid,
              const Index& doit_za_grid_size,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              // Verbosity object:
              const Verbosity& verbosity);


void DoitScatteringDataPrepare(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               ArrayOfTensor7& pha_mat_sptDOITOpt,
                               ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                               Tensor7& pha_mat_doit,
                               Vector& aa_grid,
                               // WS Input:
                               const Index& doit_za_grid_size,
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Index& scat_data_checked,
                               const Index& f_index,
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               const Tensor3& t_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Tensor4& pnd_field,
                               const Agenda& pha_mat_spt_agenda,
                               // Verbosity object:
                               const Verbosity& verbosity);


void DoitWriteIterationFields(// WS Input:
                              const Index& doit_iteration_counter,
                              const Tensor6& cloudbox_field_mono,
                              const Index& f_index,
                              // WS Generic Input:
                              const ArrayOfIndex& iterations,
                              const ArrayOfIndex& frequencies,
                              // Verbosity object:
                              const Verbosity& verbosity);


void doit_conv_flagAbs(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       Tensor6& cloudbox_field_mono,
                       // WS Input:
                       const Tensor6& cloudbox_field_mono_old,
                       // WS Generic Input:
                       const Vector& epsilon,
                       const Index& max_iterations,
                       const Index& nonconv_return_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);


void doit_conv_flagAbsBT(// WS Output:
                         Index& doit_conv_flag,
                         Index& doit_iteration_counter,
                         Tensor6& cloudbox_field_mono,
                         // WS Input:
                         const Tensor6& cloudbox_field_mono_old,
                         const Vector& f_grid,
                         const Index& f_index,
                         // WS Generic Input:
                         const Vector& epsilon,
                         const Index& max_iterations,
                         const Index& nonconv_return_nan,
                         // Verbosity object:
                         const Verbosity& verbosity);


void doit_conv_flagLsq(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       Tensor6& cloudbox_field_mono,
                       // WS Input:
                       const Tensor6& cloudbox_field_mono_old,
                       const Vector& f_grid,
                       const Index& f_index,
                       // WS Generic Input:
                       const Vector& epsilon,
                       const Index& max_iterations,
                       const Index& nonconv_return_nan,
                       // Verbosity object:
                       const Verbosity& verbosity);


void OptimizeDoitPressureGrid(// Workspace reference:
                              Workspace& ws,
                              // WS Output:
                              Vector& p_grid,
                              Tensor4& pnd_field,
                              Tensor3& t_field,
                              ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                              Tensor3& z_field,
                              ArrayOfIndex& cloudbox_limits,
                              Tensor6& cloudbox_field_mono,
                              Tensor7& pha_mat_doit,
                              Tensor4& vmr_field,
                              Vector& p_grid_orig,
                              // WS Input:
                              const Vector& f_grid,
                              const Index& f_index,
                              const Agenda& propmat_clearsky_agenda,
                              // WS Generic Input:
                              const Numeric& tau_scat_max,
                              const Numeric& sgl_alb_max,
                              const Index& cloudbox_size_max,
                              // Verbosity object:
                              const Verbosity& verbosity);


void doit_scat_fieldCalc(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor6& doit_scat_field,
                         // WS Input:
                         const Agenda& pha_mat_spt_agenda,
                         const Tensor6& cloudbox_field_mono,
                         const Tensor4& pnd_field,
                         const Tensor3& t_field,
                         const Index& atmosphere_dim,
                         const ArrayOfIndex& cloudbox_limits,
                         const Vector& za_grid,
                         const Vector& aa_grid,
                         const Index& doit_za_grid_size,
                         const Tensor7& pha_mat_doit,
                         // Verbosity object:
                         const Verbosity& verbosity);


void doit_scat_fieldCalcLimb(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Tensor6& doit_scat_field,
                             // WS Input:
                             const Agenda& pha_mat_spt_agenda,
                             const Tensor6& cloudbox_field_mono,
                             const Tensor4& pnd_field,
                             const Tensor3& t_field,
                             const Index& atmosphere_dim,
                             const ArrayOfIndex& cloudbox_limits,
                             const Vector& za_grid,
                             const Vector& aa_grid,
                             const Index& doit_za_grid_size,
                             const Index& doit_za_interp,
                             const Tensor7& pha_mat_doit,
                             // Verbosity object:
                             const Verbosity& verbosity);


void doit_za_grid_optCalc(// WS Output:
                          Vector& doit_za_grid_opt,
                          // WS Input:
                          const Tensor6& cloudbox_field_mono,
                          const Vector& za_grid,
                          const Index& doit_za_interp,
                          // WS Generic Input:
                          const Numeric& acc,
                          // Verbosity object:
                          const Verbosity& verbosity);


void doit_za_interpSet(// WS Output:
                       Index& doit_za_interp,
                       // WS Input:
                       const Index& atmosphere_dim,
                       // WS Generic Input:
                       const String& interp_method,
                       // Verbosity object:
                       const Verbosity& verbosity);


void Duration(// WS Generic Output:
              Numeric& duration,
              // WS Generic Input:
              const Time& start,
              const Time& end,
              // Verbosity object:
              const Verbosity& verbosity);


void EnergyLevelMapSet(// WS Generic Output:
                       EnergyLevelMap& x,
                       // WS Generic Input:
                       const EnergyLevelMap& y,
                       // Verbosity object:
                       const Verbosity& verbosity);


void Error(// WS Generic Input:
           const String& msg,
           // Verbosity object:
           const Verbosity& verbosity);


void Exit(// Verbosity object:
          const Verbosity& verbosity);


void ExtractFromMetaSingleScatSpecies(// WS Generic Output:
                                      Vector& meta_param,
                                      // WS Input:
                                      const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                      // WS Generic Input:
                                      const String& meta_name,
                                      const Index& scat_species_index,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void ext_matAddGas(// WS Output:
                   PropagationMatrix& ext_mat,
                   // WS Input:
                   const ArrayOfPropagationMatrix& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);


void FastemStandAlone(// WS Generic Output:
                      Matrix& emissivity,
                      Matrix& reflectivity,
                      // WS Input:
                      const Vector& f_grid,
                      const Numeric& surface_skin_t,
                      // WS Generic Input:
                      const Numeric& za,
                      const Numeric& salinity,
                      const Numeric& wind_speed,
                      const Numeric& rel_aa,
                      const Vector& transmittance,
                      const Index& fastem_version,
                      // Verbosity object:
                      const Verbosity& verbosity);


void FieldFromGriddedField(// WS Generic Output:
                           Matrix& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField2& in,
                           // Verbosity object:
                           const Verbosity& verbosity);


void FieldFromGriddedField(// WS Generic Output:
                           Tensor3& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);


void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const GriddedField4& in,
                           // Verbosity object:
                           const Verbosity& verbosity);


void FieldFromGriddedField(// WS Generic Output:
                           Tensor4& out,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const ArrayOfGriddedField3& in,
                           // Verbosity object:
                           const Verbosity& verbosity);


void FlagOff(// WS Generic Output:
             Index& flag,
             // Verbosity object:
             const Verbosity& verbosity);


void FlagOn(// WS Generic Output:
            Index& flag,
            // Verbosity object:
            const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             ArrayOfTime& out,
             // WS Generic Input:
             const ArrayOfArrayOfTime& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             ArrayOfVector& out,
             // WS Generic Input:
             const ArrayOfArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Matrix& out,
             // WS Generic Input:
             const ArrayOfVector& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Tensor3& out,
             // WS Generic Input:
             const ArrayOfMatrix& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Tensor4& out,
             // WS Generic Input:
             const ArrayOfTensor3& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Tensor5& out,
             // WS Generic Input:
             const ArrayOfTensor4& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Tensor6& out,
             // WS Generic Input:
             const ArrayOfTensor5& in,
             // Verbosity object:
             const Verbosity& verbosity);


void Flatten(// WS Generic Output:
             Tensor7& out,
             // WS Generic Input:
             const ArrayOfTensor6& in,
             // Verbosity object:
             const Verbosity& verbosity);


void ForLoop(// Workspace reference:
             Workspace& ws,
             // WS Input:
             const Agenda& forloop_agenda,
             // WS Generic Input:
             const Index& start,
             const Index& stop,
             const Index& step,
             // Verbosity object:
             const Verbosity& verbosity);


void FrequencyFromWavelength(// WS Generic Output:
                             Numeric& frequency,
                             // WS Generic Input:
                             const Numeric& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);


void FrequencyFromWavelength(// WS Generic Output:
                             Vector& frequency,
                             // WS Generic Input:
                             const Vector& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);


void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Numeric& frequency,
                                       // WS Generic Input:
                                       const Numeric& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void FrequencyFromCGSAngularWavenumber(// WS Generic Output:
                                       Vector& frequency,
                                       // WS Generic Input:
                                       const Vector& angular_wavenumber,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Numeric& frequency,
                                      // WS Generic Input:
                                      const Numeric& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void FrequencyFromCGSKayserWavenumber(// WS Generic Output:
                                      Vector& frequency,
                                      // WS Generic Input:
                                      const Vector& kayser_wavenumber,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void f_gridFromAbsorptionLines(// WS Output:
                               Vector& f_grid,
                               // WS Input:
                               const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                               // WS Generic Input:
                               const Numeric& delta_f_low,
                               const Numeric& delta_f_upp,
                               const Index& num_freqs,
                               // Verbosity object:
                               const Verbosity& verbosity);


void f_gridFromGasAbsLookup(// WS Output:
                            Vector& f_grid,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            // Verbosity object:
                            const Verbosity& verbosity);


void f_gridFromSensorAMSU(// WS Output:
                          Vector& f_grid,
                          // WS Input:
                          const Vector& lo_multi,
                          const ArrayOfVector& f_backend_multi,
                          const ArrayOfArrayOfGriddedField1& backend_channel_response_multi,
                          // WS Generic Input:
                          const Numeric& spacing,
                          // Verbosity object:
                          const Verbosity& verbosity);


void f_gridFromSensorAMSUgeneric(// WS Output:
                                 Vector& f_grid,
                                 // WS Input:
                                 const ArrayOfVector& f_backend_multi,
                                 const ArrayOfArrayOfGriddedField1& backend_channel_response_multi,
                                 // WS Generic Input:
                                 const Numeric& spacing,
                                 const Vector& verbosityVect,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void f_gridFromSensorHIRS(// WS Output:
                          Vector& f_grid,
                          // WS Input:
                          const Vector& f_backend,
                          const ArrayOfGriddedField1& backend_channel_response,
                          // WS Generic Input:
                          const Numeric& spacing,
                          // Verbosity object:
                          const Verbosity& verbosity);


void f_gridMetMM(// WS Output:
                 Vector& f_grid,
                 Vector& f_backend,
                 ArrayOfArrayOfIndex& channel2fgrid_indexes,
                 ArrayOfVector& channel2fgrid_weights,
                 // WS Input:
                 const Matrix& met_mm_backend,
                 // WS Generic Input:
                 const Vector& freq_spacing,
                 const ArrayOfIndex& freq_number,
                 const Numeric& freq_merge_threshold,
                 // Verbosity object:
                 const Verbosity& verbosity);


void g0Earth(// WS Output:
             Numeric& g0,
             // WS Input:
             const Numeric& lat,
             // Verbosity object:
             const Verbosity& verbosity);


void g0Io(// WS Output:
          Numeric& g0,
          // Verbosity object:
          const Verbosity& verbosity);


void g0Jupiter(// WS Output:
               Numeric& g0,
               // Verbosity object:
               const Verbosity& verbosity);


void g0Mars(// WS Output:
            Numeric& g0,
            // Verbosity object:
            const Verbosity& verbosity);


void g0Venus(// WS Output:
             Numeric& g0,
             // Verbosity object:
             const Verbosity& verbosity);


void geo_posEndOfPpath(// WS Output:
                       Vector& geo_pos,
                       // WS Input:
                       const Ppath& ppath,
                       // Verbosity object:
                       const Verbosity& verbosity);


void geo_posLowestAltitudeOfPpath(// WS Output:
                                  Vector& geo_pos,
                                  // WS Input:
                                  const Ppath& ppath,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void geo_posWherePpathPassesZref(// WS Output:
                                 Vector& geo_pos,
                                 // WS Input:
                                 const Ppath& ppath,
                                 // WS Generic Input:
                                 const Numeric& z_ref,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void GetEnvironmentVariable(// WS Generic Output:
                            String& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);


void GetEnvironmentVariable(// WS Generic Output:
                            Index& out,
                            // WS Generic Input:
                            const String& in,
                            // Verbosity object:
                            const Verbosity& verbosity);


void GetNumberOfThreads(// WS Generic Output:
                        Index& nthreads,
                        // Verbosity object:
                        const Verbosity& verbosity);


void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField2& out,
                              // WS Generic Input:
                              const GriddedField2& in,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField3& out,
                              // WS Generic Input:
                              const GriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonExpand(// WS Generic Output:
                              GriddedField4& out,
                              // WS Generic Input:
                              const GriddedField4& in,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonExpand(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField2& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField2& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonRegrid(// WS Generic Output:
                              GriddedField4& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const GriddedField4& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldLatLonRegrid(// WS Generic Output:
                              ArrayOfGriddedField3& out,
                              // WS Input:
                              const Vector& lat_true,
                              const Vector& lon_true,
                              // WS Generic Input:
                              const ArrayOfGriddedField3& in,
                              const Index& interp_order,
                              // Verbosity object:
                              const Verbosity& verbosity);


void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedFieldPRegrid(// WS Generic Output:
                         GriddedField4& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const GriddedField4& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedFieldPRegrid(// WS Generic Output:
                         ArrayOfGriddedField3& out,
                         // WS Input:
                         const Vector& p_grid,
                         // WS Generic Input:
                         const ArrayOfGriddedField3& in,
                         const Index& interp_order,
                         const Index& zeropadding,
                         // Verbosity object:
                         const Verbosity& verbosity);


void GriddedFieldZToPRegrid(// WS Generic Output:
                            GriddedField3& out,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const Tensor3& z_field,
                            // WS Generic Input:
                            const GriddedField3& in,
                            const Index& interp_order,
                            const Index& zeropadding,
                            // Verbosity object:
                            const Verbosity& verbosity);


void heating_ratesFromIrradiance(// WS Output:
                                 Tensor3& heating_rates,
                                 // WS Input:
                                 const Vector& p_grid,
                                 const Tensor4& irradiance_field,
                                 const Tensor3& specific_heat_capacity,
                                 const Numeric& g0,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void INCLUDE(// Verbosity object:
             const Verbosity& verbosity);


void IndexAdd(// WS Generic Output:
              Index& out,
              // WS Generic Input:
              const Index& in,
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);


void IndexNumberOfAtmosphericPoints(// WS Generic Output:
                                    Index& n,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void IndexSet(// WS Generic Output:
              Index& out,
              // WS Generic Input:
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);


void IndexStepDown(// WS Generic Output:
                   Index& out,
                   // WS Generic Input:
                   const Index& in,
                   // Verbosity object:
                   const Verbosity& verbosity);


void IndexStepUp(// WS Generic Output:
                 Index& out,
                 // WS Generic Input:
                 const Index& in,
                 // Verbosity object:
                 const Verbosity& verbosity);


void InterpAtmFieldToPosition(// WS Generic Output:
                              Numeric& out,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& p_grid,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              const Tensor3& z_field,
                              const Vector& rtp_pos,
                              // WS Generic Input:
                              const Tensor3& field,
                              // Verbosity object:
                              const Verbosity& verbosity);


void InterpGriddedField2ToPosition(// WS Generic Output:
                                   Numeric& out,
                                   // WS Input:
                                   const Index& atmosphere_dim,
                                   const Vector& lat_grid,
                                   const Vector& lat_true,
                                   const Vector& lon_true,
                                   const Vector& rtp_pos,
                                   // WS Generic Input:
                                   const GriddedField2& gfield2,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void InterpSurfaceFieldToPosition(// WS Generic Output:
                                  Numeric& out,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  const Vector& lat_grid,
                                  const Vector& lon_grid,
                                  const Vector& rtp_pos,
                                  const Matrix& z_surface,
                                  // WS Generic Input:
                                  const Matrix& field,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void irradiance_fieldFromRadiance(// WS Output:
                                  Tensor4& irradiance_field,
                                  // WS Input:
                                  const Tensor5& radiance_field,
                                  const Vector& za_grid,
                                  const Vector& aa_grid,
                                  const Vector& za_grid_weights,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void isotopologue_ratiosInitFromBuiltin(// WS Output:
                                        SpeciesAuxData& isotopologue_ratios,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void iyActiveSingleScat(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Matrix& iy,
                        ArrayOfMatrix& iy_aux,
                        ArrayOfTensor3& diy_dx,
                        Vector& ppvar_p,
                        Vector& ppvar_t,
                        EnergyLevelMap& ppvar_nlte,
                        Matrix& ppvar_vmr,
                        Matrix& ppvar_wind,
                        Matrix& ppvar_mag,
                        Matrix& ppvar_pnd,
                        Matrix& ppvar_f,
                        Tensor4& ppvar_trans_cumulat,
                        // WS Input:
                        const Index& stokes_dim,
                        const Vector& f_grid,
                        const Index& atmosphere_dim,
                        const Vector& p_grid,
                        const Tensor3& t_field,
                        const EnergyLevelMap& nlte_field,
                        const Tensor4& vmr_field,
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        const Tensor3& wind_u_field,
                        const Tensor3& wind_v_field,
                        const Tensor3& wind_w_field,
                        const Tensor3& mag_u_field,
                        const Tensor3& mag_v_field,
                        const Tensor3& mag_w_field,
                        const Index& cloudbox_on,
                        const ArrayOfIndex& cloudbox_limits,
                        const Tensor4& pnd_field,
                        const ArrayOfTensor4& dpnd_field_dx,
                        const ArrayOfString& scat_species,
                        const ArrayOfArrayOfSingleScatteringData& scat_data,
                        const Index& scat_data_checked,
                        const ArrayOfString& iy_aux_vars,
                        const Index& jacobian_do,
                        const ArrayOfRetrievalQuantity& jacobian_quantities,
                        const Ppath& ppath,
                        const Agenda& propmat_clearsky_agenda,
                        const Agenda& water_p_eq_agenda,
                        const Agenda& iy_transmitter_agenda,
                        const Index& iy_agenda_call1,
                        const Tensor3& iy_transmission,
                        const Numeric& rte_alonglos_v,
                        // WS Generic Input:
                        const Index& trans_in_jacobian,
                        const Numeric& pext_scaling,
                        const Index& t_interp_order,
                        // Verbosity object:
                        const Verbosity& verbosity);


void iyActiveSingleScat2(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Matrix& iy,
                         ArrayOfMatrix& iy_aux,
                         ArrayOfTensor3& diy_dx,
                         Vector& ppvar_p,
                         Vector& ppvar_t,
                         EnergyLevelMap& ppvar_nlte,
                         Matrix& ppvar_vmr,
                         Matrix& ppvar_wind,
                         Matrix& ppvar_mag,
                         Matrix& ppvar_pnd,
                         Matrix& ppvar_f,
                         Tensor4& ppvar_trans_cumulat,
                         // WS Input:
                         const Index& stokes_dim,
                         const Vector& f_grid,
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Tensor3& t_field,
                         const EnergyLevelMap& nlte_field,
                         const Tensor4& vmr_field,
                         const ArrayOfArrayOfSpeciesTag& abs_species,
                         const Tensor3& wind_u_field,
                         const Tensor3& wind_v_field,
                         const Tensor3& wind_w_field,
                         const Tensor3& mag_u_field,
                         const Tensor3& mag_v_field,
                         const Tensor3& mag_w_field,
                         const Index& cloudbox_on,
                         const ArrayOfIndex& cloudbox_limits,
                         const Tensor4& pnd_field,
                         const ArrayOfTensor4& dpnd_field_dx,
                         const ArrayOfString& scat_species,
                         const ArrayOfArrayOfSingleScatteringData& scat_data,
                         const Index& scat_data_checked,
                         const ArrayOfString& iy_aux_vars,
                         const Index& jacobian_do,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const Ppath& ppath,
                         const Agenda& propmat_clearsky_agenda,
                         const Agenda& water_p_eq_agenda,
                         const Agenda& iy_transmitter_agenda,
                         const Index& iy_agenda_call1,
                         const Tensor3& iy_transmission,
                         const Numeric& rte_alonglos_v,
                         // WS Generic Input:
                         const Index& trans_in_jacobian,
                         const Numeric& pext_scaling,
                         const Index& t_interp_order,
                         // Verbosity object:
                         const Verbosity& verbosity);


void iyApplyUnit(// WS Output:
                 Matrix& iy,
                 ArrayOfMatrix& iy_aux,
                 // WS Input:
                 const Index& stokes_dim,
                 const Vector& f_grid,
                 const ArrayOfString& iy_aux_vars,
                 const String& iy_unit,
                 // Verbosity object:
                 const Verbosity& verbosity);


void iyCalc(// Workspace reference:
            Workspace& ws,
            // WS Output:
            Matrix& iy,
            ArrayOfMatrix& iy_aux,
            Ppath& ppath,
            // WS Input:
            const Index& atmgeom_checked,
            const Index& atmfields_checked,
            const ArrayOfString& iy_aux_vars,
            const Index& iy_id,
            const Index& cloudbox_on,
            const Index& cloudbox_checked,
            const Index& scat_data_checked,
            const Vector& f_grid,
            const EnergyLevelMap& nlte_field,
            const Vector& rte_pos,
            const Vector& rte_los,
            const Vector& rte_pos2,
            const String& iy_unit,
            const Agenda& iy_main_agenda,
            // Verbosity object:
            const Verbosity& verbosity);


void iyEmissionStandard(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Matrix& iy,
                        ArrayOfMatrix& iy_aux,
                        ArrayOfTensor3& diy_dx,
                        Vector& ppvar_p,
                        Vector& ppvar_t,
                        EnergyLevelMap& ppvar_nlte,
                        Matrix& ppvar_vmr,
                        Matrix& ppvar_wind,
                        Matrix& ppvar_mag,
                        Matrix& ppvar_f,
                        Tensor3& ppvar_iy,
                        Tensor4& ppvar_trans_cumulat,
                        Tensor4& ppvar_trans_partial,
                        // WS Input:
                        const Index& iy_id,
                        const Index& stokes_dim,
                        const Vector& f_grid,
                        const Index& atmosphere_dim,
                        const Vector& p_grid,
                        const Tensor3& t_field,
                        const EnergyLevelMap& nlte_field,
                        const Tensor4& vmr_field,
                        const ArrayOfArrayOfSpeciesTag& abs_species,
                        const Tensor3& wind_u_field,
                        const Tensor3& wind_v_field,
                        const Tensor3& wind_w_field,
                        const Tensor3& mag_u_field,
                        const Tensor3& mag_v_field,
                        const Tensor3& mag_w_field,
                        const Index& cloudbox_on,
                        const String& iy_unit,
                        const ArrayOfString& iy_aux_vars,
                        const Index& jacobian_do,
                        const ArrayOfRetrievalQuantity& jacobian_quantities,
                        const Ppath& ppath,
                        const Vector& rte_pos2,
                        const Agenda& propmat_clearsky_agenda,
                        const Agenda& water_p_eq_agenda,
                        const Agenda& iy_main_agenda,
                        const Agenda& iy_space_agenda,
                        const Agenda& iy_surface_agenda,
                        const Agenda& iy_cloudbox_agenda,
                        const Index& iy_agenda_call1,
                        const Tensor3& iy_transmission,
                        const Numeric& rte_alonglos_v,
                        const Tensor3& surface_props_data,
                        // Verbosity object:
                        const Verbosity& verbosity);


void iyEmissionStandardSequential(// Workspace reference:
                                  Workspace& ws,
                                  // WS Output:
                                  Matrix& iy,
                                  ArrayOfMatrix& iy_aux,
                                  ArrayOfTensor3& diy_dx,
                                  Vector& ppvar_p,
                                  Vector& ppvar_t,
                                  EnergyLevelMap& ppvar_nlte,
                                  Matrix& ppvar_vmr,
                                  Matrix& ppvar_wind,
                                  Matrix& ppvar_mag,
                                  Matrix& ppvar_f,
                                  Tensor3& ppvar_iy,
                                  Tensor4& ppvar_trans_cumulat,
                                  Tensor4& ppvar_trans_partial,
                                  // WS Input:
                                  const Index& iy_id,
                                  const Index& stokes_dim,
                                  const Vector& f_grid,
                                  const Index& atmosphere_dim,
                                  const Vector& p_grid,
                                  const Tensor3& t_field,
                                  const EnergyLevelMap& nlte_field,
                                  const Tensor4& vmr_field,
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const Tensor3& wind_u_field,
                                  const Tensor3& wind_v_field,
                                  const Tensor3& wind_w_field,
                                  const Tensor3& mag_u_field,
                                  const Tensor3& mag_v_field,
                                  const Tensor3& mag_w_field,
                                  const Index& cloudbox_on,
                                  const String& iy_unit,
                                  const ArrayOfString& iy_aux_vars,
                                  const Index& jacobian_do,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const Ppath& ppath,
                                  const Vector& rte_pos2,
                                  const Agenda& propmat_clearsky_agenda,
                                  const Agenda& water_p_eq_agenda,
                                  const Agenda& iy_main_agenda,
                                  const Agenda& iy_space_agenda,
                                  const Agenda& iy_surface_agenda,
                                  const Agenda& iy_cloudbox_agenda,
                                  const Index& iy_agenda_call1,
                                  const Tensor3& iy_transmission,
                                  const Numeric& rte_alonglos_v,
                                  const Tensor3& surface_props_data,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void iyHybrid(// Workspace reference:
              Workspace& ws,
              // WS Output:
              Matrix& iy,
              ArrayOfMatrix& iy_aux,
              ArrayOfTensor3& diy_dx,
              Vector& ppvar_p,
              Vector& ppvar_t,
              EnergyLevelMap& ppvar_nlte,
              Matrix& ppvar_vmr,
              Matrix& ppvar_wind,
              Matrix& ppvar_mag,
              Matrix& ppvar_pnd,
              Matrix& ppvar_f,
              Tensor3& ppvar_iy,
              Tensor4& ppvar_trans_cumulat,
              // WS Input:
              const Index& iy_id,
              const Index& stokes_dim,
              const Vector& f_grid,
              const Index& atmosphere_dim,
              const Vector& p_grid,
              const Tensor3& t_field,
              const EnergyLevelMap& nlte_field,
              const Tensor4& vmr_field,
              const ArrayOfArrayOfSpeciesTag& abs_species,
              const Tensor3& wind_u_field,
              const Tensor3& wind_v_field,
              const Tensor3& wind_w_field,
              const Tensor3& mag_u_field,
              const Tensor3& mag_v_field,
              const Tensor3& mag_w_field,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              const Tensor4& pnd_field,
              const ArrayOfTensor4& dpnd_field_dx,
              const ArrayOfString& scat_species,
              const ArrayOfArrayOfSingleScatteringData& scat_data,
              const String& iy_unit,
              const ArrayOfString& iy_aux_vars,
              const Index& jacobian_do,
              const ArrayOfRetrievalQuantity& jacobian_quantities,
              const Agenda& propmat_clearsky_agenda,
              const Agenda& water_p_eq_agenda,
              const Agenda& iy_main_agenda,
              const Agenda& iy_space_agenda,
              const Agenda& iy_surface_agenda,
              const Agenda& iy_cloudbox_agenda,
              const Index& iy_agenda_call1,
              const Tensor3& iy_transmission,
              const Ppath& ppath,
              const Vector& rte_pos2,
              const Numeric& rte_alonglos_v,
              const Tensor3& surface_props_data,
              const Tensor7& cloudbox_field,
              const Vector& za_grid,
              // WS Generic Input:
              const Index& Naa_grid,
              const Index& t_interp_order,
              // Verbosity object:
              const Verbosity& verbosity);


void iyHybrid2(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Matrix& iy,
               ArrayOfMatrix& iy_aux,
               ArrayOfTensor3& diy_dx,
               Vector& ppvar_p,
               Vector& ppvar_t,
               EnergyLevelMap& ppvar_nlte,
               Matrix& ppvar_vmr,
               Matrix& ppvar_wind,
               Matrix& ppvar_mag,
               Matrix& ppvar_pnd,
               Matrix& ppvar_f,
               Tensor3& ppvar_iy,
               Tensor4& ppvar_trans_cumulat,
               // WS Input:
               const Index& iy_id,
               const Index& stokes_dim,
               const Vector& f_grid,
               const Index& atmosphere_dim,
               const Vector& p_grid,
               const Tensor3& t_field,
               const EnergyLevelMap& nlte_field,
               const Tensor4& vmr_field,
               const ArrayOfArrayOfSpeciesTag& abs_species,
               const Tensor3& wind_u_field,
               const Tensor3& wind_v_field,
               const Tensor3& wind_w_field,
               const Tensor3& mag_u_field,
               const Tensor3& mag_v_field,
               const Tensor3& mag_w_field,
               const Index& cloudbox_on,
               const ArrayOfIndex& cloudbox_limits,
               const Tensor4& pnd_field,
               const ArrayOfTensor4& dpnd_field_dx,
               const ArrayOfString& scat_species,
               const ArrayOfArrayOfSingleScatteringData& scat_data,
               const String& iy_unit,
               const ArrayOfString& iy_aux_vars,
               const Index& jacobian_do,
               const ArrayOfRetrievalQuantity& jacobian_quantities,
               const Agenda& propmat_clearsky_agenda,
               const Agenda& water_p_eq_agenda,
               const Agenda& iy_main_agenda,
               const Agenda& iy_space_agenda,
               const Agenda& iy_surface_agenda,
               const Agenda& iy_cloudbox_agenda,
               const Index& iy_agenda_call1,
               const Tensor3& iy_transmission,
               const Ppath& ppath,
               const Vector& rte_pos2,
               const Numeric& rte_alonglos_v,
               const Tensor3& surface_props_data,
               const Tensor7& cloudbox_field,
               const Vector& za_grid,
               // WS Generic Input:
               const Index& Naa_grid,
               const Index& t_interp_order,
               // Verbosity object:
               const Verbosity& verbosity);


void iyIndependentBeamApproximation(// Workspace reference:
                                    Workspace& ws,
                                    // WS Output:
                                    Matrix& iy,
                                    ArrayOfMatrix& iy_aux,
                                    Ppath& ppath,
                                    ArrayOfTensor3& diy_dx,
                                    GriddedField4& atm_fields_compact,
                                    // WS Input:
                                    const Index& iy_id,
                                    const Vector& f_grid,
                                    const Index& atmosphere_dim,
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    const Vector& lat_true,
                                    const Vector& lon_true,
                                    const Tensor3& t_field,
                                    const Tensor3& z_field,
                                    const Tensor4& vmr_field,
                                    const EnergyLevelMap& nlte_field,
                                    const Tensor3& wind_u_field,
                                    const Tensor3& wind_v_field,
                                    const Tensor3& wind_w_field,
                                    const Tensor3& mag_u_field,
                                    const Tensor3& mag_v_field,
                                    const Tensor3& mag_w_field,
                                    const Index& cloudbox_on,
                                    const ArrayOfIndex& cloudbox_limits,
                                    const Tensor4& pnd_field,
                                    const Matrix& particle_masses,
                                    const Agenda& ppath_agenda,
                                    const Numeric& ppath_lmax,
                                    const Numeric& ppath_lraytrace,
                                    const Index& iy_agenda_call1,
                                    const String& iy_unit,
                                    const Tensor3& iy_transmission,
                                    const Vector& rte_pos,
                                    const Vector& rte_los,
                                    const Vector& rte_pos2,
                                    const Index& jacobian_do,
                                    const ArrayOfString& iy_aux_vars,
                                    const Agenda& iy_independent_beam_approx_agenda,
                                    // WS Generic Input:
                                    const Index& return_atm1d,
                                    const Index& skip_vmr,
                                    const Index& skip_pnd,
                                    const Index& return_masses,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void iyInterpCloudboxField(// WS Output:
                           Matrix& iy,
                           // WS Input:
                           const Tensor7& cloudbox_field,
                           const Vector& rtp_pos,
                           const Vector& rtp_los,
                           const Index& jacobian_do,
                           const Index& cloudbox_on,
                           const ArrayOfIndex& cloudbox_limits,
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const Tensor3& z_field,
                           const Matrix& z_surface,
                           const Index& stokes_dim,
                           const Vector& za_grid,
                           const Vector& aa_grid,
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Index& za_interp_order,
                           const Index& za_restrict,
                           const Index& cos_za_interp,
                           const Numeric& za_extpolfac,
                           const Index& aa_interp_order,
                           // Verbosity object:
                           const Verbosity& verbosity);


void iyLoopFrequencies(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Matrix& iy,
                       ArrayOfMatrix& iy_aux,
                       Ppath& ppath,
                       ArrayOfTensor3& diy_dx,
                       // WS Input:
                       const ArrayOfString& iy_aux_vars,
                       const Index& iy_agenda_call1,
                       const Tensor3& iy_transmission,
                       const Vector& rte_pos,
                       const Vector& rte_los,
                       const Vector& rte_pos2,
                       const Index& stokes_dim,
                       const Vector& f_grid,
                       const Agenda& iy_loop_freqs_agenda,
                       // Verbosity object:
                       const Verbosity& verbosity);


void iyMC(// Workspace reference:
          Workspace& ws,
          // WS Output:
          Matrix& iy,
          ArrayOfMatrix& iy_aux,
          ArrayOfTensor3& diy_dx,
          // WS Input:
          const Index& iy_agenda_call1,
          const Tensor3& iy_transmission,
          const Vector& rte_pos,
          const Vector& rte_los,
          const ArrayOfString& iy_aux_vars,
          const Index& jacobian_do,
          const Index& atmosphere_dim,
          const Vector& p_grid,
          const Vector& lat_grid,
          const Vector& lon_grid,
          const Tensor3& z_field,
          const Tensor3& t_field,
          const Tensor4& vmr_field,
          const Vector& refellipsoid,
          const Matrix& z_surface,
          const Index& cloudbox_on,
          const ArrayOfIndex& cloudbox_limits,
          const Index& stokes_dim,
          const Vector& f_grid,
          const ArrayOfArrayOfSingleScatteringData& scat_data,
          const Agenda& iy_space_agenda,
          const Agenda& surface_rtprop_agenda,
          const Agenda& propmat_clearsky_agenda,
          const Agenda& ppath_step_agenda,
          const Numeric& ppath_lmax,
          const Numeric& ppath_lraytrace,
          const Tensor4& pnd_field,
          const String& iy_unit,
          const Numeric& mc_std_err,
          const Index& mc_max_time,
          const Index& mc_max_iter,
          const Index& mc_min_iter,
          const Numeric& mc_taustep_limit,
          // WS Generic Input:
          const Index& t_interp_order,
          // Verbosity object:
          const Verbosity& verbosity);


void iyReplaceFromAux(// WS Output:
                      Matrix& iy,
                      // WS Input:
                      const ArrayOfMatrix& iy_aux,
                      const ArrayOfString& iy_aux_vars,
                      const Index& jacobian_do,
                      // WS Generic Input:
                      const String& aux_var,
                      // Verbosity object:
                      const Verbosity& verbosity);


void iySurfaceCallAgendaX(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Matrix& iy,
                          ArrayOfTensor3& diy_dx,
                          // WS Input:
                          const String& iy_unit,
                          const Tensor3& iy_transmission,
                          const Index& iy_id,
                          const Index& cloudbox_on,
                          const Index& jacobian_do,
                          const Vector& f_grid,
                          const Agenda& iy_main_agenda,
                          const Vector& rtp_pos,
                          const Vector& rtp_los,
                          const Vector& rte_pos2,
                          const ArrayOfAgenda& iy_surface_agenda_array,
                          const Index& surface_type,
                          const Numeric& surface_type_aux,
                          // Verbosity object:
                          const Verbosity& verbosity);


void iySurfaceFastem(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Matrix& iy,
                     ArrayOfTensor3& diy_dx,
                     // WS Input:
                     const Tensor3& iy_transmission,
                     const Index& iy_id,
                     const Index& jacobian_do,
                     const Index& atmosphere_dim,
                     const EnergyLevelMap& nlte_field,
                     const Index& cloudbox_on,
                     const Index& stokes_dim,
                     const Vector& f_grid,
                     const Vector& rtp_pos,
                     const Vector& rtp_los,
                     const Vector& rte_pos2,
                     const String& iy_unit,
                     const Agenda& iy_main_agenda,
                     const Numeric& surface_skin_t,
                     // WS Generic Input:
                     const Numeric& salinity,
                     const Numeric& wind_speed,
                     const Numeric& wind_direction,
                     const Index& fastem_version,
                     // Verbosity object:
                     const Verbosity& verbosity);


void iySurfaceRtpropAgenda(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           Matrix& iy,
                           ArrayOfTensor3& diy_dx,
                           // WS Input:
                           const Tensor3& iy_transmission,
                           const Index& iy_id,
                           const Index& jacobian_do,
                           const Index& atmosphere_dim,
                           const EnergyLevelMap& nlte_field,
                           const Index& cloudbox_on,
                           const Index& stokes_dim,
                           const Vector& f_grid,
                           const Vector& rtp_pos,
                           const Vector& rtp_los,
                           const Vector& rte_pos2,
                           const String& iy_unit,
                           const Agenda& iy_main_agenda,
                           const Agenda& surface_rtprop_agenda,
                           // Verbosity object:
                           const Verbosity& verbosity);


void iySurfaceRtpropCalc(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Matrix& iy,
                         ArrayOfTensor3& diy_dx,
                         // WS Input:
                         const Matrix& surface_los,
                         const Tensor4& surface_rmatrix,
                         const Matrix& surface_emission,
                         const ArrayOfString& dsurface_names,
                         const ArrayOfTensor4& dsurface_rmatrix_dx,
                         const ArrayOfMatrix& dsurface_emission_dx,
                         const Tensor3& iy_transmission,
                         const Index& iy_id,
                         const Index& jacobian_do,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const Index& atmosphere_dim,
                         const EnergyLevelMap& nlte_field,
                         const Index& cloudbox_on,
                         const Index& stokes_dim,
                         const Vector& f_grid,
                         const Vector& rtp_pos,
                         const Vector& rtp_los,
                         const Vector& rte_pos2,
                         const String& iy_unit,
                         const Agenda& iy_main_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);


void iyTransmissionStandard(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Matrix& iy,
                            ArrayOfMatrix& iy_aux,
                            ArrayOfTensor3& diy_dx,
                            Vector& ppvar_p,
                            Vector& ppvar_t,
                            EnergyLevelMap& ppvar_nlte,
                            Matrix& ppvar_vmr,
                            Matrix& ppvar_wind,
                            Matrix& ppvar_mag,
                            Matrix& ppvar_pnd,
                            Matrix& ppvar_f,
                            Tensor3& ppvar_iy,
                            Tensor4& ppvar_trans_cumulat,
                            // WS Input:
                            const Index& stokes_dim,
                            const Vector& f_grid,
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Tensor3& t_field,
                            const EnergyLevelMap& nlte_field,
                            const Tensor4& vmr_field,
                            const ArrayOfArrayOfSpeciesTag& abs_species,
                            const Tensor3& wind_u_field,
                            const Tensor3& wind_v_field,
                            const Tensor3& wind_w_field,
                            const Tensor3& mag_u_field,
                            const Tensor3& mag_v_field,
                            const Tensor3& mag_w_field,
                            const Index& cloudbox_on,
                            const ArrayOfIndex& cloudbox_limits,
                            const Tensor4& pnd_field,
                            const ArrayOfTensor4& dpnd_field_dx,
                            const ArrayOfString& scat_species,
                            const ArrayOfArrayOfSingleScatteringData& scat_data,
                            const ArrayOfString& iy_aux_vars,
                            const Index& jacobian_do,
                            const ArrayOfRetrievalQuantity& jacobian_quantities,
                            const Ppath& ppath,
                            const Agenda& propmat_clearsky_agenda,
                            const Agenda& water_p_eq_agenda,
                            const Agenda& iy_transmitter_agenda,
                            const Index& iy_agenda_call1,
                            const Tensor3& iy_transmission,
                            const Numeric& rte_alonglos_v,
                            // Verbosity object:
                            const Verbosity& verbosity);


void iy_transmitterMultiplePol(// WS Output:
                               Matrix& iy,
                               // WS Input:
                               const Index& stokes_dim,
                               const Vector& f_grid,
                               const ArrayOfIndex& instrument_pol,
                               // Verbosity object:
                               const Verbosity& verbosity);


void iy_transmitterSinglePol(// WS Output:
                             Matrix& iy,
                             // WS Input:
                             const Index& stokes_dim,
                             const Vector& f_grid,
                             const ArrayOfIndex& instrument_pol,
                             // Verbosity object:
                             const Verbosity& verbosity);


void jacobianAddAbsSpecies(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           ArrayOfRetrievalQuantity& jacobian_quantities,
                           Agenda& jacobian_agenda,
                           // WS Input:
                           const Index& atmosphere_dim,
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           // WS Generic Input:
                           const Vector& g1,
                           const Vector& g2,
                           const Vector& g3,
                           const String& species,
                           const String& unit,
                           const Index& for_species_tag,
                           // Verbosity object:
                           const Verbosity& verbosity);


void jacobianAddBasicCatalogParameter(// Workspace reference:
                                      Workspace& ws,
                                      // WS Output:
                                      ArrayOfRetrievalQuantity& jacobian_quantities,
                                      Agenda& jacobian_agenda,
                                      // WS Generic Input:
                                      const QuantumIdentifier& catalog_identity,
                                      const String& catalog_parameter,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void jacobianAddBasicCatalogParameters(// Workspace reference:
                                       Workspace& ws,
                                       // WS Output:
                                       ArrayOfRetrievalQuantity& jacobian_quantities,
                                       Agenda& jacobian_agenda,
                                       // WS Generic Input:
                                       const ArrayOfQuantumIdentifier& catalog_identities,
                                       const ArrayOfString& catalog_parameters,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void jacobianAddFreqShift(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          ArrayOfRetrievalQuantity& jacobian_quantities,
                          Agenda& jacobian_agenda,
                          // WS Input:
                          const Vector& f_grid,
                          // WS Generic Input:
                          const Numeric& df,
                          // Verbosity object:
                          const Verbosity& verbosity);


void jacobianAddFreqStretch(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Vector& f_grid,
                            // WS Generic Input:
                            const Numeric& df,
                            // Verbosity object:
                            const Verbosity& verbosity);


void jacobianAddShapeCatalogParameter(// Workspace reference:
                                      Workspace& ws,
                                      // WS Output:
                                      ArrayOfRetrievalQuantity& jacobian_quantities,
                                      Agenda& jacobian_agenda,
                                      // WS Generic Input:
                                      const QuantumIdentifier& line_identity,
                                      const String& species,
                                      const String& variable,
                                      const String& coefficient,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void jacobianAddShapeCatalogParameters(// Workspace reference:
                                       Workspace& ws,
                                       // WS Output:
                                       ArrayOfRetrievalQuantity& jacobian_quantities,
                                       Agenda& jacobian_agenda,
                                       // WS Generic Input:
                                       const ArrayOfQuantumIdentifier& line_identities,
                                       const ArrayOfString& species,
                                       const ArrayOfString& variables,
                                       const ArrayOfString& coefficients,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void jacobianAddMagField(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         ArrayOfRetrievalQuantity& jacobian_quantities,
                         Agenda& jacobian_agenda,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         // WS Generic Input:
                         const Vector& g1,
                         const Vector& g2,
                         const Vector& g3,
                         const String& component,
                         const Numeric& dB,
                         // Verbosity object:
                         const Verbosity& verbosity);


void jacobianAddNLTE(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfRetrievalQuantity& jacobian_quantities,
                     Agenda& jacobian_agenda,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Vector& g1,
                     const Vector& g2,
                     const Vector& g3,
                     const QuantumIdentifier& energy_level_identity,
                     const Numeric& dx,
                     // Verbosity object:
                     const Verbosity& verbosity);


void jacobianAddNLTEs(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      ArrayOfRetrievalQuantity& jacobian_quantities,
                      Agenda& jacobian_agenda,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      // WS Generic Input:
                      const Vector& g1,
                      const Vector& g2,
                      const Vector& g3,
                      const ArrayOfQuantumIdentifier& energy_level_identities,
                      const Numeric& dx,
                      // Verbosity object:
                      const Verbosity& verbosity);


void jacobianAddPointingZa(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           ArrayOfRetrievalQuantity& jacobian_quantities,
                           Agenda& jacobian_agenda,
                           // WS Input:
                           const Matrix& sensor_pos,
                           const Vector& sensor_time,
                           // WS Generic Input:
                           const Index& poly_order,
                           const String& calcmode,
                           const Numeric& dza,
                           // Verbosity object:
                           const Verbosity& verbosity);


void jacobianAddPolyfit(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        ArrayOfRetrievalQuantity& jacobian_quantities,
                        Agenda& jacobian_agenda,
                        // WS Input:
                        const ArrayOfIndex& sensor_response_pol_grid,
                        const Matrix& sensor_response_dlos_grid,
                        const Matrix& sensor_pos,
                        // WS Generic Input:
                        const Index& poly_order,
                        const Index& no_pol_variation,
                        const Index& no_los_variation,
                        const Index& no_mblock_variation,
                        // Verbosity object:
                        const Verbosity& verbosity);


void jacobianAddScatSpecies(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            // WS Generic Input:
                            const Vector& g1,
                            const Vector& g2,
                            const Vector& g3,
                            const String& species,
                            const String& quantity,
                            // Verbosity object:
                            const Verbosity& verbosity);


void jacobianAddSinefit(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        ArrayOfRetrievalQuantity& jacobian_quantities,
                        Agenda& jacobian_agenda,
                        // WS Input:
                        const ArrayOfIndex& sensor_response_pol_grid,
                        const Matrix& sensor_response_dlos_grid,
                        const Matrix& sensor_pos,
                        // WS Generic Input:
                        const Vector& period_lengths,
                        const Index& no_pol_variation,
                        const Index& no_los_variation,
                        const Index& no_mblock_variation,
                        // Verbosity object:
                        const Verbosity& verbosity);


void jacobianAddSpecialSpecies(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               ArrayOfRetrievalQuantity& jacobian_quantities,
                               Agenda& jacobian_agenda,
                               // WS Input:
                               const Index& atmosphere_dim,
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               // WS Generic Input:
                               const Vector& g1,
                               const Vector& g2,
                               const Vector& g3,
                               const String& species,
                               // Verbosity object:
                               const Verbosity& verbosity);


void jacobianAddSurfaceQuantity(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                ArrayOfRetrievalQuantity& jacobian_quantities,
                                Agenda& jacobian_agenda,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const Vector& lat_grid,
                                const Vector& lon_grid,
                                // WS Generic Input:
                                const Vector& g1,
                                const Vector& g2,
                                const String& quantity,
                                // Verbosity object:
                                const Verbosity& verbosity);


void jacobianAddTemperature(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            // WS Generic Input:
                            const Vector& g1,
                            const Vector& g2,
                            const Vector& g3,
                            const String& hse,
                            // Verbosity object:
                            const Verbosity& verbosity);


void jacobianAddWind(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfRetrievalQuantity& jacobian_quantities,
                     Agenda& jacobian_agenda,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     // WS Generic Input:
                     const Vector& g1,
                     const Vector& g2,
                     const Vector& g3,
                     const String& component,
                     const Numeric& dfrequency,
                     // Verbosity object:
                     const Verbosity& verbosity);


void jacobianAdjustAndTransform(// WS Output:
                                Matrix& jacobian,
                                // WS Input:
                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                const Vector& x,
                                // Verbosity object:
                                const Verbosity& verbosity);


void jacobianCalcDoNothing(// WS Output:
                           Matrix& jacobian,
                           // WS Input:
                           const Index& mblock_index,
                           const Vector& iyb,
                           const Vector& yb,
                           // Verbosity object:
                           const Verbosity& verbosity);


void jacobianCalcFreqShift(// WS Output:
                           Matrix& jacobian,
                           // WS Input:
                           const Index& mblock_index,
                           const Vector& iyb,
                           const Vector& yb,
                           const Index& stokes_dim,
                           const Vector& f_grid,
                           const Matrix& mblock_dlos_grid,
                           const Sparse& sensor_response,
                           const ArrayOfRetrievalQuantity& jacobian_quantities,
                           // Verbosity object:
                           const Verbosity& verbosity);


void jacobianCalcFreqStretch(// WS Output:
                             Matrix& jacobian,
                             // WS Input:
                             const Index& mblock_index,
                             const Vector& iyb,
                             const Vector& yb,
                             const Index& stokes_dim,
                             const Vector& f_grid,
                             const Matrix& mblock_dlos_grid,
                             const Sparse& sensor_response,
                             const ArrayOfIndex& sensor_response_pol_grid,
                             const Vector& sensor_response_f_grid,
                             const Matrix& sensor_response_dlos_grid,
                             const ArrayOfRetrievalQuantity& jacobian_quantities,
                             // Verbosity object:
                             const Verbosity& verbosity);


void jacobianCalcPointingZaInterp(// WS Output:
                                  Matrix& jacobian,
                                  // WS Input:
                                  const Index& mblock_index,
                                  const Vector& iyb,
                                  const Vector& yb,
                                  const Index& stokes_dim,
                                  const Vector& f_grid,
                                  const Matrix& sensor_los,
                                  const Matrix& mblock_dlos_grid,
                                  const Sparse& sensor_response,
                                  const Vector& sensor_time,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void jacobianCalcPointingZaRecalc(// Workspace reference:
                                  Workspace& ws,
                                  // WS Output:
                                  Matrix& jacobian,
                                  // WS Input:
                                  const Index& mblock_index,
                                  const Vector& iyb,
                                  const Vector& yb,
                                  const Index& atmosphere_dim,
                                  const EnergyLevelMap& nlte_field,
                                  const Index& cloudbox_on,
                                  const Index& stokes_dim,
                                  const Vector& f_grid,
                                  const Matrix& sensor_pos,
                                  const Matrix& sensor_los,
                                  const Matrix& transmitter_pos,
                                  const Matrix& mblock_dlos_grid,
                                  const Sparse& sensor_response,
                                  const Vector& sensor_time,
                                  const String& iy_unit,
                                  const Agenda& iy_main_agenda,
                                  const Agenda& geo_pos_agenda,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void jacobianCalcPolyfit(// WS Output:
                         Matrix& jacobian,
                         // WS Input:
                         const Index& mblock_index,
                         const Vector& iyb,
                         const Vector& yb,
                         const Sparse& sensor_response,
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Vector& sensor_response_f_grid,
                         const Matrix& sensor_response_dlos_grid,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         // WS Generic Input:
                         const Index& poly_coeff,
                         // Verbosity object:
                         const Verbosity& verbosity);


void jacobianCalcSinefit(// WS Output:
                         Matrix& jacobian,
                         // WS Input:
                         const Index& mblock_index,
                         const Vector& iyb,
                         const Vector& yb,
                         const Sparse& sensor_response,
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Vector& sensor_response_f_grid,
                         const Matrix& sensor_response_dlos_grid,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         // WS Generic Input:
                         const Index& period_index,
                         // Verbosity object:
                         const Verbosity& verbosity);


void jacobianClose(// Workspace reference:
                   Workspace& ws,
                   // WS Output:
                   Index& jacobian_do,
                   Agenda& jacobian_agenda,
                   // WS Input:
                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                   // Verbosity object:
                   const Verbosity& verbosity);


void jacobianFromTwoY(// WS Output:
                      Matrix& jacobian,
                      // WS Input:
                      const Vector& y,
                      // WS Generic Input:
                      const Vector& y_pert,
                      const Numeric& pert_size,
                      // Verbosity object:
                      const Verbosity& verbosity);


void jacobianFromYbatch(// WS Output:
                        Matrix& jacobian,
                        // WS Input:
                        const ArrayOfVector& ybatch,
                        const Vector& y,
                        // WS Generic Input:
                        const Numeric& pert_size,
                        // Verbosity object:
                        const Verbosity& verbosity);


void jacobianInit(// WS Output:
                  ArrayOfRetrievalQuantity& jacobian_quantities,
                  Agenda& jacobian_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);


void jacobianOff(// WS Output:
                 Index& jacobian_do,
                 Agenda& jacobian_agenda,
                 ArrayOfRetrievalQuantity& jacobian_quantities,
                 // Verbosity object:
                 const Verbosity& verbosity);


void jacobianSetAffineTransformation(// WS Output:
                                     ArrayOfRetrievalQuantity& jacobian_quantities,
                                     // WS Generic Input:
                                     const Matrix& transformation_matrix,
                                     const Vector& offset_vector,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void jacobianSetFuncTransformation(// WS Output:
                                   ArrayOfRetrievalQuantity& jacobian_quantities,
                                   // WS Generic Input:
                                   const String& transformation_func,
                                   const Numeric& z_min,
                                   const Numeric& z_max,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void lat_gridFromRawField(// WS Output:
                          Vector& lat_grid,
                          // WS Generic Input:
                          const GriddedField3& field_raw,
                          // Verbosity object:
                          const Verbosity& verbosity);


void lbl_checkedCalc(// WS Output:
                     Index& lbl_checked,
                     // WS Input:
                     const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                     const ArrayOfArrayOfSpeciesTag& abs_species,
                     const SpeciesAuxData& isotopologue_ratios,
                     const SpeciesAuxData& partition_functions,
                     // Verbosity object:
                     const Verbosity& verbosity);


void LocalTimeOffset(// WS Generic Output:
                     Numeric& dt,
                     // Verbosity object:
                     const Verbosity& verbosity);


void lon_gridFromRawField(// WS Output:
                          Vector& lon_grid,
                          // WS Generic Input:
                          const GriddedField3& field_raw,
                          // Verbosity object:
                          const Verbosity& verbosity);


void MagFieldsCalc(// WS Output:
                   Tensor3& mag_u_field,
                   Tensor3& mag_v_field,
                   Tensor3& mag_w_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const GriddedField3& mag_u_field_raw,
                   const GriddedField3& mag_v_field_raw,
                   const GriddedField3& mag_w_field_raw,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   // Verbosity object:
                   const Verbosity& verbosity);


void MagFieldsCalcExpand1D(// WS Output:
                           Tensor3& mag_u_field,
                           Tensor3& mag_v_field,
                           Tensor3& mag_w_field,
                           // WS Input:
                           const Vector& p_grid,
                           const Vector& lat_grid,
                           const Vector& lon_grid,
                           const GriddedField3& mag_u_field_raw,
                           const GriddedField3& mag_v_field_raw,
                           const GriddedField3& mag_w_field_raw,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           // Verbosity object:
                           const Verbosity& verbosity);


void MagFieldsFromAltitudeRawCalc(// WS Output:
                                  Tensor3& mag_u_field,
                                  Tensor3& mag_v_field,
                                  Tensor3& mag_w_field,
                                  // WS Input:
                                  const Vector& lat_grid,
                                  const Vector& lon_grid,
                                  const Tensor3& z_field,
                                  const GriddedField3& mag_u_field_raw,
                                  const GriddedField3& mag_v_field_raw,
                                  const GriddedField3& mag_w_field_raw,
                                  // WS Generic Input:
                                  const Index& interp_order,
                                  const Numeric& extrapolating,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void MagRawRead(// WS Output:
                GriddedField3& mag_u_field_raw,
                GriddedField3& mag_v_field_raw,
                GriddedField3& mag_w_field_raw,
                // WS Generic Input:
                const String& basename,
                // Verbosity object:
                const Verbosity& verbosity);


void MatrixAddScalar(// WS Generic Output:
                     Matrix& out,
                     // WS Generic Input:
                     const Matrix& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);


void MatrixCBR(// WS Generic Output:
               Matrix& out,
               // WS Input:
               const Index& stokes_dim,
               // WS Generic Input:
               const Vector& f,
               // Verbosity object:
               const Verbosity& verbosity);


void MatrixCopySparse(// WS Generic Output:
                      Matrix& out,
                      // WS Generic Input:
                      const Sparse& in,
                      // Verbosity object:
                      const Verbosity& verbosity);


void MatrixExtractFromTensor3(// WS Generic Output:
                              Matrix& out,
                              // WS Generic Input:
                              const Tensor3& in,
                              const Index& i,
                              const String& direction,
                              // Verbosity object:
                              const Verbosity& verbosity);


void MatrixFromCovarianceMatrix(// WS Generic Output:
                                Matrix& out,
                                // WS Generic Input:
                                const CovarianceMatrix& in,
                                // Verbosity object:
                                const Verbosity& verbosity);


void MatrixIdentity(// WS Generic Output:
                    Matrix& out,
                    // WS Generic Input:
                    const Index& n,
                    const Numeric& value,
                    // Verbosity object:
                    const Verbosity& verbosity);


void MatrixMatrixMultiply(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Matrix& m,
                          const Matrix& x,
                          // Verbosity object:
                          const Verbosity& verbosity);


void MatrixPlanck(// WS Generic Output:
                  Matrix& out,
                  // WS Input:
                  const Index& stokes_dim,
                  // WS Generic Input:
                  const Vector& f,
                  const Numeric& t,
                  // Verbosity object:
                  const Verbosity& verbosity);


void MatrixScale(// WS Generic Output:
                 Matrix& out,
                 // WS Generic Input:
                 const Matrix& in,
                 const Numeric& value,
                 // Verbosity object:
                 const Verbosity& verbosity);


void MatrixSet(// WS Generic Output:
               Matrix& out,
               // WS Generic Input:
               const Matrix& value,
               // Verbosity object:
               const Verbosity& verbosity);


void MatrixSetConstant(// WS Generic Output:
                       Matrix& out,
                       // WS Input:
                       const Index& nrows,
                       const Index& ncols,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);


void MatrixUnitIntensity(// WS Generic Output:
                         Matrix& out,
                         // WS Input:
                         const Index& stokes_dim,
                         // WS Generic Input:
                         const Vector& f,
                         // Verbosity object:
                         const Verbosity& verbosity);


void MatrixVectorMultiply(// WS Generic Output:
                          Vector& out,
                          // WS Generic Input:
                          const Matrix& m,
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);


void Matrix1ColFromVector(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);


void Matrix2ColFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);


void Matrix3ColFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           const Vector& v3,
                           // Verbosity object:
                           const Verbosity& verbosity);


void Matrix1RowFromVector(// WS Generic Output:
                          Matrix& out,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);


void Matrix2RowFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);


void Matrix3RowFromVectors(// WS Generic Output:
                           Matrix& out,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           const Vector& v3,
                           // Verbosity object:
                           const Verbosity& verbosity);


void mblock_dlos_gridUniformCircular(// WS Output:
                                     Matrix& mblock_dlos_grid,
                                     // WS Generic Input:
                                     const Numeric& spacing,
                                     const Numeric& width,
                                     const Index& centre,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void mblock_dlos_gridUniformRectangular(// WS Output:
                                        Matrix& mblock_dlos_grid,
                                        // WS Generic Input:
                                        const Numeric& spacing,
                                        const Numeric& za_width,
                                        const Numeric& aa_width,
                                        const Index& centre,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void mc_antennaSetGaussian(// WS Output:
                           MCAntenna& mc_antenna,
                           // WS Generic Input:
                           const Numeric& za_sigma,
                           const Numeric& aa_sigma,
                           // Verbosity object:
                           const Verbosity& verbosity);


void mc_antennaSetGaussianByFWHM(// WS Output:
                                 MCAntenna& mc_antenna,
                                 // WS Generic Input:
                                 const Numeric& za_fwhm,
                                 const Numeric& aa_fwhm,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void mc_antennaSetPencilBeam(// WS Output:
                             MCAntenna& mc_antenna,
                             // Verbosity object:
                             const Verbosity& verbosity);


void MCGeneral(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Vector& y,
               Index& mc_iteration_count,
               Vector& mc_error,
               Tensor3& mc_points,
               ArrayOfIndex& mc_source_domain,
               ArrayOfIndex& mc_scat_order,
               // WS Input:
               const MCAntenna& mc_antenna,
               const Vector& f_grid,
               const Index& f_index,
               const Matrix& sensor_pos,
               const Matrix& sensor_los,
               const Index& stokes_dim,
               const Index& atmosphere_dim,
               const Agenda& ppath_step_agenda,
               const Numeric& ppath_lmax,
               const Numeric& ppath_lraytrace,
               const Agenda& iy_space_agenda,
               const Agenda& surface_rtprop_agenda,
               const Agenda& propmat_clearsky_agenda,
               const Vector& p_grid,
               const Vector& lat_grid,
               const Vector& lon_grid,
               const Tensor3& z_field,
               const Vector& refellipsoid,
               const Matrix& z_surface,
               const Tensor3& t_field,
               const Tensor4& vmr_field,
               const Index& cloudbox_on,
               const ArrayOfIndex& cloudbox_limits,
               const Tensor4& pnd_field,
               const ArrayOfArrayOfSingleScatteringData& scat_data,
               const Index& atmfields_checked,
               const Index& atmgeom_checked,
               const Index& scat_data_checked,
               const Index& cloudbox_checked,
               const String& iy_unit,
               const Index& mc_seed,
               const Numeric& mc_std_err,
               const Index& mc_max_time,
               const Index& mc_max_iter,
               const Index& mc_min_iter,
               const Numeric& mc_taustep_limit,
               // WS Generic Input:
               const Index& l_mc_scat_order,
               const Index& t_interp_order,
               // Verbosity object:
               const Verbosity& verbosity);


void MCRadar(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Vector& y,
             Vector& mc_error,
             // WS Input:
             const MCAntenna& mc_antenna,
             const Vector& f_grid,
             const Index& f_index,
             const Matrix& sensor_pos,
             const Matrix& sensor_los,
             const Index& stokes_dim,
             const Index& atmosphere_dim,
             const Numeric& ppath_lmax,
             const Agenda& ppath_step_agenda,
             const Numeric& ppath_lraytrace,
             const Agenda& propmat_clearsky_agenda,
             const Vector& p_grid,
             const Vector& lat_grid,
             const Vector& lon_grid,
             const Tensor3& z_field,
             const Vector& refellipsoid,
             const Matrix& z_surface,
             const Tensor3& t_field,
             const Tensor4& vmr_field,
             const Index& cloudbox_on,
             const ArrayOfIndex& cloudbox_limits,
             const Tensor4& pnd_field,
             const ArrayOfArrayOfSingleScatteringData& scat_data,
             const Vector& mc_y_tx,
             const Vector& range_bins,
             const Index& atmfields_checked,
             const Index& atmgeom_checked,
             const Index& scat_data_checked,
             const Index& cloudbox_checked,
             const String& iy_unit,
             const Index& mc_max_scatorder,
             const Index& mc_seed,
             const Index& mc_max_iter,
             // WS Generic Input:
             const Numeric& ze_tref,
             const Numeric& k2,
             const Index& t_interp_order,
             // Verbosity object:
             const Verbosity& verbosity);


void MCSetSeedFromTime(// WS Output:
                       Index& mc_seed,
                       // Verbosity object:
                       const Verbosity& verbosity);


void nlte_fieldRescalePopulationLevels(// WS Output:
                                       EnergyLevelMap& nlte_field,
                                       // WS Generic Input:
                                       const Numeric& s,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void nlte_fieldForSingleSpeciesNonOverlappingLines(// Workspace reference:
                                                   Workspace& ws,
                                                   // WS Output:
                                                   EnergyLevelMap& nlte_field,
                                                   // WS Input:
                                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                                   const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                   const ArrayOfArrayOfGriddedField1& collision_coefficients,
                                                   const ArrayOfQuantumIdentifier& collision_line_identifiers,
                                                   const SpeciesAuxData& isotopologue_ratios,
                                                   const Agenda& iy_main_agenda,
                                                   const Agenda& ppath_agenda,
                                                   const Agenda& iy_space_agenda,
                                                   const Agenda& iy_surface_agenda,
                                                   const Agenda& iy_cloudbox_agenda,
                                                   const Agenda& propmat_clearsky_agenda,
                                                   const Agenda& water_p_eq_agenda,
                                                   const Tensor4& vmr_field,
                                                   const Tensor3& t_field,
                                                   const Tensor3& z_field,
                                                   const Vector& p_grid,
                                                   const Index& atmosphere_dim,
                                                   const Vector& refellipsoid,
                                                   const Tensor3& surface_props_data,
                                                   const Index& nlte_do,
                                                   // WS Generic Input:
                                                   const Numeric& df,
                                                   const Numeric& convergence_limit,
                                                   const Index& nz,
                                                   const Index& nf,
                                                   const Index& dampened,
                                                   const Index& iteration_limit,
                                                   // Verbosity object:
                                                   const Verbosity& verbosity);


void collision_coefficientsFromSplitFiles(// WS Output:
                                          ArrayOfArrayOfGriddedField1& collision_coefficients,
                                          ArrayOfQuantumIdentifier& collision_line_identifiers,
                                          // WS Input:
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // WS Generic Input:
                                          const String& basename,
                                          // Verbosity object:
                                          const Verbosity& verbosity);


void NumericAdd(// WS Generic Output:
                Numeric& out,
                // WS Generic Input:
                const Numeric& in,
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);


void NumericFromVector(// WS Generic Output:
                       Numeric& out,
                       // WS Generic Input:
                       const Vector& in,
                       const String& op,
                       // Verbosity object:
                       const Verbosity& verbosity);


void NumericInvScale(// WS Generic Output:
                     Numeric& out,
                     // WS Generic Input:
                     const Numeric& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);


void NumericScale(// WS Generic Output:
                  Numeric& out,
                  // WS Generic Input:
                  const Numeric& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void NumericSet(// WS Generic Output:
                Numeric& out,
                // WS Generic Input:
                const Numeric& value,
                // Verbosity object:
                const Verbosity& verbosity);


void QuantumIdentifierSet(// WS Generic Output:
                          QuantumIdentifier& out,
                          // WS Generic Input:
                          const String& string_initializer,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ArrayOfQuantumIdentifierSet(// WS Generic Output:
                                 ArrayOfQuantumIdentifier& out,
                                 // WS Generic Input:
                                 const ArrayOfString& string_initializers,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void nlte_sourceFromTemperatureAndSrcCoefPerSpecies(// WS Output:
                                                    ArrayOfStokesVector& nlte_source,
                                                    ArrayOfStokesVector& dnlte_dx_source,
                                                    ArrayOfStokesVector& nlte_dsource_dx,
                                                    // WS Input:
                                                    const ArrayOfMatrix& src_coef_per_species,
                                                    const ArrayOfMatrix& dsrc_coef_dx,
                                                    const ArrayOfRetrievalQuantity& jacobian_quantities,
                                                    const Vector& f_grid,
                                                    const Numeric& rtp_temperature,
                                                    // Verbosity object:
                                                    const Verbosity& verbosity);


void nlteOff(// WS Output:
             Index& nlte_do,
             EnergyLevelMap& nlte_field,
             ArrayOfQuantumIdentifier& nlte_level_identifiers,
             // Verbosity object:
             const Verbosity& verbosity);


void nlteSetByQuantumIdentifiers(// WS Output:
                                 Index& nlte_do,
                                 ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                 // WS Input:
                                 const EnergyLevelMap& nlte_field,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void nlte_fieldFromRaw(// WS Output:
                       EnergyLevelMap& nlte_field,
                       // WS Input:
                       const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                       const Vector& nlte_vibrational_energies,
                       // WS Generic Input:
                       const Tensor4& data,
                       // Verbosity object:
                       const Verbosity& verbosity);


void nlte_fieldSetLteExternalPartitionFunction(// WS Output:
                                               Index& nlte_do,
                                               EnergyLevelMap& nlte_field,
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Input:
                                               const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                                               const SpeciesAuxData& partition_functions,
                                               const Tensor3& t_field,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void ArrayOfQuantumIdentifierFromLines(// WS Generic Output:
                                       ArrayOfQuantumIdentifier& out,
                                       // WS Input:
                                       const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                       // WS Generic Input:
                                       const Index& global,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void nlte_fieldSetLteInternalPartitionFunction(// WS Output:
                                               Index& nlte_do,
                                               EnergyLevelMap& nlte_field,
                                               ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Input:
                                               const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                                               const Tensor3& t_field,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void timeNow(// WS Output:
             Time& time,
             // Verbosity object:
             const Verbosity& verbosity);


void timeOffset(// WS Output:
                Time& time,
                // WS Generic Input:
                const Numeric& offset,
                // Verbosity object:
                const Verbosity& verbosity);


void OEM(// Workspace reference:
         Workspace& ws,
         // WS Output:
         Vector& x,
         Vector& yf,
         Matrix& jacobian,
         Matrix& dxdy,
         Vector& oem_diagnostics,
         Vector& lm_ga_history,
         ArrayOfString& oem_errors,
         // WS Input:
         const Vector& xa,
         const CovarianceMatrix& covmat_sx,
         const Vector& y,
         const CovarianceMatrix& covmat_se,
         const ArrayOfRetrievalQuantity& jacobian_quantities,
         const Agenda& inversion_iterate_agenda,
         // WS Generic Input:
         const String& method,
         const Numeric& max_start_cost,
         const Vector& x_norm,
         const Index& max_iter,
         const Numeric& stop_dx,
         const Vector& lm_ga_settings,
         const Index& clear_matrices,
         const Index& display_progress,
         // Verbosity object:
         const Verbosity& verbosity);


void avkCalc(// WS Output:
             Matrix& avk,
             // WS Input:
             const Matrix& dxdy,
             const Matrix& jacobian,
             // Verbosity object:
             const Verbosity& verbosity);


void covmat_soCalc(// WS Output:
                   Matrix& covmat_so,
                   // WS Input:
                   const Matrix& dxdy,
                   const CovarianceMatrix& covmat_se,
                   // Verbosity object:
                   const Verbosity& verbosity);


void covmat_ssCalc(// WS Output:
                   Matrix& covmat_ss,
                   // WS Input:
                   const Matrix& avk,
                   const CovarianceMatrix& covmat_sx,
                   // Verbosity object:
                   const Verbosity& verbosity);


void opt_prop_bulkCalc(// WS Output:
                       PropagationMatrix& ext_mat,
                       StokesVector& abs_vec,
                       // WS Input:
                       const ArrayOfPropagationMatrix& ext_mat_spt,
                       const ArrayOfStokesVector& abs_vec_spt,
                       const Tensor4& pnd_field,
                       const Index& scat_p_index,
                       const Index& scat_lat_index,
                       const Index& scat_lon_index,
                       // Verbosity object:
                       const Verbosity& verbosity);


void opt_prop_sptFromData(// WS Output:
                          ArrayOfPropagationMatrix& ext_mat_spt,
                          ArrayOfStokesVector& abs_vec_spt,
                          // WS Input:
                          const ArrayOfArrayOfSingleScatteringData& scat_data,
                          const Vector& za_grid,
                          const Vector& aa_grid,
                          const Index& za_index,
                          const Index& aa_index,
                          const Index& f_index,
                          const Vector& f_grid,
                          const Numeric& rtp_temperature,
                          const Tensor4& pnd_field,
                          const Index& scat_p_index,
                          const Index& scat_lat_index,
                          const Index& scat_lon_index,
                          // Verbosity object:
                          const Verbosity& verbosity);


void opt_prop_sptFromScat_data(// WS Output:
                               ArrayOfPropagationMatrix& ext_mat_spt,
                               ArrayOfStokesVector& abs_vec_spt,
                               // WS Input:
                               const ArrayOfArrayOfSingleScatteringData& scat_data,
                               const Index& scat_data_checked,
                               const Vector& za_grid,
                               const Vector& aa_grid,
                               const Index& za_index,
                               const Index& aa_index,
                               const Index& f_index,
                               const Numeric& rtp_temperature,
                               const Tensor4& pnd_field,
                               const Index& scat_p_index,
                               const Index& scat_lat_index,
                               const Index& scat_lon_index,
                               // Verbosity object:
                               const Verbosity& verbosity);


void opt_prop_sptFromMonoData(// WS Output:
                              ArrayOfPropagationMatrix& ext_mat_spt,
                              ArrayOfStokesVector& abs_vec_spt,
                              // WS Input:
                              const ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                              const Vector& za_grid,
                              const Vector& aa_grid,
                              const Index& za_index,
                              const Index& aa_index,
                              const Numeric& rtp_temperature,
                              const Tensor4& pnd_field,
                              const Index& scat_p_index,
                              const Index& scat_lat_index,
                              const Index& scat_lon_index,
                              // Verbosity object:
                              const Verbosity& verbosity);


void output_file_formatSetAscii(// WS Output:
                                String& output_file_format,
                                // Verbosity object:
                                const Verbosity& verbosity);


void output_file_formatSetBinary(// WS Output:
                                 String& output_file_format,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void output_file_formatSetZippedAscii(// WS Output:
                                      String& output_file_format,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void particle_bulkprop_fieldClip(// WS Output:
                                 Tensor4& particle_bulkprop_field,
                                 // WS Input:
                                 const ArrayOfString& particle_bulkprop_names,
                                 // WS Generic Input:
                                 const String& bulkprop_name,
                                 const Numeric& limit_low,
                                 const Numeric& limit_high,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void particle_bulkprop_fieldPerturb(// WS Output:
                                    Tensor4& particle_bulkprop_field,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    const ArrayOfString& particle_bulkprop_names,
                                    // WS Generic Input:
                                    const String& particle_type,
                                    const Vector& p_ret_grid,
                                    const Vector& lat_ret_grid,
                                    const Vector& lon_ret_grid,
                                    const Index& pert_index,
                                    const Numeric& pert_size,
                                    const String& pert_mode,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void particle_bulkprop_fieldPerturbAtmGrids(// WS Output:
                                            Tensor4& particle_bulkprop_field,
                                            // WS Input:
                                            const Index& atmosphere_dim,
                                            const Vector& p_grid,
                                            const Vector& lat_grid,
                                            const Vector& lon_grid,
                                            const ArrayOfString& particle_bulkprop_names,
                                            // WS Generic Input:
                                            const String& particle_type,
                                            const Index& pert_index,
                                            const Numeric& pert_size,
                                            const String& pert_mode,
                                            // Verbosity object:
                                            const Verbosity& verbosity);


void particle_massesFromMetaDataSingleCategory(// WS Output:
                                               Matrix& particle_masses,
                                               // WS Input:
                                               const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void particle_massesFromMetaData(// WS Output:
                                 Matrix& particle_masses,
                                 // WS Input:
                                 const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void partition_functionsInitFromBuiltin(// WS Output:
                                        SpeciesAuxData& partition_functions,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void pha_matCalc(// WS Output:
                 Tensor4& pha_mat,
                 // WS Input:
                 const Tensor5& pha_mat_spt,
                 const Tensor4& pnd_field,
                 const Index& atmosphere_dim,
                 const Index& scat_p_index,
                 const Index& scat_lat_index,
                 const Index& scat_lon_index,
                 // Verbosity object:
                 const Verbosity& verbosity);


void pha_mat_sptFromData(// WS Output:
                         Tensor5& pha_mat_spt,
                         // WS Input:
                         const ArrayOfArrayOfSingleScatteringData& scat_data,
                         const Vector& za_grid,
                         const Vector& aa_grid,
                         const Index& za_index,
                         const Index& aa_index,
                         const Index& f_index,
                         const Vector& f_grid,
                         const Numeric& rtp_temperature,
                         const Tensor4& pnd_field,
                         const Index& scat_p_index,
                         const Index& scat_lat_index,
                         const Index& scat_lon_index,
                         // Verbosity object:
                         const Verbosity& verbosity);


void pha_mat_sptFromDataDOITOpt(// WS Output:
                                Tensor5& pha_mat_spt,
                                // WS Input:
                                const ArrayOfTensor7& pha_mat_sptDOITOpt,
                                const ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                                const Index& doit_za_grid_size,
                                const Vector& aa_grid,
                                const Index& za_index,
                                const Index& aa_index,
                                const Numeric& rtp_temperature,
                                const Tensor4& pnd_field,
                                const Index& scat_p_index,
                                const Index& scat_lat_index,
                                const Index& scat_lon_index,
                                // Verbosity object:
                                const Verbosity& verbosity);


void pha_mat_sptFromMonoData(// WS Output:
                             Tensor5& pha_mat_spt,
                             // WS Input:
                             const ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                             const Index& doit_za_grid_size,
                             const Vector& aa_grid,
                             const Index& za_index,
                             const Index& aa_index,
                             const Numeric& rtp_temperature,
                             const Tensor4& pnd_field,
                             const Index& scat_p_index,
                             const Index& scat_lat_index,
                             const Index& scat_lon_index,
                             // Verbosity object:
                             const Verbosity& verbosity);


void pha_mat_sptFromScat_data(// WS Output:
                              Tensor5& pha_mat_spt,
                              // WS Input:
                              const ArrayOfArrayOfSingleScatteringData& scat_data,
                              const Index& scat_data_checked,
                              const Vector& za_grid,
                              const Vector& aa_grid,
                              const Index& za_index,
                              const Index& aa_index,
                              const Index& f_index,
                              const Numeric& rtp_temperature,
                              const Tensor4& pnd_field,
                              const Index& scat_p_index,
                              const Index& scat_lat_index,
                              const Index& scat_lon_index,
                              // Verbosity object:
                              const Verbosity& verbosity);


void pndFromPsd(// WS Output:
                Matrix& pnd_data,
                Tensor3& dpnd_data_dx,
                // WS Input:
                const Vector& pnd_size_grid,
                const Matrix& psd_data,
                const Vector& psd_size_grid,
                const Tensor3& dpsd_data_dx,
                const ArrayOfArrayOfSingleScatteringData& scat_data,
                const Vector& f_grid,
                const Index& scat_data_checked,
                // WS Generic Input:
                const Index& quad_order,
                const Index& scat_index,
                const Numeric& threshold_se_ext,
                const Numeric& threshold_ss_ext,
                const Numeric& threshold_se_pnd,
                // Verbosity object:
                const Verbosity& verbosity);


void pndFromPsdBasic(// WS Output:
                     Matrix& pnd_data,
                     Tensor3& dpnd_data_dx,
                     // WS Input:
                     const Vector& pnd_size_grid,
                     const Matrix& psd_data,
                     const Vector& psd_size_grid,
                     const Tensor3& dpsd_data_dx,
                     // WS Generic Input:
                     const Index& quad_order,
                     // Verbosity object:
                     const Verbosity& verbosity);


void pnd_fieldCalcFromParticleBulkProps(// Workspace reference:
                                        Workspace& ws,
                                        // WS Output:
                                        Tensor4& pnd_field,
                                        ArrayOfTensor4& dpnd_field_dx,
                                        // WS Input:
                                        const Index& atmosphere_dim,
                                        const Vector& p_grid,
                                        const Vector& lat_grid,
                                        const Vector& lon_grid,
                                        const Tensor3& t_field,
                                        const Index& cloudbox_on,
                                        const ArrayOfIndex& cloudbox_limits,
                                        const ArrayOfString& scat_species,
                                        const ArrayOfArrayOfSingleScatteringData& scat_data,
                                        const ArrayOfArrayOfScatteringMetaData& scat_meta,
                                        const Tensor4& particle_bulkprop_field,
                                        const ArrayOfString& particle_bulkprop_names,
                                        const ArrayOfAgenda& pnd_agenda_array,
                                        const ArrayOfArrayOfString& pnd_agenda_array_input_names,
                                        const Index& jacobian_do,
                                        const ArrayOfRetrievalQuantity& jacobian_quantities,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void pnd_fieldCalcFrompnd_field_raw(// WS Output:
                                    Tensor4& pnd_field,
                                    ArrayOfTensor4& dpnd_field_dx,
                                    // WS Input:
                                    const Vector& p_grid,
                                    const Vector& lat_grid,
                                    const Vector& lon_grid,
                                    const ArrayOfGriddedField3& pnd_field_raw,
                                    const Index& atmosphere_dim,
                                    const ArrayOfIndex& cloudbox_limits,
                                    const ArrayOfRetrievalQuantity& jacobian_quantities,
                                    // WS Generic Input:
                                    const Index& zeropadding,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void pnd_fieldExpand1D(// WS Output:
                       Tensor4& pnd_field,
                       // WS Input:
                       const Index& atmosphere_dim,
                       const Index& cloudbox_on,
                       const ArrayOfIndex& cloudbox_limits,
                       // WS Generic Input:
                       const Index& nzero,
                       // Verbosity object:
                       const Verbosity& verbosity);


void pnd_fieldZero(// WS Output:
                   Tensor4& pnd_field,
                   ArrayOfTensor4& dpnd_field_dx,
                   ArrayOfArrayOfSingleScatteringData& scat_data,
                   // WS Input:
                   const Index& atmosphere_dim,
                   const Vector& f_grid,
                   const ArrayOfIndex& cloudbox_limits,
                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                   // Verbosity object:
                   const Verbosity& verbosity);


void ppath_fieldFromDownUpLimbGeoms(// Workspace reference:
                                    Workspace& ws,
                                    // WS Output:
                                    ArrayOfPpath& ppath_field,
                                    // WS Input:
                                    const Agenda& ppath_agenda,
                                    const Numeric& ppath_lmax,
                                    const Numeric& ppath_lraytrace,
                                    const Index& atmgeom_checked,
                                    const Tensor3& z_field,
                                    const Vector& f_grid,
                                    const Index& cloudbox_on,
                                    const Index& cloudbox_checked,
                                    const Index& ppath_inside_cloudbox_do,
                                    const Vector& rte_pos,
                                    const Vector& rte_los,
                                    const Vector& rte_pos2,
                                    const Vector& refellipsoid,
                                    const Index& atmosphere_dim,
                                    // WS Generic Input:
                                    const Index& nz,
                                    // Verbosity object:
                                    const Verbosity& verbosity);


void ppathCalc(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Ppath& ppath,
               // WS Input:
               const Agenda& ppath_agenda,
               const Numeric& ppath_lmax,
               const Numeric& ppath_lraytrace,
               const Index& atmgeom_checked,
               const Vector& f_grid,
               const Index& cloudbox_on,
               const Index& cloudbox_checked,
               const Index& ppath_inside_cloudbox_do,
               const Vector& rte_pos,
               const Vector& rte_los,
               const Vector& rte_pos2,
               // Verbosity object:
               const Verbosity& verbosity);


void ppath_fieldCalc(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfPpath& ppath_field,
                     // WS Input:
                     const Agenda& ppath_agenda,
                     const Numeric& ppath_lmax,
                     const Numeric& ppath_lraytrace,
                     const Index& atmgeom_checked,
                     const Vector& f_grid,
                     const Index& cloudbox_on,
                     const Index& cloudbox_checked,
                     const Index& ppath_inside_cloudbox_do,
                     const Matrix& sensor_pos,
                     const Matrix& sensor_los,
                     const Vector& rte_pos2,
                     // Verbosity object:
                     const Verbosity& verbosity);


void ppathCalcFromAltitude(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           Ppath& ppath,
                           // WS Input:
                           const Agenda& ppath_agenda,
                           const Numeric& ppath_lmax,
                           const Numeric& ppath_lraytrace,
                           const Index& atmgeom_checked,
                           const Vector& f_grid,
                           const Index& cloudbox_on,
                           const Index& cloudbox_checked,
                           const Index& ppath_inside_cloudbox_do,
                           const Vector& rte_pos,
                           const Vector& rte_los,
                           const Vector& rte_pos2,
                           // WS Generic Input:
                           const Numeric& altitude,
                           const Numeric& accuracy,
                           // Verbosity object:
                           const Verbosity& verbosity);


void ppathFromRtePos2(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      Ppath& ppath,
                      Vector& rte_los,
                      Numeric& ppath_lraytrace,
                      // WS Input:
                      const Agenda& ppath_step_agenda,
                      const Index& atmosphere_dim,
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const Tensor3& z_field,
                      const Vector& f_grid,
                      const Vector& refellipsoid,
                      const Matrix& z_surface,
                      const Vector& rte_pos,
                      const Vector& rte_pos2,
                      const Numeric& ppath_lmax,
                      // WS Generic Input:
                      const Numeric& za_accuracy,
                      const Numeric& pplrt_factor,
                      const Numeric& pplrt_lowest,
                      // Verbosity object:
                      const Verbosity& verbosity);


void ppathPlaneParallel(// WS Output:
                        Ppath& ppath,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Tensor3& z_field,
                        const Matrix& z_surface,
                        const Index& cloudbox_on,
                        const ArrayOfIndex& cloudbox_limits,
                        const Index& ppath_inside_cloudbox_do,
                        const Vector& rte_pos,
                        const Vector& rte_los,
                        const Numeric& ppath_lmax,
                        // Verbosity object:
                        const Verbosity& verbosity);


void ppathStepByStep(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     Ppath& ppath,
                     // WS Input:
                     const Agenda& ppath_step_agenda,
                     const Index& ppath_inside_cloudbox_do,
                     const Index& atmosphere_dim,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     const Tensor3& z_field,
                     const Vector& f_grid,
                     const Vector& refellipsoid,
                     const Matrix& z_surface,
                     const Index& cloudbox_on,
                     const ArrayOfIndex& cloudbox_limits,
                     const Vector& rte_pos,
                     const Vector& rte_los,
                     const Numeric& ppath_lmax,
                     const Numeric& ppath_lraytrace,
                     // Verbosity object:
                     const Verbosity& verbosity);


void ppathWriteXMLPartial(// WS Input:
                          const String& output_file_format,
                          const Ppath& ppath,
                          // WS Generic Input:
                          const String& filename,
                          const Index& file_index,
                          // Verbosity object:
                          const Verbosity& verbosity);


void ppath_stepGeometric(// WS Output:
                         Ppath& ppath_step,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Tensor3& z_field,
                         const Vector& refellipsoid,
                         const Matrix& z_surface,
                         const Numeric& ppath_lmax,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ppath_stepRefractionBasic(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Ppath& ppath_step,
                               // WS Input:
                               const Agenda& refr_index_air_agenda,
                               const Index& atmosphere_dim,
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const Tensor3& z_field,
                               const Tensor3& t_field,
                               const Tensor4& vmr_field,
                               const Vector& refellipsoid,
                               const Matrix& z_surface,
                               const Vector& f_grid,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               // Verbosity object:
                               const Verbosity& verbosity);


void ppvar_optical_depthFromPpvar_trans_cumulat(// WS Output:
                                                Matrix& ppvar_optical_depth,
                                                // WS Input:
                                                const Tensor4& ppvar_trans_cumulat,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void PrintPhysicalConstants(// Verbosity object:
                            const Verbosity& verbosity);


void ZFromPSimple(// WS Generic Output:
                  Vector& z_grid,
                  // WS Generic Input:
                  const Vector& p_grid,
                  // Verbosity object:
                  const Verbosity& verbosity);


void PFromZSimple(// WS Generic Output:
                  Vector& p_grid,
                  // WS Generic Input:
                  const Vector& z_grid,
                  // Verbosity object:
                  const Verbosity& verbosity);


void propmat_clearskyAddFaraday(// WS Output:
                                ArrayOfPropagationMatrix& propmat_clearsky,
                                ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                // WS Input:
                                const Index& stokes_dim,
                                const Index& atmosphere_dim,
                                const Vector& f_grid,
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                const Vector& rtp_vmr,
                                const Vector& rtp_los,
                                const Vector& rtp_mag,
                                // Verbosity object:
                                const Verbosity& verbosity);


void propmat_clearskyAddFromAbsCoefPerSpecies(// WS Output:
                                              ArrayOfPropagationMatrix& propmat_clearsky,
                                              ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                              // WS Input:
                                              const ArrayOfMatrix& abs_coef_per_species,
                                              const ArrayOfMatrix& dabs_coef_dx,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void propmat_clearskyAddFromLookup(// WS Output:
                                   ArrayOfPropagationMatrix& propmat_clearsky,
                                   ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                   // WS Input:
                                   const GasAbsLookup& abs_lookup,
                                   const Index& abs_lookup_is_adapted,
                                   const Index& abs_p_interp_order,
                                   const Index& abs_t_interp_order,
                                   const Index& abs_nls_interp_order,
                                   const Index& abs_f_interp_order,
                                   const Vector& f_grid,
                                   const Numeric& rtp_pressure,
                                   const Numeric& rtp_temperature,
                                   const Vector& rtp_vmr,
                                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                                   // WS Generic Input:
                                   const Numeric& extpolfac,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void propmat_clearskyAddHitranLineMixingLines(// WS Output:
                                              ArrayOfPropagationMatrix& propmat_clearsky,
                                              // WS Input:
                                              const HitranRelaxationMatrixData& abs_hitran_relmat_data,
                                              const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                              const Vector& f_grid,
                                              const ArrayOfArrayOfSpeciesTag& abs_species,
                                              const ArrayOfRetrievalQuantity& jacobian_quantities,
                                              const SpeciesAuxData& partition_functions,
                                              const Numeric& rtp_pressure,
                                              const Numeric& rtp_temperature,
                                              const Vector& rtp_vmr,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void propmat_clearskyAddOnTheFly(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 ArrayOfPropagationMatrix& propmat_clearsky,
                                 ArrayOfStokesVector& nlte_source,
                                 ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                 ArrayOfStokesVector& dnlte_dx_source,
                                 ArrayOfStokesVector& nlte_dsource_dx,
                                 // WS Input:
                                 const Vector& f_grid,
                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                 const ArrayOfRetrievalQuantity& jacobian_quantities,
                                 const Numeric& rtp_pressure,
                                 const Numeric& rtp_temperature,
                                 const EnergyLevelMap& rtp_nlte,
                                 const Vector& rtp_vmr,
                                 const Agenda& abs_xsec_agenda,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void propmat_clearskyAddParticles(// WS Output:
                                  ArrayOfPropagationMatrix& propmat_clearsky,
                                  ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                                  // WS Input:
                                  const Index& stokes_dim,
                                  const Index& atmosphere_dim,
                                  const Vector& f_grid,
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const Vector& rtp_vmr,
                                  const Vector& rtp_los,
                                  const Numeric& rtp_temperature,
                                  const ArrayOfArrayOfSingleScatteringData& scat_data,
                                  const Index& scat_data_checked,
                                  // WS Generic Input:
                                  const Index& use_abs_as_ext,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void propmat_clearskyAddZeeman(// WS Output:
                               ArrayOfPropagationMatrix& propmat_clearsky,
                               ArrayOfStokesVector& nlte_source,
                               ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                               ArrayOfStokesVector& dnlte_dx_source,
                               ArrayOfStokesVector& nlte_dsource_dx,
                               // WS Input:
                               const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                               const Vector& f_grid,
                               const ArrayOfArrayOfSpeciesTag& abs_species,
                               const ArrayOfRetrievalQuantity& jacobian_quantities,
                               const SpeciesAuxData& isotopologue_ratios,
                               const SpeciesAuxData& partition_functions,
                               const Numeric& rtp_pressure,
                               const Numeric& rtp_temperature,
                               const EnergyLevelMap& rtp_nlte,
                               const Vector& rtp_vmr,
                               const Vector& rtp_mag,
                               const Vector& rtp_los,
                               const Index& atmosphere_dim,
                               const Index& lbl_checked,
                               // WS Generic Input:
                               const Index& manual_zeeman_tag,
                               const Numeric& manual_zeeman_magnetic_field_strength,
                               const Numeric& manual_zeeman_theta,
                               const Numeric& manual_zeeman_eta,
                               // Verbosity object:
                               const Verbosity& verbosity);


void propmat_clearskyInit(// WS Output:
                          ArrayOfPropagationMatrix& propmat_clearsky,
                          ArrayOfStokesVector& nlte_source,
                          ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
                          ArrayOfStokesVector& dnlte_dx_source,
                          ArrayOfStokesVector& nlte_dsource_dx,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Index& propmat_clearsky_agenda_checked,
                          const Index& nlte_do,
                          // Verbosity object:
                          const Verbosity& verbosity);


void propmat_clearskyZero(// WS Output:
                          ArrayOfPropagationMatrix& propmat_clearsky,
                          // WS Input:
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          // Verbosity object:
                          const Verbosity& verbosity);


void propmat_clearskyForceNegativeToZero(// WS Output:
                                         ArrayOfPropagationMatrix& propmat_clearsky,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void propmat_clearsky_agenda_checkedCalc(// Workspace reference:
                                         Workspace& ws,
                                         // WS Output:
                                         Index& propmat_clearsky_agenda_checked,
                                         // WS Input:
                                         const ArrayOfArrayOfSpeciesTag& abs_species,
                                         const Agenda& propmat_clearsky_agenda,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void propmat_clearsky_fieldCalc(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                Tensor7& propmat_clearsky_field,
                                Tensor6& nlte_source_field,
                                // WS Input:
                                const Index& atmfields_checked,
                                const Vector& f_grid,
                                const Index& stokes_dim,
                                const Vector& p_grid,
                                const Vector& lat_grid,
                                const Vector& lon_grid,
                                const Tensor3& t_field,
                                const Tensor4& vmr_field,
                                const EnergyLevelMap& nlte_field,
                                const Tensor3& mag_u_field,
                                const Tensor3& mag_v_field,
                                const Tensor3& mag_w_field,
                                const Agenda& propmat_clearsky_agenda,
                                // WS Generic Input:
                                const Vector& doppler,
                                const Vector& los,
                                // Verbosity object:
                                const Verbosity& verbosity);


void psdAbelBoutle12(// WS Output:
                     Matrix& psd_data,
                     Tensor3& dpsd_data_dx,
                     // WS Input:
                     const Vector& psd_size_grid,
                     const Vector& pnd_agenda_input_t,
                     const Matrix& pnd_agenda_input,
                     const ArrayOfString& pnd_agenda_input_names,
                     const ArrayOfString& dpnd_data_dx_names,
                     const Numeric& scat_species_a,
                     const Numeric& scat_species_b,
                     // WS Generic Input:
                     const Numeric& t_min,
                     const Numeric& t_max,
                     const Index& picky,
                     // Verbosity object:
                     const Verbosity& verbosity);


void psdDelanoeEtAl14(// WS Output:
                      Matrix& psd_data,
                      Tensor3& dpsd_data_dx,
                      // WS Input:
                      const Vector& psd_size_grid,
                      const Vector& pnd_agenda_input_t,
                      const Matrix& pnd_agenda_input,
                      const ArrayOfString& pnd_agenda_input_names,
                      const ArrayOfString& dpnd_data_dx_names,
                      // WS Generic Input:
                      const Numeric& iwc,
                      const Numeric& n0Star,
                      const Numeric& Dm,
                      const Numeric& rho,
                      const Numeric& alpha,
                      const Numeric& beta,
                      const Numeric& t_min,
                      const Numeric& t_max,
                      const Numeric& dm_min,
                      const Index& picky,
                      // Verbosity object:
                      const Verbosity& verbosity);


void psdFieldEtAl07(// WS Output:
                    Matrix& psd_data,
                    Tensor3& dpsd_data_dx,
                    // WS Input:
                    const Vector& psd_size_grid,
                    const Vector& pnd_agenda_input_t,
                    const Matrix& pnd_agenda_input,
                    const ArrayOfString& pnd_agenda_input_names,
                    const ArrayOfString& dpnd_data_dx_names,
                    const Numeric& scat_species_a,
                    const Numeric& scat_species_b,
                    // WS Generic Input:
                    const String& regime,
                    const Numeric& t_min,
                    const Numeric& t_max,
                    const Numeric& t_min_psd,
                    const Numeric& t_max_psd,
                    const Numeric& beta_min,
                    const Numeric& beta_max,
                    const Index& picky,
                    // Verbosity object:
                    const Verbosity& verbosity);


void psdFieldEtAl19(// WS Output:
                    Matrix& psd_data,
                    Tensor3& dpsd_data_dx,
                    // WS Input:
                    const Vector& psd_size_grid,
                    const Vector& pnd_agenda_input_t,
                    const Matrix& pnd_agenda_input,
                    const ArrayOfString& pnd_agenda_input_names,
                    const ArrayOfString& dpnd_data_dx_names,
                    const Numeric& scat_species_a,
                    const Numeric& scat_species_b,
                    // WS Generic Input:
                    const Numeric& t_min,
                    const Numeric& t_max,
                    const Index& picky,
                    // Verbosity object:
                    const Verbosity& verbosity);


void psdMcFarquaharHeymsfield97(// WS Output:
                                Matrix& psd_data,
                                Tensor3& dpsd_data_dx,
                                // WS Input:
                                const Vector& psd_size_grid,
                                const Vector& pnd_agenda_input_t,
                                const Matrix& pnd_agenda_input,
                                const ArrayOfString& pnd_agenda_input_names,
                                const ArrayOfString& dpnd_data_dx_names,
                                const Numeric& scat_species_a,
                                const Numeric& scat_species_b,
                                // WS Generic Input:
                                const Numeric& t_min,
                                const Numeric& t_max,
                                const Numeric& t_min_psd,
                                const Numeric& t_max_psd,
                                const Index& picky,
                                const Index& noisy,
                                // Verbosity object:
                                const Verbosity& verbosity);


void psdMilbrandtYau05(// WS Output:
                       Matrix& psd_data,
                       Tensor3& dpsd_data_dx,
                       // WS Input:
                       const Vector& psd_size_grid,
                       const Vector& pnd_agenda_input_t,
                       const Matrix& pnd_agenda_input,
                       const ArrayOfString& pnd_agenda_input_names,
                       const ArrayOfString& dpnd_data_dx_names,
                       // WS Generic Input:
                       const String& hydrometeor_type,
                       const Numeric& t_min,
                       const Numeric& t_max,
                       const Index& picky,
                       // Verbosity object:
                       const Verbosity& verbosity);


void psdModifiedGamma(// WS Output:
                      Matrix& psd_data,
                      Tensor3& dpsd_data_dx,
                      // WS Input:
                      const Vector& psd_size_grid,
                      const Vector& pnd_agenda_input_t,
                      const Matrix& pnd_agenda_input,
                      const ArrayOfString& pnd_agenda_input_names,
                      const ArrayOfString& dpnd_data_dx_names,
                      // WS Generic Input:
                      const Numeric& n0,
                      const Numeric& mu,
                      const Numeric& la,
                      const Numeric& ga,
                      const Numeric& t_min,
                      const Numeric& t_max,
                      const Index& picky,
                      // Verbosity object:
                      const Verbosity& verbosity);


void psdModifiedGammaMass(// WS Output:
                          Matrix& psd_data,
                          Tensor3& dpsd_data_dx,
                          // WS Input:
                          const Vector& psd_size_grid,
                          const Vector& pnd_agenda_input_t,
                          const Matrix& pnd_agenda_input,
                          const ArrayOfString& pnd_agenda_input_names,
                          const ArrayOfString& dpnd_data_dx_names,
                          const Numeric& scat_species_a,
                          const Numeric& scat_species_b,
                          // WS Generic Input:
                          const Numeric& n0,
                          const Numeric& mu,
                          const Numeric& la,
                          const Numeric& ga,
                          const Numeric& t_min,
                          const Numeric& t_max,
                          const Index& picky,
                          // Verbosity object:
                          const Verbosity& verbosity);


void psdModifiedGammaMassNtot(// WS Output:
                              Matrix& psd_data,
                              Tensor3& dpsd_data_dx,
                              // WS Input:
                              const Vector& psd_size_grid,
                              const Vector& pnd_agenda_input_t,
                              const Matrix& pnd_agenda_input,
                              const ArrayOfString& pnd_agenda_input_names,
                              const ArrayOfString& dpnd_data_dx_names,
                              const Numeric& scat_species_a,
                              const Numeric& scat_species_b,
                              // WS Generic Input:
                              const Numeric& n0,
                              const Numeric& mu,
                              const Numeric& la,
                              const Numeric& ga,
                              const Numeric& t_min,
                              const Numeric& t_max,
                              const Index& picky,
                              // Verbosity object:
                              const Verbosity& verbosity);


void psdModifiedGammaMassMeanParticleMass(// WS Output:
                                          Matrix& psd_data,
                                          Tensor3& dpsd_data_dx,
                                          // WS Input:
                                          const Vector& psd_size_grid,
                                          const Vector& pnd_agenda_input_t,
                                          const Matrix& pnd_agenda_input,
                                          const ArrayOfString& pnd_agenda_input_names,
                                          const ArrayOfString& dpnd_data_dx_names,
                                          const Numeric& scat_species_a,
                                          const Numeric& scat_species_b,
                                          // WS Generic Input:
                                          const Numeric& n0,
                                          const Numeric& mu,
                                          const Numeric& la,
                                          const Numeric& ga,
                                          const Numeric& t_min,
                                          const Numeric& t_max,
                                          const Index& picky,
                                          // Verbosity object:
                                          const Verbosity& verbosity);


void psdModifiedGammaMassSingleMoment(// WS Output:
                                      Matrix& psd_data,
                                      Tensor3& dpsd_data_dx,
                                      // WS Input:
                                      const Vector& psd_size_grid,
                                      const Vector& pnd_agenda_input_t,
                                      const Matrix& pnd_agenda_input,
                                      const ArrayOfString& pnd_agenda_input_names,
                                      const ArrayOfString& dpnd_data_dx_names,
                                      const Numeric& scat_species_a,
                                      const Numeric& scat_species_b,
                                      // WS Generic Input:
                                      const Numeric& n_alpha,
                                      const Numeric& n_b,
                                      const Numeric& mu,
                                      const Numeric& gamma,
                                      const Numeric& t_min,
                                      const Numeric& t_max,
                                      const Index& picky,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void psdModifiedGammaMassXmean(// WS Output:
                               Matrix& psd_data,
                               Tensor3& dpsd_data_dx,
                               // WS Input:
                               const Vector& psd_size_grid,
                               const Vector& pnd_agenda_input_t,
                               const Matrix& pnd_agenda_input,
                               const ArrayOfString& pnd_agenda_input_names,
                               const ArrayOfString& dpnd_data_dx_names,
                               const Numeric& scat_species_a,
                               const Numeric& scat_species_b,
                               // WS Generic Input:
                               const Numeric& n0,
                               const Numeric& mu,
                               const Numeric& la,
                               const Numeric& ga,
                               const Numeric& t_min,
                               const Numeric& t_max,
                               const Index& picky,
                               // Verbosity object:
                               const Verbosity& verbosity);


void psdModifiedGammaMassXmedian(// WS Output:
                                 Matrix& psd_data,
                                 Tensor3& dpsd_data_dx,
                                 // WS Input:
                                 const Vector& psd_size_grid,
                                 const Vector& pnd_agenda_input_t,
                                 const Matrix& pnd_agenda_input,
                                 const ArrayOfString& pnd_agenda_input_names,
                                 const ArrayOfString& dpnd_data_dx_names,
                                 const Numeric& scat_species_a,
                                 const Numeric& scat_species_b,
                                 // WS Generic Input:
                                 const Numeric& n0,
                                 const Numeric& mu,
                                 const Numeric& la,
                                 const Numeric& ga,
                                 const Numeric& t_min,
                                 const Numeric& t_max,
                                 const Index& picky,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void psdMonoDispersive(// WS Output:
                       Matrix& psd_data,
                       Tensor3& dpsd_data_dx,
                       // WS Input:
                       const Vector& pnd_agenda_input_t,
                       const Matrix& pnd_agenda_input,
                       const ArrayOfString& pnd_agenda_input_names,
                       const ArrayOfString& dpnd_data_dx_names,
                       const ArrayOfArrayOfScatteringMetaData& scat_meta,
                       // WS Generic Input:
                       const Index& species_index,
                       const Numeric& t_min,
                       const Numeric& t_max,
                       const Index& picky,
                       // Verbosity object:
                       const Verbosity& verbosity);


void psdMonoMass(// WS Output:
                 Matrix& psd_data,
                 Tensor3& dpsd_data_dx,
                 // WS Input:
                 const Vector& pnd_agenda_input_t,
                 const Matrix& pnd_agenda_input,
                 const ArrayOfString& pnd_agenda_input_names,
                 const ArrayOfString& dpnd_data_dx_names,
                 const ArrayOfArrayOfScatteringMetaData& scat_meta,
                 // WS Generic Input:
                 const Index& species_index,
                 const Numeric& t_min,
                 const Numeric& t_max,
                 const Index& picky,
                 // Verbosity object:
                 const Verbosity& verbosity);


void psdSeifertBeheng06(// WS Output:
                        Matrix& psd_data,
                        Tensor3& dpsd_data_dx,
                        // WS Input:
                        const Vector& psd_size_grid,
                        const Vector& pnd_agenda_input_t,
                        const Matrix& pnd_agenda_input,
                        const ArrayOfString& pnd_agenda_input_names,
                        const ArrayOfString& dpnd_data_dx_names,
                        // WS Generic Input:
                        const String& hydrometeor_type,
                        const Numeric& t_min,
                        const Numeric& t_max,
                        const Index& picky,
                        // Verbosity object:
                        const Verbosity& verbosity);


void psdWangEtAl16(// WS Output:
                   Matrix& psd_data,
                   Tensor3& dpsd_data_dx,
                   // WS Input:
                   const Vector& psd_size_grid,
                   const Vector& pnd_agenda_input_t,
                   const Matrix& pnd_agenda_input,
                   const ArrayOfString& pnd_agenda_input_names,
                   const ArrayOfString& dpnd_data_dx_names,
                   const Numeric& scat_species_a,
                   const Numeric& scat_species_b,
                   // WS Generic Input:
                   const Numeric& t_min,
                   const Numeric& t_max,
                   const Index& picky,
                   // Verbosity object:
                   const Verbosity& verbosity);


void p_gridDensify(// WS Output:
                   Vector& p_grid,
                   Index& atmfields_checked,
                   Index& atmgeom_checked,
                   Index& cloudbox_checked,
                   // WS Generic Input:
                   const Vector& p_grid_old,
                   const Index& nfill,
                   // Verbosity object:
                   const Verbosity& verbosity);


void p_gridFromZRaw(// WS Output:
                    Vector& p_grid,
                    // WS Input:
                    const GriddedField3& z_field_raw,
                    // WS Generic Input:
                    const Index& no_negZ,
                    // Verbosity object:
                    const Verbosity& verbosity);


void lat_gridFromZRaw(// WS Output:
                      Vector& lat_grid,
                      // WS Input:
                      const GriddedField3& z_field_raw,
                      // Verbosity object:
                      const Verbosity& verbosity);


void lon_gridFromZRaw(// WS Output:
                      Vector& lon_grid,
                      // WS Input:
                      const GriddedField3& z_field_raw,
                      // Verbosity object:
                      const Verbosity& verbosity);


void atm_gridsFromZRaw(// WS Output:
                       Vector& p_grid,
                       Vector& lat_grid,
                       Vector& lon_grid,
                       // WS Input:
                       const GriddedField3& z_field_raw,
                       // WS Generic Input:
                       const Index& no_negZ,
                       // Verbosity object:
                       const Verbosity& verbosity);


void p_gridFromGasAbsLookup(// WS Output:
                            Vector& p_grid,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            // Verbosity object:
                            const Verbosity& verbosity);


void p_gridRefine(// WS Output:
                  Vector& p_grid,
                  Index& atmfields_checked,
                  Index& atmgeom_checked,
                  Index& cloudbox_checked,
                  // WS Generic Input:
                  const Vector& p_grid_old,
                  const Numeric& p_step,
                  // Verbosity object:
                  const Verbosity& verbosity);


void RadiationFieldSpectralIntegrate(// WS Generic Output:
                                     Tensor4& radiation_field,
                                     // WS Input:
                                     const Vector& f_grid,
                                     // WS Generic Input:
                                     const Tensor5& spectral_radiation_field,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void RadiationFieldSpectralIntegrate(// WS Generic Output:
                                     Tensor5& radiation_field,
                                     // WS Input:
                                     const Vector& f_grid,
                                     // WS Generic Input:
                                     const Tensor7& spectral_radiation_field,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D(// Workspace reference:
                                                                    Workspace& ws,
                                                                    // WS Output:
                                                                    Matrix& line_irradiance,
                                                                    Tensor3& line_transmission,
                                                                    // WS Input:
                                                                    const ArrayOfArrayOfSpeciesTag& abs_species,
                                                                    const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                                                    const EnergyLevelMap& nlte_field,
                                                                    const Tensor4& vmr_field,
                                                                    const Tensor3& t_field,
                                                                    const Tensor3& z_field,
                                                                    const Vector& p_grid,
                                                                    const Vector& refellipsoid,
                                                                    const Tensor3& surface_props_data,
                                                                    const Agenda& iy_main_agenda,
                                                                    const Agenda& ppath_agenda,
                                                                    const Agenda& iy_space_agenda,
                                                                    const Agenda& iy_surface_agenda,
                                                                    const Agenda& iy_cloudbox_agenda,
                                                                    const Agenda& propmat_clearsky_agenda,
                                                                    // WS Generic Input:
                                                                    const Numeric& df,
                                                                    const Index& nz,
                                                                    const Index& nf,
                                                                    const Numeric& r,
                                                                    // Verbosity object:
                                                                    const Verbosity& verbosity);


void RationalAdd(// WS Generic Output:
                 Rational& out,
                 // WS Generic Input:
                 const Rational& in,
                 const Rational& value,
                 // Verbosity object:
                 const Verbosity& verbosity);


void RationalInvScale(// WS Generic Output:
                      Rational& out,
                      // WS Generic Input:
                      const Rational& in,
                      const Rational& value,
                      // Verbosity object:
                      const Verbosity& verbosity);


void RationalScale(// WS Generic Output:
                   Rational& out,
                   // WS Generic Input:
                   const Rational& in,
                   const Rational& value,
                   // Verbosity object:
                   const Verbosity& verbosity);


void RationalSet(// WS Generic Output:
                 Rational& out,
                 // WS Generic Input:
                 const Index& numerator,
                 const Index& denominator,
                 // Verbosity object:
                 const Verbosity& verbosity);


void ReadArrayOfARTSCAT(// WS Output:
                        ArrayOfAbsorptionLines& abs_lines,
                        // WS Generic Input:
                        const String& filename,
                        const Numeric& fmin,
                        const Numeric& fmax,
                        const String& globalquantumnumbers,
                        const String& localquantumnumbers,
                        const String& normalization_option,
                        const String& mirroring_option,
                        const String& population_option,
                        const String& lineshapetype_option,
                        const String& cutoff_option,
                        const Numeric& cutoff_value,
                        const Numeric& linemixinglimit_value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void ReadSplitARTSCAT(// WS Output:
                      ArrayOfAbsorptionLines& abs_lines,
                      // WS Input:
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      // WS Generic Input:
                      const String& basename,
                      const Numeric& fmin,
                      const Numeric& fmax,
                      const String& globalquantumnumbers,
                      const String& localquantumnumbers,
                      const Index& ignore_missing,
                      const String& normalization_option,
                      const String& mirroring_option,
                      const String& population_option,
                      const String& lineshapetype_option,
                      const String& cutoff_option,
                      const Numeric& cutoff_value,
                      const Numeric& linemixinglimit_value,
                      // Verbosity object:
                      const Verbosity& verbosity);


void ReadARTSCAT(// WS Output:
                 ArrayOfAbsorptionLines& abs_lines,
                 // WS Generic Input:
                 const String& filename,
                 const Numeric& fmin,
                 const Numeric& fmax,
                 const String& globalquantumnumbers,
                 const String& localquantumnumbers,
                 const String& normalization_option,
                 const String& mirroring_option,
                 const String& population_option,
                 const String& lineshapetype_option,
                 const String& cutoff_option,
                 const Numeric& cutoff_value,
                 const Numeric& linemixinglimit_value,
                 // Verbosity object:
                 const Verbosity& verbosity);


void ReadHITRAN(// WS Output:
                ArrayOfAbsorptionLines& abs_lines,
                // WS Generic Input:
                const String& filename,
                const Numeric& fmin,
                const Numeric& fmax,
                const String& globalquantumnumbers,
                const String& localquantumnumbers,
                const String& hitran_type,
                const String& normalization_option,
                const String& mirroring_option,
                const String& population_option,
                const String& lineshapetype_option,
                const String& cutoff_option,
                const Numeric& cutoff_value,
                const Numeric& linemixinglimit_value,
                // Verbosity object:
                const Verbosity& verbosity);


void ReadLBLRTM(// WS Output:
                ArrayOfAbsorptionLines& abs_lines,
                // WS Generic Input:
                const String& filename,
                const Numeric& fmin,
                const Numeric& fmax,
                const String& globalquantumnumbers,
                const String& localquantumnumbers,
                const String& normalization_option,
                const String& mirroring_option,
                const String& population_option,
                const String& lineshapetype_option,
                const String& cutoff_option,
                const Numeric& cutoff_value,
                const Numeric& linemixinglimit_value,
                // Verbosity object:
                const Verbosity& verbosity);


void ReadMytran2(// WS Output:
                 ArrayOfAbsorptionLines& abs_lines,
                 // WS Generic Input:
                 const String& filename,
                 const Numeric& fmin,
                 const Numeric& fmax,
                 const String& globalquantumnumbers,
                 const String& localquantumnumbers,
                 const String& normalization_option,
                 const String& mirroring_option,
                 const String& population_option,
                 const String& lineshapetype_option,
                 const String& cutoff_option,
                 const Numeric& cutoff_value,
                 const Numeric& linemixinglimit_value,
                 // Verbosity object:
                 const Verbosity& verbosity);


void ReadJPL(// WS Output:
             ArrayOfAbsorptionLines& abs_lines,
             // WS Generic Input:
             const String& filename,
             const Numeric& fmin,
             const Numeric& fmax,
             const String& globalquantumnumbers,
             const String& localquantumnumbers,
             const String& normalization_option,
             const String& mirroring_option,
             const String& population_option,
             const String& lineshapetype_option,
             const String& cutoff_option,
             const Numeric& cutoff_value,
             const Numeric& linemixinglimit_value,
             // Verbosity object:
             const Verbosity& verbosity);


void abs_linesTruncateGlobalQuantumNumbers(// WS Output:
                                           ArrayOfAbsorptionLines& abs_lines,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void abs_linesWriteSplitXML(// WS Input:
                            const String& output_file_format,
                            const ArrayOfAbsorptionLines& abs_lines,
                            // WS Generic Input:
                            const String& basename,
                            // Verbosity object:
                            const Verbosity& verbosity);


void abs_linesWriteSpeciesSplitXML(// WS Input:
                                   const String& output_file_format,
                                   const ArrayOfAbsorptionLines& abs_lines,
                                   // WS Generic Input:
                                   const String& basename,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void abs_lines_per_speciesWriteSplitXML(// WS Input:
                                        const String& output_file_format,
                                        const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                        // WS Generic Input:
                                        const String& basename,
                                        // Verbosity object:
                                        const Verbosity& verbosity);


void abs_lines_per_speciesWriteSpeciesSplitXML(// WS Input:
                                               const String& output_file_format,
                                               const ArrayOfArrayOfAbsorptionLines& abs_lines_per_species,
                                               // WS Generic Input:
                                               const String& basename,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Vector& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Matrix& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Numeric& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Matrix& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Vector& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor3& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Matrix& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor4& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor3& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor5& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor4& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor5& o,
            // WS Generic Input:
            const Tensor6& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor5& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void Reduce(// WS Generic Output:
            Tensor6& o,
            // WS Generic Input:
            const Tensor7& i,
            // Verbosity object:
            const Verbosity& verbosity);


void refellipsoidEarth(// WS Output:
                       Vector& refellipsoid,
                       // WS Generic Input:
                       const String& model,
                       // Verbosity object:
                       const Verbosity& verbosity);


void refellipsoidGanymede(// WS Output:
                          Vector& refellipsoid,
                          // WS Generic Input:
                          const String& model,
                          // Verbosity object:
                          const Verbosity& verbosity);


void refellipsoidForAzimuth(// WS Output:
                            Vector& refellipsoid,
                            // WS Generic Input:
                            const Numeric& latitude,
                            const Numeric& azimuth,
                            // Verbosity object:
                            const Verbosity& verbosity);


void refellipsoidEuropa(// WS Output:
                        Vector& refellipsoid,
                        // WS Generic Input:
                        const String& model,
                        // Verbosity object:
                        const Verbosity& verbosity);


void refellipsoidIo(// WS Output:
                    Vector& refellipsoid,
                    // WS Generic Input:
                    const String& model,
                    // Verbosity object:
                    const Verbosity& verbosity);


void refellipsoidJupiter(// WS Output:
                         Vector& refellipsoid,
                         // WS Generic Input:
                         const String& model,
                         // Verbosity object:
                         const Verbosity& verbosity);


void refellipsoidMars(// WS Output:
                      Vector& refellipsoid,
                      // WS Generic Input:
                      const String& model,
                      // Verbosity object:
                      const Verbosity& verbosity);


void refellipsoidMoon(// WS Output:
                      Vector& refellipsoid,
                      // WS Generic Input:
                      const String& model,
                      // Verbosity object:
                      const Verbosity& verbosity);


void refellipsoidOrbitPlane(// WS Output:
                            Vector& refellipsoid,
                            // WS Generic Input:
                            const Numeric& orbitinc,
                            // Verbosity object:
                            const Verbosity& verbosity);


void refellipsoidSet(// WS Output:
                     Vector& refellipsoid,
                     // WS Generic Input:
                     const Numeric& re,
                     const Numeric& e,
                     // Verbosity object:
                     const Verbosity& verbosity);


void refellipsoidVenus(// WS Output:
                       Vector& refellipsoid,
                       // WS Generic Input:
                       const String& model,
                       // Verbosity object:
                       const Verbosity& verbosity);


void refr_index_airFreeElectrons(// WS Output:
                                 Numeric& refr_index_air,
                                 Numeric& refr_index_air_group,
                                 // WS Input:
                                 const Vector& f_grid,
                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                 const Vector& rtp_vmr,
                                 // WS Generic Input:
                                 const Index& demand_vmr_value,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void refr_index_airInfraredEarth(// WS Output:
                                 Numeric& refr_index_air,
                                 Numeric& refr_index_air_group,
                                 // WS Input:
                                 const Numeric& rtp_pressure,
                                 const Numeric& rtp_temperature,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void refr_index_airMicrowavesEarth(// WS Output:
                                   Numeric& refr_index_air,
                                   Numeric& refr_index_air_group,
                                   // WS Input:
                                   const Numeric& rtp_pressure,
                                   const Numeric& rtp_temperature,
                                   const Vector& rtp_vmr,
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   // WS Generic Input:
                                   const Numeric& k1,
                                   const Numeric& k2,
                                   const Numeric& k3,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void refr_index_airMicrowavesGeneral(// WS Output:
                                     Numeric& refr_index_air,
                                     Numeric& refr_index_air_group,
                                     // WS Input:
                                     const Numeric& rtp_pressure,
                                     const Numeric& rtp_temperature,
                                     const Vector& rtp_vmr,
                                     const ArrayOfArrayOfSpeciesTag& abs_species,
                                     // Verbosity object:
                                     const Verbosity& verbosity);


void retrievalDefClose(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Index& jacobian_do,
                       Agenda& jacobian_agenda,
                       Index& retrieval_checked,
                       // WS Input:
                       const CovarianceMatrix& covmat_sx,
                       const ArrayOfRetrievalQuantity& jacobian_quantities,
                       // Verbosity object:
                       const Verbosity& verbosity);


void retrievalAddAbsSpecies(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            CovarianceMatrix& covmat_sx,
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Index& atmosphere_dim,
                            const Sparse& covmat_block,
                            const Sparse& covmat_inv_block,
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            // WS Generic Input:
                            const Vector& g1,
                            const Vector& g2,
                            const Vector& g3,
                            const String& species,
                            const String& unit,
                            const Index& for_species_tag,
                            // Verbosity object:
                            const Verbosity& verbosity);


void retrievalAddFreqShift(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           CovarianceMatrix& covmat_sx,
                           ArrayOfRetrievalQuantity& jacobian_quantities,
                           Agenda& jacobian_agenda,
                           // WS Input:
                           const Sparse& covmat_block,
                           const Sparse& covmat_inv_block,
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Numeric& df,
                           // Verbosity object:
                           const Verbosity& verbosity);


void retrievalAddFreqStretch(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             CovarianceMatrix& covmat_sx,
                             ArrayOfRetrievalQuantity& jacobian_quantities,
                             Agenda& jacobian_agenda,
                             // WS Input:
                             const Vector& f_grid,
                             const Sparse& covmat_block,
                             const Sparse& covmat_inv_block,
                             // WS Generic Input:
                             const Numeric& df,
                             // Verbosity object:
                             const Verbosity& verbosity);


void retrievalDefInit(// WS Output:
                      CovarianceMatrix& covmat_se,
                      CovarianceMatrix& covmat_sx,
                      Sparse& covmat_block,
                      Sparse& covmat_inv_block,
                      ArrayOfRetrievalQuantity& jacobian_quantities,
                      Agenda& jacobian_agenda,
                      // WS Generic Input:
                      const Index& initialize_jacobian,
                      // Verbosity object:
                      const Verbosity& verbosity);


void retrievalAddCatalogParameter(// Workspace reference:
                                  Workspace& ws,
                                  // WS Output:
                                  CovarianceMatrix& covmat_sx,
                                  ArrayOfRetrievalQuantity& jacobian_quantities,
                                  Agenda& jacobian_agenda,
                                  // WS Generic Input:
                                  const QuantumIdentifier& catalog_identity,
                                  const String& catalog_parameter,
                                  const Numeric& var,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void retrievalAddCatalogParameters(// Workspace reference:
                                   Workspace& ws,
                                   // WS Output:
                                   CovarianceMatrix& covmat_sx,
                                   ArrayOfRetrievalQuantity& jacobian_quantities,
                                   Agenda& jacobian_agenda,
                                   // WS Input:
                                   const Sparse& covmat_block,
                                   const Sparse& covmat_inv_block,
                                   // WS Generic Input:
                                   const ArrayOfQuantumIdentifier& catalog_identities,
                                   const ArrayOfString& catalog_parameters,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void retrievalAddMagField(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          CovarianceMatrix& covmat_sx,
                          ArrayOfRetrievalQuantity& jacobian_quantities,
                          Agenda& jacobian_agenda,
                          // WS Input:
                          const Index& atmosphere_dim,
                          const Sparse& covmat_block,
                          const Sparse& covmat_inv_block,
                          const Vector& p_grid,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          // WS Generic Input:
                          const Vector& g1,
                          const Vector& g2,
                          const Vector& g3,
                          const String& component,
                          const Numeric& dB,
                          // Verbosity object:
                          const Verbosity& verbosity);


void retrievalAddPointingZa(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            CovarianceMatrix& covmat_sx,
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Sparse& covmat_block,
                            const Sparse& covmat_inv_block,
                            const Matrix& sensor_pos,
                            const Vector& sensor_time,
                            // WS Generic Input:
                            const Index& poly_order,
                            const String& calcmode,
                            const Numeric& dza,
                            // Verbosity object:
                            const Verbosity& verbosity);


void retrievalAddPolyfit(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         CovarianceMatrix& covmat_sx,
                         ArrayOfRetrievalQuantity& jacobian_quantities,
                         Agenda& jacobian_agenda,
                         // WS Input:
                         const Sparse& covmat_block,
                         const Sparse& covmat_inv_block,
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Matrix& sensor_response_dlos_grid,
                         const Matrix& sensor_pos,
                         // WS Generic Input:
                         const Index& poly_order,
                         const Index& no_pol_variation,
                         const Index& no_los_variation,
                         const Index& no_mblock_variation,
                         // Verbosity object:
                         const Verbosity& verbosity);


void retrievalAddScatSpecies(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             CovarianceMatrix& covmat_sx,
                             ArrayOfRetrievalQuantity& jacobian_quantities,
                             Agenda& jacobian_agenda,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Sparse& covmat_block,
                             const Sparse& covmat_inv_block,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             // WS Generic Input:
                             const Vector& g1,
                             const Vector& g2,
                             const Vector& g3,
                             const String& species,
                             const String& quantity,
                             // Verbosity object:
                             const Verbosity& verbosity);


void retrievalAddSinefit(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         CovarianceMatrix& covmat_sx,
                         ArrayOfRetrievalQuantity& jacobian_quantities,
                         Agenda& jacobian_agenda,
                         // WS Input:
                         const Sparse& covmat_block,
                         const Sparse& covmat_inv_block,
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Matrix& sensor_response_dlos_grid,
                         const Matrix& sensor_pos,
                         // WS Generic Input:
                         const Vector& period_lengths,
                         const Index& no_pol_variation,
                         const Index& no_los_variation,
                         const Index& no_mblock_variation,
                         // Verbosity object:
                         const Verbosity& verbosity);


void retrievalAddSpecialSpecies(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                CovarianceMatrix& covmat_sx,
                                ArrayOfRetrievalQuantity& jacobian_quantities,
                                Agenda& jacobian_agenda,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const Sparse& covmat_block,
                                const Sparse& covmat_inv_block,
                                const Vector& p_grid,
                                const Vector& lat_grid,
                                const Vector& lon_grid,
                                // WS Generic Input:
                                const Vector& g1,
                                const Vector& g2,
                                const Vector& g3,
                                const String& species,
                                // Verbosity object:
                                const Verbosity& verbosity);


void retrievalAddSurfaceQuantity(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 CovarianceMatrix& covmat_sx,
                                 ArrayOfRetrievalQuantity& jacobian_quantities,
                                 Agenda& jacobian_agenda,
                                 // WS Input:
                                 const Sparse& covmat_block,
                                 const Sparse& covmat_inv_block,
                                 const Index& atmosphere_dim,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 // WS Generic Input:
                                 const Vector& g1,
                                 const Vector& g2,
                                 const String& quantity,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void retrievalAddTemperature(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             CovarianceMatrix& covmat_sx,
                             ArrayOfRetrievalQuantity& jacobian_quantities,
                             Agenda& jacobian_agenda,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Sparse& covmat_block,
                             const Sparse& covmat_inv_block,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             // WS Generic Input:
                             const Vector& g1,
                             const Vector& g2,
                             const Vector& g3,
                             const String& hse,
                             // Verbosity object:
                             const Verbosity& verbosity);


void retrievalAddWind(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      CovarianceMatrix& covmat_sx,
                      ArrayOfRetrievalQuantity& jacobian_quantities,
                      Agenda& jacobian_agenda,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Sparse& covmat_block,
                      const Sparse& covmat_inv_block,
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      // WS Generic Input:
                      const Vector& g1,
                      const Vector& g2,
                      const Vector& g3,
                      const String& component,
                      const Numeric& dfrequency,
                      // Verbosity object:
                      const Verbosity& verbosity);


void retrievalErrorsExtract(// WS Output:
                            Vector& retrieval_eo,
                            Vector& retrieval_ss,
                            // WS Input:
                            const Matrix& covmat_so,
                            const Matrix& covmat_ss,
                            // Verbosity object:
                            const Verbosity& verbosity);


void RT4Calc(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Tensor7& cloudbox_field,
             Vector& za_grid,
             Vector& aa_grid,
             // WS Input:
             const Index& atmfields_checked,
             const Index& atmgeom_checked,
             const Index& scat_data_checked,
             const Index& cloudbox_checked,
             const Index& cloudbox_on,
             const ArrayOfIndex& cloudbox_limits,
             const Agenda& propmat_clearsky_agenda,
             const Agenda& surface_rtprop_agenda,
             const Index& atmosphere_dim,
             const Tensor4& pnd_field,
             const Tensor3& t_field,
             const Tensor3& z_field,
             const Tensor4& vmr_field,
             const Vector& p_grid,
             const ArrayOfArrayOfSingleScatteringData& scat_data,
             const Vector& f_grid,
             const Index& stokes_dim,
             const Matrix& z_surface,
             // WS Generic Input:
             const Index& nstreams,
             const String& pfct_method,
             const String& quad_type,
             const Index& add_straight_angles,
             const Index& pfct_aa_grid_size,
             const Index& auto_inc_nstreams,
             const Index& robust,
             const Index& za_interp_order,
             const Index& cos_za_interp,
             const Numeric& max_delta_tau,
             // Verbosity object:
             const Verbosity& verbosity);


void RT4CalcWithRT4Surface(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           Tensor7& cloudbox_field,
                           Vector& za_grid,
                           Vector& aa_grid,
                           // WS Input:
                           const Index& atmfields_checked,
                           const Index& atmgeom_checked,
                           const Index& scat_data_checked,
                           const Index& cloudbox_checked,
                           const Index& cloudbox_on,
                           const ArrayOfIndex& cloudbox_limits,
                           const Agenda& propmat_clearsky_agenda,
                           const Index& atmosphere_dim,
                           const Tensor4& pnd_field,
                           const Tensor3& t_field,
                           const Tensor3& z_field,
                           const Tensor4& vmr_field,
                           const Vector& p_grid,
                           const ArrayOfArrayOfSingleScatteringData& scat_data,
                           const Vector& f_grid,
                           const Index& stokes_dim,
                           const Matrix& z_surface,
                           const Numeric& surface_skin_t,
                           const Vector& surface_scalar_reflectivity,
                           const Tensor3& surface_reflectivity,
                           const GriddedField3& surface_complex_refr_index,
                           // WS Generic Input:
                           const Index& nstreams,
                           const String& pfct_method,
                           const String& ground_type,
                           const String& quad_type,
                           const Index& add_straight_angles,
                           const Index& pfct_aa_grid_size,
                           const Index& auto_inc_nstreams,
                           const Index& robust,
                           const Index& za_interp_order,
                           const Index& cos_za_interp,
                           const Numeric& max_delta_tau,
                           // Verbosity object:
                           const Verbosity& verbosity);


void RT4Test(// WS Generic Output:
             Tensor4& out_rad,
             // WS Generic Input:
             const String& datapath,
             // Verbosity object:
             const Verbosity& verbosity);


void rte_losGeometricFromRtePosToRtePos2(// WS Output:
                                         Vector& rte_los,
                                         // WS Input:
                                         const Index& atmosphere_dim,
                                         const Vector& lat_grid,
                                         const Vector& lon_grid,
                                         const Vector& refellipsoid,
                                         const Vector& rte_pos,
                                         const Vector& rte_pos2,
                                         // Verbosity object:
                                         const Verbosity& verbosity);


void rte_losSet(// WS Output:
                Vector& rte_los,
                // WS Input:
                const Index& atmosphere_dim,
                // WS Generic Input:
                const Numeric& za,
                const Numeric& aa,
                // Verbosity object:
                const Verbosity& verbosity);


void rte_posSet(// WS Output:
                Vector& rte_pos,
                // WS Input:
                const Index& atmosphere_dim,
                // WS Generic Input:
                const Numeric& z,
                const Numeric& lat,
                const Numeric& lon,
                // Verbosity object:
                const Verbosity& verbosity);


void rte_pos_losMoveToStartOfPpath(// WS Output:
                                   Vector& rte_pos,
                                   Vector& rte_los,
                                   // WS Input:
                                   const Index& atmosphere_dim,
                                   const Ppath& ppath,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void rtp_nlteFromRaw(// WS Output:
                     EnergyLevelMap& rtp_nlte,
                     // WS Input:
                     const ArrayOfQuantumIdentifier& nlte_level_identifiers,
                     const Vector& nlte_vibrational_energies,
                     // WS Generic Input:
                     const Vector& data,
                     // Verbosity object:
                     const Verbosity& verbosity);


void ScatElementsPndAndScatAdd(// WS Output:
                               ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                               ArrayOfGriddedField3& pnd_field_raw,
                               // WS Input:
                               const Index& atmosphere_dim,
                               // WS Generic Input:
                               const ArrayOfString& scat_data_files,
                               const ArrayOfString& pnd_field_files,
                               // Verbosity object:
                               const Verbosity& verbosity);


void ScatElementsSelect(// WS Output:
                        ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                        ArrayOfArrayOfScatteringMetaData& scat_meta,
                        // WS Input:
                        const ArrayOfString& scat_species,
                        // WS Generic Input:
                        const String& species,
                        const String& sizeparam,
                        const Numeric& sizemin,
                        const Numeric& sizemax,
                        const Numeric& tolerance,
                        const String& delim,
                        // Verbosity object:
                        const Verbosity& verbosity);


void ScatElementsToabs_speciesAdd(// WS Output:
                                  ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                  ArrayOfGriddedField3& vmr_field_raw,
                                  ArrayOfArrayOfSpeciesTag& abs_species,
                                  Index& propmat_clearsky_agenda_checked,
                                  Index& abs_xsec_agenda_checked,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  const Vector& f_grid,
                                  // WS Generic Input:
                                  const ArrayOfString& scat_data_files,
                                  const ArrayOfString& pnd_field_files,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void ScatSpeciesExtendTemperature(// WS Output:
                                  ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                  // WS Input:
                                  const ArrayOfString& scat_species,
                                  // WS Generic Input:
                                  const String& species,
                                  const String& scat_species_delim,
                                  const Numeric& T_low,
                                  const Numeric& T_high,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void ScatSpeciesInit(// WS Output:
                     ArrayOfString& scat_species,
                     ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                     ArrayOfArrayOfScatteringMetaData& scat_meta,
                     Index& scat_data_checked,
                     ArrayOfGriddedField3& pnd_field_raw,
                     // Verbosity object:
                     const Verbosity& verbosity);


void ScatSpeciesMerge(// WS Output:
                      Tensor4& pnd_field,
                      ArrayOfArrayOfSingleScatteringData& scat_data,
                      ArrayOfArrayOfScatteringMetaData& scat_meta,
                      ArrayOfString& scat_species,
                      Index& cloudbox_checked,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Index& cloudbox_on,
                      const ArrayOfIndex& cloudbox_limits,
                      const Tensor3& t_field,
                      const Tensor3& z_field,
                      const Matrix& z_surface,
                      // Verbosity object:
                      const Verbosity& verbosity);


void ScatSpeciesPndAndScatAdd(// WS Output:
                              ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                              ArrayOfGriddedField3& pnd_field_raw,
                              // WS Input:
                              const Index& atmosphere_dim,
                              // WS Generic Input:
                              const ArrayOfString& scat_data_files,
                              const String& pnd_fieldarray_file,
                              // Verbosity object:
                              const Verbosity& verbosity);


void ScatSpeciesScatAndMetaRead(// WS Output:
                                ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                                ArrayOfArrayOfScatteringMetaData& scat_meta,
                                // WS Generic Input:
                                const ArrayOfString& scat_data_files,
                                // Verbosity object:
                                const Verbosity& verbosity);


void scat_data_singleTmatrix(// WS Output:
                             SingleScatteringData& scat_data_single,
                             ScatteringMetaData& scat_meta_single,
                             // WS Input:
                             const GriddedField3& complex_refr_index,
                             // WS Generic Input:
                             const String& shape,
                             const Numeric& diameter_volume_equ,
                             const Numeric& aspect_ratio,
                             const Numeric& mass,
                             const String& ptype,
                             const Vector& data_f_grid,
                             const Vector& data_t_grid,
                             const Vector& data_za_grid,
                             const Vector& data_aa_grid,
                             const Numeric& precision,
                             const String& cri_source,
                             const Index& ndgs,
                             const Index& robust,
                             const Index& quiet,
                             // Verbosity object:
                             const Verbosity& verbosity);


void scat_data_checkedCalc(// WS Output:
                           Index& scat_data_checked,
                           // WS Input:
                           const ArrayOfArrayOfSingleScatteringData& scat_data,
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Numeric& dfrel_threshold,
                           const String& check_level,
                           const Numeric& sca_mat_threshold,
                           // Verbosity object:
                           const Verbosity& verbosity);


void scat_data_monoCalc(// WS Output:
                        ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                        // WS Input:
                        const ArrayOfArrayOfSingleScatteringData& scat_data,
                        const Vector& f_grid,
                        const Index& f_index,
                        // Verbosity object:
                        const Verbosity& verbosity);


void scat_data_monoExtract(// WS Output:
                           ArrayOfArrayOfSingleScatteringData& scat_data_mono,
                           // WS Input:
                           const ArrayOfArrayOfSingleScatteringData& scat_data,
                           const Index& f_index,
                           // Verbosity object:
                           const Verbosity& verbosity);


void scat_dataCalc(// WS Output:
                   ArrayOfArrayOfSingleScatteringData& scat_data,
                   // WS Input:
                   const ArrayOfArrayOfSingleScatteringData& scat_data_raw,
                   const Vector& f_grid,
                   // WS Generic Input:
                   const Index& interp_order,
                   // Verbosity object:
                   const Verbosity& verbosity);


void scat_dataCheck(// WS Input:
                    const ArrayOfArrayOfSingleScatteringData& scat_data,
                    // WS Generic Input:
                    const String& check_type,
                    const Numeric& sca_mat_threshold,
                    // Verbosity object:
                    const Verbosity& verbosity);


void scat_dataReduceT(// WS Output:
                      ArrayOfArrayOfSingleScatteringData& scat_data,
                      // WS Generic Input:
                      const Index& scat_index,
                      const Numeric& temperature,
                      const Index& interp_order,
                      const Index& phamat_only,
                      const Numeric& sca_mat_threshold,
                      // Verbosity object:
                      const Verbosity& verbosity);


void ScatSpeciesSizeMassInfo(// WS Output:
                             Vector& scat_species_x,
                             Numeric& scat_species_a,
                             Numeric& scat_species_b,
                             // WS Input:
                             const ArrayOfArrayOfScatteringMetaData& scat_meta,
                             // WS Generic Input:
                             const Index& species_index,
                             const String& x_unit,
                             const Numeric& x_fit_start,
                             const Numeric& x_fit_end,
                             const Index& do_only_x,
                             // Verbosity object:
                             const Verbosity& verbosity);


void particle_fieldCleanup(// WS Generic Output:
                           Tensor4& particle_field_out,
                           // WS Generic Input:
                           const Tensor4& particle_field_in,
                           const Numeric& threshold,
                           // Verbosity object:
                           const Verbosity& verbosity);


void sensor_checkedCalc(// WS Output:
                        Index& sensor_checked,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Index& stokes_dim,
                        const Vector& f_grid,
                        const Matrix& sensor_pos,
                        const Matrix& sensor_los,
                        const Matrix& transmitter_pos,
                        const Matrix& mblock_dlos_grid,
                        const Sparse& sensor_response,
                        const Vector& sensor_response_f,
                        const ArrayOfIndex& sensor_response_pol,
                        const Matrix& sensor_response_dlos,
                        // Verbosity object:
                        const Verbosity& verbosity);


void sensorOff(// WS Output:
               Sparse& sensor_response,
               Vector& sensor_response_f,
               ArrayOfIndex& sensor_response_pol,
               Matrix& sensor_response_dlos,
               Vector& sensor_response_f_grid,
               ArrayOfIndex& sensor_response_pol_grid,
               Matrix& sensor_response_dlos_grid,
               Matrix& mblock_dlos_grid,
               // WS Input:
               const Index& stokes_dim,
               const Vector& f_grid,
               // Verbosity object:
               const Verbosity& verbosity);


void sensor_losGeometricFromSensorPosToOtherPositions(// WS Output:
                                                      Matrix& sensor_los,
                                                      // WS Input:
                                                      const Index& atmosphere_dim,
                                                      const Vector& lat_grid,
                                                      const Vector& lon_grid,
                                                      const Vector& refellipsoid,
                                                      const Matrix& sensor_pos,
                                                      // WS Generic Input:
                                                      const Matrix& target_pos,
                                                      // Verbosity object:
                                                      const Verbosity& verbosity);


void sensor_responseAntenna(// WS Output:
                            Sparse& sensor_response,
                            Vector& sensor_response_f,
                            ArrayOfIndex& sensor_response_pol,
                            Matrix& sensor_response_dlos,
                            Matrix& sensor_response_dlos_grid,
                            // WS Input:
                            const Vector& sensor_response_f_grid,
                            const ArrayOfIndex& sensor_response_pol_grid,
                            const Index& atmosphere_dim,
                            const Index& antenna_dim,
                            const Matrix& antenna_dlos,
                            const GriddedField4& antenna_response,
                            const Index& sensor_norm,
                            // WS Generic Input:
                            const String& option_2d,
                            // Verbosity object:
                            const Verbosity& verbosity);


void sensor_responseBackend(// WS Output:
                            Sparse& sensor_response,
                            Vector& sensor_response_f,
                            ArrayOfIndex& sensor_response_pol,
                            Matrix& sensor_response_dlos,
                            Vector& sensor_response_f_grid,
                            // WS Input:
                            const ArrayOfIndex& sensor_response_pol_grid,
                            const Matrix& sensor_response_dlos_grid,
                            const Vector& f_backend,
                            const ArrayOfGriddedField1& backend_channel_response,
                            const Index& sensor_norm,
                            // Verbosity object:
                            const Verbosity& verbosity);


void sensor_responseBackendFrequencySwitching(// WS Output:
                                              Sparse& sensor_response,
                                              Vector& sensor_response_f,
                                              ArrayOfIndex& sensor_response_pol,
                                              Matrix& sensor_response_dlos,
                                              Vector& sensor_response_f_grid,
                                              // WS Input:
                                              const ArrayOfIndex& sensor_response_pol_grid,
                                              const Matrix& sensor_response_dlos_grid,
                                              const Vector& f_backend,
                                              const ArrayOfGriddedField1& backend_channel_response,
                                              const Index& sensor_norm,
                                              // WS Generic Input:
                                              const Numeric& df1,
                                              const Numeric& df2,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void sensor_responseBeamSwitching(// WS Output:
                                  Sparse& sensor_response,
                                  Vector& sensor_response_f,
                                  ArrayOfIndex& sensor_response_pol,
                                  Matrix& sensor_response_dlos,
                                  Matrix& sensor_response_dlos_grid,
                                  // WS Input:
                                  const Vector& sensor_response_f_grid,
                                  const ArrayOfIndex& sensor_response_pol_grid,
                                  // WS Generic Input:
                                  const Numeric& w1,
                                  const Numeric& w2,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void sensor_responseFillFgrid(// WS Output:
                              Sparse& sensor_response,
                              Vector& sensor_response_f,
                              ArrayOfIndex& sensor_response_pol,
                              Matrix& sensor_response_dlos,
                              Vector& sensor_response_f_grid,
                              // WS Input:
                              const ArrayOfIndex& sensor_response_pol_grid,
                              const Matrix& sensor_response_dlos_grid,
                              // WS Generic Input:
                              const Index& polyorder,
                              const Index& nfill,
                              // Verbosity object:
                              const Verbosity& verbosity);


void sensor_responseFrequencySwitching(// WS Output:
                                       Sparse& sensor_response,
                                       Vector& sensor_response_f,
                                       ArrayOfIndex& sensor_response_pol,
                                       Matrix& sensor_response_dlos,
                                       Vector& sensor_response_f_grid,
                                       // WS Input:
                                       const ArrayOfIndex& sensor_response_pol_grid,
                                       const Matrix& sensor_response_dlos_grid,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void sensor_responseIF2RF(// WS Output:
                          Vector& sensor_response_f,
                          Vector& sensor_response_f_grid,
                          // WS Input:
                          const Numeric& lo,
                          const String& sideband_mode,
                          // Verbosity object:
                          const Verbosity& verbosity);


void sensor_responseInit(// WS Output:
                         Sparse& sensor_response,
                         Vector& sensor_response_f,
                         ArrayOfIndex& sensor_response_pol,
                         Matrix& sensor_response_dlos,
                         Vector& sensor_response_f_grid,
                         ArrayOfIndex& sensor_response_pol_grid,
                         Matrix& sensor_response_dlos_grid,
                         // WS Input:
                         const Vector& f_grid,
                         const Matrix& mblock_dlos_grid,
                         const Index& antenna_dim,
                         const Index& atmosphere_dim,
                         const Index& stokes_dim,
                         const Index& sensor_norm,
                         // Verbosity object:
                         const Verbosity& verbosity);


void sensor_responseMetMM(// WS Output:
                          Index& antenna_dim,
                          Matrix& mblock_dlos_grid,
                          Sparse& sensor_response,
                          Vector& sensor_response_f,
                          ArrayOfIndex& sensor_response_pol,
                          Matrix& sensor_response_dlos,
                          Vector& sensor_response_f_grid,
                          ArrayOfIndex& sensor_response_pol_grid,
                          Matrix& sensor_response_dlos_grid,
                          Index& sensor_norm,
                          // WS Input:
                          const Index& atmosphere_dim,
                          const Index& stokes_dim,
                          const Vector& f_grid,
                          const Vector& f_backend,
                          const ArrayOfArrayOfIndex& channel2fgrid_indexes,
                          const ArrayOfVector& channel2fgrid_weights,
                          const String& iy_unit,
                          const Matrix& antenna_dlos,
                          const ArrayOfString& met_mm_polarisation,
                          const Vector& met_mm_antenna,
                          // WS Generic Input:
                          const Index& use_antenna,
                          const Index& mirror_dza,
                          // Verbosity object:
                          const Verbosity& verbosity);


void sensor_responseMixer(// WS Output:
                          Sparse& sensor_response,
                          Vector& sensor_response_f,
                          ArrayOfIndex& sensor_response_pol,
                          Matrix& sensor_response_dlos,
                          Vector& sensor_response_f_grid,
                          // WS Input:
                          const ArrayOfIndex& sensor_response_pol_grid,
                          const Matrix& sensor_response_dlos_grid,
                          const Numeric& lo,
                          const GriddedField1& sideband_response,
                          const Index& sensor_norm,
                          // Verbosity object:
                          const Verbosity& verbosity);


void sensor_responseMixerBackendPrecalcWeights(// WS Output:
                                               Sparse& sensor_response,
                                               Vector& sensor_response_f,
                                               ArrayOfIndex& sensor_response_pol,
                                               Matrix& sensor_response_dlos,
                                               Vector& sensor_response_f_grid,
                                               // WS Input:
                                               const ArrayOfIndex& sensor_response_pol_grid,
                                               const Matrix& sensor_response_dlos_grid,
                                               const Vector& f_backend,
                                               const ArrayOfArrayOfIndex& channel2fgrid_indexes,
                                               const ArrayOfVector& channel2fgrid_weights,
                                               // Verbosity object:
                                               const Verbosity& verbosity);


void sensor_responseMultiMixerBackend(// WS Output:
                                      Sparse& sensor_response,
                                      Vector& sensor_response_f,
                                      ArrayOfIndex& sensor_response_pol,
                                      Matrix& sensor_response_dlos,
                                      Vector& sensor_response_f_grid,
                                      // WS Input:
                                      const ArrayOfIndex& sensor_response_pol_grid,
                                      const Matrix& sensor_response_dlos_grid,
                                      const Vector& lo_multi,
                                      const ArrayOfGriddedField1& sideband_response_multi,
                                      const ArrayOfString& sideband_mode_multi,
                                      const ArrayOfVector& f_backend_multi,
                                      const ArrayOfArrayOfGriddedField1& backend_channel_response_multi,
                                      const Index& sensor_norm,
                                      // Verbosity object:
                                      const Verbosity& verbosity);


void sensor_responsePolarisation(// WS Output:
                                 Sparse& sensor_response,
                                 Vector& sensor_response_f,
                                 ArrayOfIndex& sensor_response_pol,
                                 Matrix& sensor_response_dlos,
                                 ArrayOfIndex& sensor_response_pol_grid,
                                 // WS Input:
                                 const Vector& sensor_response_f_grid,
                                 const Matrix& sensor_response_dlos_grid,
                                 const Index& stokes_dim,
                                 const String& iy_unit,
                                 const ArrayOfIndex& instrument_pol,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void sensor_responseStokesRotation(// WS Output:
                                   Sparse& sensor_response,
                                   // WS Input:
                                   const Vector& sensor_response_f_grid,
                                   const ArrayOfIndex& sensor_response_pol_grid,
                                   const Matrix& sensor_response_dlos_grid,
                                   const Index& stokes_dim,
                                   const Vector& stokes_rotation,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void sensor_responseSimpleAMSU(// WS Output:
                               Vector& f_grid,
                               Index& antenna_dim,
                               Matrix& mblock_dlos_grid,
                               Sparse& sensor_response,
                               Vector& sensor_response_f,
                               ArrayOfIndex& sensor_response_pol,
                               Matrix& sensor_response_dlos,
                               Vector& sensor_response_f_grid,
                               ArrayOfIndex& sensor_response_pol_grid,
                               Matrix& sensor_response_dlos_grid,
                               Index& sensor_norm,
                               // WS Input:
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               const Matrix& sensor_description_amsu,
                               // WS Generic Input:
                               const Numeric& spacing,
                               // Verbosity object:
                               const Verbosity& verbosity);


void sensor_responseGenericAMSU(// WS Output:
                                Vector& f_grid,
                                Index& antenna_dim,
                                Matrix& mblock_dlos_grid,
                                Sparse& sensor_response,
                                Vector& sensor_response_f,
                                ArrayOfIndex& sensor_response_pol,
                                Matrix& sensor_response_dlos,
                                Vector& sensor_response_f_grid,
                                ArrayOfIndex& sensor_response_pol_grid,
                                Matrix& sensor_response_dlos_grid,
                                Index& sensor_norm,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const Index& stokes_dim,
                                const Matrix& sensor_description_amsu,
                                // WS Generic Input:
                                const Numeric& spacing,
                                // Verbosity object:
                                const Verbosity& verbosity);


void sensor_responseWMRF(// WS Output:
                         Sparse& sensor_response,
                         Vector& sensor_response_f,
                         ArrayOfIndex& sensor_response_pol,
                         Matrix& sensor_response_dlos,
                         Vector& sensor_response_f_grid,
                         // WS Input:
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Matrix& sensor_response_dlos_grid,
                         const Sparse& wmrf_weights,
                         const Vector& f_backend,
                         // Verbosity object:
                         const Verbosity& verbosity);


void SetNumberOfThreads(// WS Generic Input:
                        const Index& nthreads,
                        // Verbosity object:
                        const Verbosity& verbosity);


void Sleep(// WS Generic Input:
           const Numeric& time,
           // Verbosity object:
           const Verbosity& verbosity);


void timeSleep(// WS Input:
               const Time& time,
               // Verbosity object:
               const Verbosity& verbosity);


void SparseSparseMultiply(// WS Generic Output:
                          Sparse& out,
                          // WS Generic Input:
                          const Sparse& m1,
                          const Sparse& m2,
                          // Verbosity object:
                          const Verbosity& verbosity);


void SparseMatrixIdentity(// WS Generic Output:
                          Sparse& out,
                          // WS Generic Input:
                          const Index& n,
                          const Numeric& value,
                          // Verbosity object:
                          const Verbosity& verbosity);


void spectral_irradiance_fieldFromSpectralRadianceField(// WS Output:
                                                        Tensor5& spectral_irradiance_field,
                                                        // WS Input:
                                                        const Tensor7& spectral_radiance_field,
                                                        const Vector& za_grid,
                                                        const Vector& aa_grid,
                                                        const Vector& za_grid_weights,
                                                        // Verbosity object:
                                                        const Verbosity& verbosity);


void spectral_radiance_fieldClearskyPlaneParallel(// Workspace reference:
                                                  Workspace& ws,
                                                  // WS Output:
                                                  Tensor7& spectral_radiance_field,
                                                  // WS Generic Output:
                                                  Tensor3& trans_field,
                                                  // WS Input:
                                                  const Agenda& propmat_clearsky_agenda,
                                                  const Agenda& water_p_eq_agenda,
                                                  const Agenda& iy_space_agenda,
                                                  const Agenda& iy_surface_agenda,
                                                  const Agenda& iy_cloudbox_agenda,
                                                  const Index& stokes_dim,
                                                  const Vector& f_grid,
                                                  const Index& atmosphere_dim,
                                                  const Vector& p_grid,
                                                  const Tensor3& z_field,
                                                  const Tensor3& t_field,
                                                  const EnergyLevelMap& nlte_field,
                                                  const Tensor4& vmr_field,
                                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                                  const Tensor3& wind_u_field,
                                                  const Tensor3& wind_v_field,
                                                  const Tensor3& wind_w_field,
                                                  const Tensor3& mag_u_field,
                                                  const Tensor3& mag_v_field,
                                                  const Tensor3& mag_w_field,
                                                  const Matrix& z_surface,
                                                  const Numeric& ppath_lmax,
                                                  const Numeric& rte_alonglos_v,
                                                  const Tensor3& surface_props_data,
                                                  const Vector& za_grid,
                                                  // WS Generic Input:
                                                  const Index& use_parallel_iy,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void spectral_radiance_fieldCopyCloudboxField(// WS Output:
                                              Tensor7& spectral_radiance_field,
                                              // WS Input:
                                              const Index& atmosphere_dim,
                                              const Vector& p_grid,
                                              const Index& cloudbox_on,
                                              const ArrayOfIndex& cloudbox_limits,
                                              const Tensor7& cloudbox_field,
                                              // Verbosity object:
                                              const Verbosity& verbosity);


void spectral_radiance_fieldExpandCloudboxField(// Workspace reference:
                                                Workspace& ws,
                                                // WS Output:
                                                Tensor7& spectral_radiance_field,
                                                // WS Input:
                                                const Agenda& propmat_clearsky_agenda,
                                                const Agenda& water_p_eq_agenda,
                                                const Agenda& iy_space_agenda,
                                                const Agenda& iy_surface_agenda,
                                                const Agenda& iy_cloudbox_agenda,
                                                const Index& stokes_dim,
                                                const Vector& f_grid,
                                                const Index& atmosphere_dim,
                                                const Vector& p_grid,
                                                const Tensor3& z_field,
                                                const Tensor3& t_field,
                                                const EnergyLevelMap& nlte_field,
                                                const Tensor4& vmr_field,
                                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                                const Tensor3& wind_u_field,
                                                const Tensor3& wind_v_field,
                                                const Tensor3& wind_w_field,
                                                const Tensor3& mag_u_field,
                                                const Tensor3& mag_v_field,
                                                const Tensor3& mag_w_field,
                                                const Matrix& z_surface,
                                                const Index& cloudbox_on,
                                                const ArrayOfIndex& cloudbox_limits,
                                                const Tensor7& cloudbox_field,
                                                const Numeric& ppath_lmax,
                                                const Numeric& rte_alonglos_v,
                                                const Tensor3& surface_props_data,
                                                const Vector& za_grid,
                                                // WS Generic Input:
                                                const Index& use_parallel_iy,
                                                // Verbosity object:
                                                const Verbosity& verbosity);


void specular_losCalc(// WS Output:
                      Vector& specular_los,
                      Vector& surface_normal,
                      // WS Input:
                      const Vector& rtp_pos,
                      const Vector& rtp_los,
                      const Index& atmosphere_dim,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const Vector& refellipsoid,
                      const Matrix& z_surface,
                      // WS Generic Input:
                      const Index& ignore_surface_slope,
                      // Verbosity object:
                      const Verbosity& verbosity);


void specular_losCalcNoTopography(// WS Output:
                                  Vector& specular_los,
                                  Vector& surface_normal,
                                  // WS Input:
                                  const Vector& rtp_pos,
                                  const Vector& rtp_los,
                                  const Index& atmosphere_dim,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void StringJoin(// WS Generic Output:
                String& out,
                // WS Generic Input:
                const String& in1,
                const String& in2,
                const String& in3,
                const String& in4,
                const String& in5,
                const String& in6,
                const String& in7,
                const String& in8,
                const String& in9,
                const String& in10,
                // Verbosity object:
                const Verbosity& verbosity);


void StringSet(// WS Generic Output:
               String& out,
               // WS Generic Input:
               const String& text,
               // Verbosity object:
               const Verbosity& verbosity);


void z_surfaceFromFileAndGrid(// WS Output:
                              Matrix& z_surface,
                              // WS Input:
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              // WS Generic Input:
                              const String& filename,
                              const Index& interp_order,
                              const Index& set_lowest_altitude_to_zero,
                              // Verbosity object:
                              const Verbosity& verbosity);


void z_surfaceConstantAltitude(// WS Output:
                               Matrix& z_surface,
                               // WS Input:
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               // WS Generic Input:
                               const Numeric& altitude,
                               // Verbosity object:
                               const Verbosity& verbosity);


void surfaceBlackbody(// WS Output:
                      Matrix& surface_los,
                      Tensor4& surface_rmatrix,
                      Matrix& surface_emission,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Vector& f_grid,
                      const Index& stokes_dim,
                      const Vector& rtp_pos,
                      const Vector& rtp_los,
                      const Numeric& surface_skin_t,
                      // Verbosity object:
                      const Verbosity& verbosity);


void surfaceFastem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   Matrix& surface_emission,
                   // WS Input:
                   const Index& atmosphere_dim,
                   const Index& stokes_dim,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const Numeric& surface_skin_t,
                   // WS Generic Input:
                   const Numeric& salinity,
                   const Numeric& wind_speed,
                   const Numeric& wind_direction,
                   const Vector& transmittance,
                   const Index& fastem_version,
                   // Verbosity object:
                   const Verbosity& verbosity);


void surfaceTessem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   Matrix& surface_emission,
                   // WS Input:
                   const Index& atmosphere_dim,
                   const Index& stokes_dim,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const Numeric& surface_skin_t,
                   const TessemNN& tessem_neth,
                   const TessemNN& tessem_netv,
                   // WS Generic Input:
                   const Numeric& salinity,
                   const Numeric& wind_speed,
                   // Verbosity object:
                   const Verbosity& verbosity);


void surfaceTelsem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   Matrix& surface_emission,
                   // WS Input:
                   const Index& atmosphere_dim,
                   const Index& stokes_dim,
                   const Vector& f_grid,
                   const Vector& lat_grid,
                   const Vector& lat_true,
                   const Vector& lon_true,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const Numeric& surface_skin_t,
                   // WS Generic Input:
                   const TelsemAtlas& atlas,
                   const Numeric& r_min,
                   const Numeric& r_max,
                   const Numeric& d_max,
                   // Verbosity object:
                   const Verbosity& verbosity);


void surfaceFlatRefractiveIndex(// WS Output:
                                Matrix& surface_los,
                                Tensor4& surface_rmatrix,
                                Matrix& surface_emission,
                                // WS Input:
                                const Vector& f_grid,
                                const Index& stokes_dim,
                                const Index& atmosphere_dim,
                                const Vector& rtp_pos,
                                const Vector& rtp_los,
                                const Vector& specular_los,
                                const Numeric& surface_skin_t,
                                const GriddedField3& surface_complex_refr_index,
                                // Verbosity object:
                                const Verbosity& verbosity);


void surfaceFlatReflectivity(// WS Output:
                             Matrix& surface_los,
                             Tensor4& surface_rmatrix,
                             Matrix& surface_emission,
                             // WS Input:
                             const Vector& f_grid,
                             const Index& stokes_dim,
                             const Index& atmosphere_dim,
                             const Vector& rtp_pos,
                             const Vector& rtp_los,
                             const Vector& specular_los,
                             const Numeric& surface_skin_t,
                             const Tensor3& surface_reflectivity,
                             // Verbosity object:
                             const Verbosity& verbosity);


void surfaceFlatRvRh(// WS Output:
                     Matrix& surface_los,
                     Tensor4& surface_rmatrix,
                     Matrix& surface_emission,
                     // WS Input:
                     const Vector& f_grid,
                     const Index& stokes_dim,
                     const Index& atmosphere_dim,
                     const Vector& rtp_pos,
                     const Vector& rtp_los,
                     const Vector& specular_los,
                     const Numeric& surface_skin_t,
                     const Matrix& surface_rv_rh,
                     // Verbosity object:
                     const Verbosity& verbosity);


void surfaceFlatScalarReflectivity(// WS Output:
                                   Matrix& surface_los,
                                   Tensor4& surface_rmatrix,
                                   Matrix& surface_emission,
                                   // WS Input:
                                   const Vector& f_grid,
                                   const Index& stokes_dim,
                                   const Index& atmosphere_dim,
                                   const Vector& rtp_pos,
                                   const Vector& rtp_los,
                                   const Vector& specular_los,
                                   const Numeric& surface_skin_t,
                                   const Vector& surface_scalar_reflectivity,
                                   // Verbosity object:
                                   const Verbosity& verbosity);


void surfaceLambertianSimple(// WS Output:
                             Matrix& surface_los,
                             Tensor4& surface_rmatrix,
                             Matrix& surface_emission,
                             // WS Input:
                             const Vector& f_grid,
                             const Index& stokes_dim,
                             const Index& atmosphere_dim,
                             const Vector& rtp_pos,
                             const Vector& rtp_los,
                             const Vector& surface_normal,
                             const Numeric& surface_skin_t,
                             const Vector& surface_scalar_reflectivity,
                             // WS Generic Input:
                             const Index& lambertian_nza,
                             const Numeric& za_pos,
                             // Verbosity object:
                             const Verbosity& verbosity);


void surfaceSemiSpecularBy3beams(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Numeric& surface_skin_t,
                                 Matrix& surface_los,
                                 Tensor4& surface_rmatrix,
                                 Matrix& surface_emission,
                                 // WS Input:
                                 const Index& atmosphere_dim,
                                 const Vector& f_grid,
                                 const Vector& rtp_pos,
                                 const Vector& rtp_los,
                                 const Agenda& surface_rtprop_sub_agenda,
                                 // WS Generic Input:
                                 const Numeric& specular_factor,
                                 const Numeric& dza,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


void surfaceSplitSpecularTo3beams(// WS Output:
                                  Matrix& surface_los,
                                  Tensor4& surface_rmatrix,
                                  // WS Input:
                                  const Index& atmosphere_dim,
                                  const Vector& rtp_pos,
                                  const Vector& rtp_los,
                                  // WS Generic Input:
                                  const Numeric& specular_factor,
                                  const Numeric& dza,
                                  // Verbosity object:
                                  const Verbosity& verbosity);


void surface_complex_refr_indexFromGriddedField5(// WS Output:
                                                 GriddedField3& surface_complex_refr_index,
                                                 // WS Input:
                                                 const Index& atmosphere_dim,
                                                 const Vector& lat_grid,
                                                 const Vector& lat_true,
                                                 const Vector& lon_true,
                                                 const Vector& rtp_pos,
                                                 // WS Generic Input:
                                                 const GriddedField5& complex_refr_index_field,
                                                 // Verbosity object:
                                                 const Verbosity& verbosity);


void surface_reflectivityFromGriddedField6(// WS Output:
                                           Tensor3& surface_reflectivity,
                                           // WS Input:
                                           const Index& stokes_dim,
                                           const Vector& f_grid,
                                           const Index& atmosphere_dim,
                                           const Vector& lat_grid,
                                           const Vector& lat_true,
                                           const Vector& lon_true,
                                           const Vector& rtp_pos,
                                           const Vector& rtp_los,
                                           // WS Generic Input:
                                           const GriddedField6& r_field,
                                           // Verbosity object:
                                           const Verbosity& verbosity);


void surface_rtpropCallAgendaX(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Numeric& surface_skin_t,
                               Matrix& surface_los,
                               Tensor4& surface_rmatrix,
                               Matrix& surface_emission,
                               // WS Input:
                               const Vector& f_grid,
                               const Vector& rtp_pos,
                               const Vector& rtp_los,
                               const ArrayOfAgenda& surface_rtprop_agenda_array,
                               const Index& surface_type,
                               const Numeric& surface_type_aux,
                               // Verbosity object:
                               const Verbosity& verbosity);


void surface_scalar_reflectivityFromGriddedField4(// WS Output:
                                                  Vector& surface_scalar_reflectivity,
                                                  // WS Input:
                                                  const Index& stokes_dim,
                                                  const Vector& f_grid,
                                                  const Index& atmosphere_dim,
                                                  const Vector& lat_grid,
                                                  const Vector& lat_true,
                                                  const Vector& lon_true,
                                                  const Vector& rtp_pos,
                                                  const Vector& rtp_los,
                                                  // WS Generic Input:
                                                  const GriddedField4& r_field,
                                                  // Verbosity object:
                                                  const Verbosity& verbosity);


void surface_scalar_reflectivityFromSurface_rmatrix(// WS Output:
                                                    Vector& surface_scalar_reflectivity,
                                                    // WS Input:
                                                    const Tensor4& surface_rmatrix,
                                                    // Verbosity object:
                                                    const Verbosity& verbosity);


void surface_typeInterpTypeMask(// WS Output:
                                Index& surface_type,
                                Numeric& surface_type_aux,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const Vector& lat_grid,
                                const Vector& lat_true,
                                const Vector& lon_true,
                                const Vector& rtp_pos,
                                const GriddedField2& surface_type_mask,
                                // Verbosity object:
                                const Verbosity& verbosity);


void SurfaceDummy(// WS Output:
                  ArrayOfTensor4& dsurface_rmatrix_dx,
                  ArrayOfMatrix& dsurface_emission_dx,
                  // WS Input:
                  const Index& atmosphere_dim,
                  const Vector& lat_grid,
                  const Vector& lon_grid,
                  const Tensor3& surface_props_data,
                  const ArrayOfString& surface_props_names,
                  const ArrayOfString& dsurface_names,
                  const Index& jacobian_do,
                  // Verbosity object:
                  const Verbosity& verbosity);


void SurfaceFastem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   ArrayOfTensor4& dsurface_rmatrix_dx,
                   Matrix& surface_emission,
                   ArrayOfMatrix& dsurface_emission_dx,
                   // WS Input:
                   const Index& stokes_dim,
                   const Index& atmosphere_dim,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const Tensor3& surface_props_data,
                   const ArrayOfString& surface_props_names,
                   const ArrayOfString& dsurface_names,
                   const Index& jacobian_do,
                   // WS Generic Input:
                   const Vector& transmittance,
                   const Index& fastem_version,
                   // Verbosity object:
                   const Verbosity& verbosity);


void SurfaceTessem(// WS Output:
                   Matrix& surface_los,
                   Tensor4& surface_rmatrix,
                   ArrayOfTensor4& dsurface_rmatrix_dx,
                   Matrix& surface_emission,
                   ArrayOfMatrix& dsurface_emission_dx,
                   // WS Input:
                   const Index& stokes_dim,
                   const Index& atmosphere_dim,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const Vector& f_grid,
                   const Vector& rtp_pos,
                   const Vector& rtp_los,
                   const TessemNN& tessem_neth,
                   const TessemNN& tessem_netv,
                   const Tensor3& surface_props_data,
                   const ArrayOfString& surface_props_names,
                   const ArrayOfString& dsurface_names,
                   const Index& jacobian_do,
                   // Verbosity object:
                   const Verbosity& verbosity);


void TangentPointExtract(// WS Generic Output:
                         Vector& tan_pos,
                         // WS Input:
                         const Ppath& ppath,
                         // Verbosity object:
                         const Verbosity& verbosity);


void TangentPointPrint(// WS Input:
                       const Ppath& ppath,
                       // WS Generic Input:
                       const Index& level,
                       // Verbosity object:
                       const Verbosity& verbosity);


void telsemStandalone(// WS Generic Output:
                      Matrix& emissivities,
                      // WS Generic Input:
                      const Numeric& lat,
                      const Numeric& lon,
                      const Numeric& theta,
                      const Vector& f,
                      const TelsemAtlas& ta,
                      const Numeric& d_max,
                      // Verbosity object:
                      const Verbosity& verbosity);


void telsemAtlasLookup(// WS Generic Output:
                       Vector& emissivities,
                       // WS Generic Input:
                       const Numeric& lat,
                       const Numeric& lon,
                       const TelsemAtlas& atlas,
                       // Verbosity object:
                       const Verbosity& verbosity);


void telsemSurfaceTypeLandSea(// WS Output:
                              Index& surface_type,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& lat_grid,
                              const Vector& lat_true,
                              const Vector& lon_true,
                              const Vector& rtp_pos,
                              // WS Generic Input:
                              const TelsemAtlas& atlas,
                              // Verbosity object:
                              const Verbosity& verbosity);


void telsem_atlasReadAscii(// WS Generic Output:
                           TelsemAtlas& atlas,
                           // WS Generic Input:
                           const String& directory,
                           const Index& month,
                           const String& filename_pattern,
                           // Verbosity object:
                           const Verbosity& verbosity);


void telsem_atlasesReadAscii(// WS Output:
                             ArrayOfTelsemAtlas& telsem_atlases,
                             // WS Generic Input:
                             const String& directory,
                             const String& filename_pattern,
                             // Verbosity object:
                             const Verbosity& verbosity);


void Tensor3AddScalar(// WS Generic Output:
                      Tensor3& out,
                      // WS Generic Input:
                      const Tensor3& in,
                      const Numeric& value,
                      // Verbosity object:
                      const Verbosity& verbosity);


void Tensor3ExtractFromTensor4(// WS Generic Output:
                               Tensor3& out,
                               // WS Generic Input:
                               const Tensor4& in,
                               const Index& i,
                               const String& direction,
                               // Verbosity object:
                               const Verbosity& verbosity);


void Tensor3Scale(// WS Generic Output:
                  Tensor3& out,
                  // WS Generic Input:
                  const Tensor3& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void Tensor3SetConstant(// WS Generic Output:
                        Tensor3& out,
                        // WS Input:
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void Tensor4AddScalar(// WS Generic Output:
                      Tensor4& out,
                      // WS Generic Input:
                      const Tensor4& in,
                      const Numeric& value,
                      // Verbosity object:
                      const Verbosity& verbosity);


void Tensor4Scale(// WS Generic Output:
                  Tensor4& out,
                  // WS Generic Input:
                  const Tensor4& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void Tensor4SetConstant(// WS Generic Output:
                        Tensor4& out,
                        // WS Input:
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void Tensor5Scale(// WS Generic Output:
                  Tensor5& out,
                  // WS Generic Input:
                  const Tensor5& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void Tensor5SetConstant(// WS Generic Output:
                        Tensor5& out,
                        // WS Input:
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void Tensor6Scale(// WS Generic Output:
                  Tensor6& out,
                  // WS Generic Input:
                  const Tensor6& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void Tensor6SetConstant(// WS Generic Output:
                        Tensor6& out,
                        // WS Input:
                        const Index& nvitrines,
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void Tensor7Scale(// WS Generic Output:
                  Tensor7& out,
                  // WS Generic Input:
                  const Tensor7& in,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);


void Tensor7SetConstant(// WS Generic Output:
                        Tensor7& out,
                        // WS Input:
                        const Index& nlibraries,
                        const Index& nvitrines,
                        const Index& nshelves,
                        const Index& nbooks,
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);


void TestArrayOfAgenda(// Workspace reference:
                       Workspace& ws,
                       // WS Input:
                       const ArrayOfAgenda& test_agenda_array,
                       // WS Generic Input:
                       const Index& index,
                       // Verbosity object:
                       const Verbosity& verbosity);


void TessemNNReadAscii(// WS Generic Output:
                       TessemNN& tessem_nn,
                       // WS Generic Input:
                       const String& filename,
                       // Verbosity object:
                       const Verbosity& verbosity);


void TestTessem(// WS Generic Output:
                Vector& outvalues,
                // WS Generic Input:
                const TessemNN& net,
                const Vector& invalues,
                // Verbosity object:
                const Verbosity& verbosity);


void Test(// Verbosity object:
          const Verbosity& verbosity);


void time_gridOffset(// WS Output:
                     ArrayOfTime& time_grid,
                     // WS Generic Input:
                     const Numeric& dt,
                     // Verbosity object:
                     const Verbosity& verbosity);


void timerStart(// WS Output:
                Timer& timer,
                // Verbosity object:
                const Verbosity& verbosity);


void timerStop(// WS Output:
               Timer& timer,
               // Verbosity object:
               const Verbosity& verbosity);


void time_stampsSort(// WS Generic Output:
                     ArrayOfTime& out,
                     // WS Input:
                     const ArrayOfTime& time_stamps,
                     // WS Generic Input:
                     const ArrayOfTime& in,
                     // Verbosity object:
                     const Verbosity& verbosity);


void time_stampsSort(// WS Generic Output:
                     ArrayOfVector& out,
                     // WS Input:
                     const ArrayOfTime& time_stamps,
                     // WS Generic Input:
                     const ArrayOfVector& in,
                     // Verbosity object:
                     const Verbosity& verbosity);


void TMatrixTest(// Verbosity object:
                 const Verbosity& verbosity);


void transmittanceFromIy_aux(// WS Generic Output:
                             Vector& transmittance,
                             // WS Input:
                             const ArrayOfString& iy_aux_vars,
                             const ArrayOfMatrix& iy_aux,
                             // Verbosity object:
                             const Verbosity& verbosity);


void VectorAddScalar(// WS Generic Output:
                     Vector& out,
                     // WS Generic Input:
                     const Vector& in,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);


void VectorAddVector(// WS Generic Output:
                     Vector& c,
                     // WS Generic Input:
                     const Vector& a,
                     const Vector& b,
                     // Verbosity object:
                     const Verbosity& verbosity);


void VectorCrop(// WS Generic Output:
                Vector& out,
                // WS Generic Input:
                const Vector& in,
                const Numeric& min_value,
                const Numeric& max_value,
                // Verbosity object:
                const Verbosity& verbosity);


void VectorExtractFromMatrix(// WS Generic Output:
                             Vector& out,
                             // WS Generic Input:
                             const Matrix& in,
                             const Index& i,
                             const String& direction,
                             // Verbosity object:
                             const Verbosity& verbosity);


void VectorFlip(// WS Generic Output:
                Vector& out,
                // WS Generic Input:
                const Vector& in,
                // Verbosity object:
                const Verbosity& verbosity);


void VectorInsertGridPoints(// WS Generic Output:
                            Vector& out,
                            // WS Generic Input:
                            const Vector& in,
                            const Vector& points,
                            // Verbosity object:
                            const Verbosity& verbosity);


void VectorLinSpace(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);


void VectorLogSpace(// WS Generic Output:
                    Vector& out,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);


void VectorMatrixMultiply(// WS Generic Output:
                          Vector& out,
                          // WS Generic Input:
                          const Matrix& m,
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);


void VectorNLinSpace(// WS Generic Output:
                     Vector& out,
                     // WS Input:
                     const Index& nelem,
                     // WS Generic Input:
                     const Numeric& start,
                     const Numeric& stop,
                     // Verbosity object:
                     const Verbosity& verbosity);


void VectorNLogSpace(// WS Generic Output:
                     Vector& out,
                     // WS Input:
                     const Index& nelem,
                     // WS Generic Input:
                     const Numeric& start,
                     const Numeric& stop,
                     // Verbosity object:
                     const Verbosity& verbosity);


void VectorReshapeMatrix(// WS Generic Output:
                         Vector& out,
                         // WS Generic Input:
                         const Matrix& in,
                         const String& direction,
                         // Verbosity object:
                         const Verbosity& verbosity);


void VectorScale(// WS Generic Output:
                 Vector& out,
                 // WS Generic Input:
                 const Vector& in,
                 const Numeric& value,
                 // Verbosity object:
                 const Verbosity& verbosity);


void VectorSetConstant(// WS Generic Output:
                       Vector& out,
                       // WS Input:
                       const Index& nelem,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);


void VectorSet(// WS Generic Output:
               Vector& out,
               // WS Generic Input:
               const Vector& value,
               // Verbosity object:
               const Verbosity& verbosity);


void VectorSubtractVector(// WS Generic Output:
                          Vector& c,
                          // WS Generic Input:
                          const Vector& a,
                          const Vector& b,
                          // Verbosity object:
                          const Verbosity& verbosity);


void VectorVectorMultiply(// WS Generic Output:
                          Vector& out,
                          // WS Generic Input:
                          const Vector& v1,
                          const Vector& v2,
                          // Verbosity object:
                          const Verbosity& verbosity);


void VectorZtanToZaRefr1D(// Workspace reference:
                          Workspace& ws,
                          // WS Generic Output:
                          Vector& v_za,
                          // WS Input:
                          const Agenda& refr_index_air_agenda,
                          const Matrix& sensor_pos,
                          const Vector& p_grid,
                          const Tensor3& t_field,
                          const Tensor3& z_field,
                          const Tensor4& vmr_field,
                          const Vector& refellipsoid,
                          const Index& atmosphere_dim,
                          const Vector& f_grid,
                          // WS Generic Input:
                          const Vector& v_ztan,
                          // Verbosity object:
                          const Verbosity& verbosity);


void VectorZtanToZa1D(// WS Generic Output:
                      Vector& v_za,
                      // WS Input:
                      const Matrix& sensor_pos,
                      const Vector& refellipsoid,
                      const Index& atmosphere_dim,
                      // WS Generic Input:
                      const Vector& v_ztan,
                      // Verbosity object:
                      const Verbosity& verbosity);


void verbosityInit(// WS Output:
                   Verbosity& verbosity);


void verbositySet(// WS Output:
                  Verbosity& verbosity,
                  // WS Generic Input:
                  const Index& agenda,
                  const Index& screen,
                  const Index& file);


void verbositySetAgenda(// WS Output:
                        Verbosity& verbosity,
                        // WS Generic Input:
                        const Index& level);


void verbositySetFile(// WS Output:
                      Verbosity& verbosity,
                      // WS Generic Input:
                      const Index& level);


void verbositySetScreen(// WS Output:
                        Verbosity& verbosity,
                        // WS Generic Input:
                        const Index& level);


void vmr_fieldClip(// WS Output:
                   Tensor4& vmr_field,
                   // WS Input:
                   const ArrayOfArrayOfSpeciesTag& abs_species,
                   // WS Generic Input:
                   const String& species,
                   const Numeric& limit_low,
                   const Numeric& limit_high,
                   // Verbosity object:
                   const Verbosity& verbosity);


void vmr_fieldPerturb(// WS Output:
                      Tensor4& vmr_field,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      // WS Generic Input:
                      const String& species,
                      const Vector& p_ret_grid,
                      const Vector& lat_ret_grid,
                      const Vector& lon_ret_grid,
                      const Index& pert_index,
                      const Numeric& pert_size,
                      const String& pert_mode,
                      // Verbosity object:
                      const Verbosity& verbosity);


void vmr_fieldPerturbAtmGrids(// WS Output:
                              Tensor4& vmr_field,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const Vector& p_grid,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              const ArrayOfArrayOfSpeciesTag& abs_species,
                              // WS Generic Input:
                              const String& species,
                              const Index& pert_index,
                              const Numeric& pert_size,
                              const String& pert_mode,
                              // Verbosity object:
                              const Verbosity& verbosity);


void vmr_fieldSetAllConstant(// WS Output:
                             Tensor4& vmr_field,
                             // WS Input:
                             const ArrayOfArrayOfSpeciesTag& abs_species,
                             // WS Generic Input:
                             const Vector& vmr_values,
                             // Verbosity object:
                             const Verbosity& verbosity);


void water_p_eq_fieldMK05(// WS Output:
                          Tensor3& water_p_eq_field,
                          // WS Input:
                          const Tensor3& t_field,
                          // Verbosity object:
                          const Verbosity& verbosity);


void vmr_fieldSetConstant(// WS Output:
                          Tensor4& vmr_field,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          // WS Generic Input:
                          const String& species,
                          const Numeric& vmr_value,
                          // Verbosity object:
                          const Verbosity& verbosity);


void Wigner6Init(// WS Output:
                 Index& wigner_initialized,
                 // WS Generic Input:
                 const Index& fast_wigner_stored_symbols,
                 const Index& largest_wigner_symbol_parameter,
                 // Verbosity object:
                 const Verbosity& verbosity);


void Wigner3Init(// WS Output:
                 Index& wigner_initialized,
                 // WS Generic Input:
                 const Index& fast_wigner_stored_symbols,
                 const Index& largest_wigner_symbol_parameter,
                 // Verbosity object:
                 const Verbosity& verbosity);


void Wigner6Unload(// WS Output:
                   Index& wigner_initialized,
                   // Verbosity object:
                   const Verbosity& verbosity);


void Wigner3Unload(// WS Output:
                   Index& wigner_initialized,
                   // Verbosity object:
                   const Verbosity& verbosity);


void WignerFastInfoPrint(// WS Input:
                         const Index& wigner_initialized,
                         // Verbosity object:
                         const Verbosity& verbosity);


void WindFieldsCalc(// WS Output:
                    Tensor3& wind_u_field,
                    Tensor3& wind_v_field,
                    Tensor3& wind_w_field,
                    // WS Input:
                    const Vector& p_grid,
                    const Vector& lat_grid,
                    const Vector& lon_grid,
                    const GriddedField3& wind_u_field_raw,
                    const GriddedField3& wind_v_field_raw,
                    const GriddedField3& wind_w_field_raw,
                    const Index& atmosphere_dim,
                    // WS Generic Input:
                    const Index& interp_order,
                    // Verbosity object:
                    const Verbosity& verbosity);


void WindFieldsCalcExpand1D(// WS Output:
                            Tensor3& wind_u_field,
                            Tensor3& wind_v_field,
                            Tensor3& wind_w_field,
                            // WS Input:
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const GriddedField3& wind_u_field_raw,
                            const GriddedField3& wind_v_field_raw,
                            const GriddedField3& wind_w_field_raw,
                            const Index& atmosphere_dim,
                            // WS Generic Input:
                            const Index& interp_order,
                            // Verbosity object:
                            const Verbosity& verbosity);


void WindRawRead(// WS Output:
                 GriddedField3& wind_u_field_raw,
                 GriddedField3& wind_v_field_raw,
                 GriddedField3& wind_w_field_raw,
                 // WS Generic Input:
                 const String& basename,
                 // Verbosity object:
                 const Verbosity& verbosity);


void wind_u_fieldIncludePlanetRotation(// WS Output:
                                       Tensor3& wind_u_field,
                                       // WS Input:
                                       const Index& atmosphere_dim,
                                       const Vector& p_grid,
                                       const Vector& lat_grid,
                                       const Vector& lon_grid,
                                       const Vector& refellipsoid,
                                       const Tensor3& z_field,
                                       const Numeric& planet_rotation_period,
                                       // Verbosity object:
                                       const Verbosity& verbosity);


void WMRFSelectChannels(// WS Output:
                        Vector& f_grid,
                        Sparse& wmrf_weights,
                        Vector& f_backend,
                        // WS Input:
                        const ArrayOfIndex& wmrf_channels,
                        // Verbosity object:
                        const Verbosity& verbosity);


void WriteMolTau(// WS Input:
                 const Vector& f_grid,
                 const Tensor3& z_field,
                 const Tensor7& propmat_clearsky_field,
                 const Index& atmosphere_dim,
                 // WS Generic Input:
                 const String& filename,
                 // Verbosity object:
                 const Verbosity& verbosity);


void xaStandard(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Vector& xa,
                // WS Input:
                const ArrayOfRetrievalQuantity& jacobian_quantities,
                const Index& atmfields_checked,
                const Index& atmgeom_checked,
                const Index& atmosphere_dim,
                const Vector& p_grid,
                const Vector& lat_grid,
                const Vector& lon_grid,
                const Tensor3& t_field,
                const Tensor4& vmr_field,
                const ArrayOfArrayOfSpeciesTag& abs_species,
                const Index& cloudbox_on,
                const Index& cloudbox_checked,
                const Tensor4& particle_bulkprop_field,
                const ArrayOfString& particle_bulkprop_names,
                const Tensor3& wind_u_field,
                const Tensor3& wind_v_field,
                const Tensor3& wind_w_field,
                const Tensor3& mag_u_field,
                const Tensor3& mag_v_field,
                const Tensor3& mag_w_field,
                const Tensor3& surface_props_data,
                const ArrayOfString& surface_props_names,
                const Agenda& water_p_eq_agenda,
                // Verbosity object:
                const Verbosity& verbosity);


void xClip(// WS Output:
           Vector& x,
           // WS Input:
           const ArrayOfRetrievalQuantity& jacobian_quantities,
           // WS Generic Input:
           const Index& ijq,
           const Numeric& limit_low,
           const Numeric& limit_high,
           // Verbosity object:
           const Verbosity& verbosity);


void x2artsAtmAndSurf(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      Tensor4& vmr_field,
                      Tensor3& t_field,
                      Tensor4& particle_bulkprop_field,
                      Tensor3& wind_u_field,
                      Tensor3& wind_v_field,
                      Tensor3& wind_w_field,
                      Tensor3& mag_u_field,
                      Tensor3& mag_v_field,
                      Tensor3& mag_w_field,
                      Tensor3& surface_props_data,
                      // WS Input:
                      const ArrayOfRetrievalQuantity& jacobian_quantities,
                      const Vector& x,
                      const Index& atmfields_checked,
                      const Index& atmgeom_checked,
                      const Index& atmosphere_dim,
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      const Index& cloudbox_on,
                      const Index& cloudbox_checked,
                      const ArrayOfString& particle_bulkprop_names,
                      const ArrayOfString& surface_props_names,
                      const Agenda& water_p_eq_agenda,
                      // Verbosity object:
                      const Verbosity& verbosity);


void x2artsSensor(// Workspace reference:
                  Workspace& ws,
                  // WS Output:
                  Matrix& sensor_los,
                  Vector& f_backend,
                  Vector& y_baseline,
                  Sparse& sensor_response,
                  Vector& sensor_response_f,
                  ArrayOfIndex& sensor_response_pol,
                  Matrix& sensor_response_dlos,
                  Vector& sensor_response_f_grid,
                  ArrayOfIndex& sensor_response_pol_grid,
                  Matrix& sensor_response_dlos_grid,
                  Matrix& mblock_dlos_grid,
                  // WS Input:
                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                  const Vector& x,
                  const Agenda& sensor_response_agenda,
                  const Index& sensor_checked,
                  const Vector& sensor_time,
                  // Verbosity object:
                  const Verbosity& verbosity);


void x2artsSpectroscopy(// Verbosity object:
                        const Verbosity& verbosity);


void yApplySensorPol(// WS Output:
                     Vector& y,
                     Vector& y_f,
                     ArrayOfIndex& y_pol,
                     Matrix& y_pos,
                     Matrix& y_los,
                     ArrayOfVector& y_aux,
                     Matrix& y_geo,
                     Matrix& jacobian,
                     // WS Input:
                     const Index& stokes_dim,
                     const Index& jacobian_do,
                     const Matrix& sensor_pos,
                     const Matrix& sensor_pol,
                     // Verbosity object:
                     const Verbosity& verbosity);


void yApplyUnit(// WS Output:
                Vector& y,
                Matrix& jacobian,
                // WS Input:
                const Vector& y_f,
                const ArrayOfIndex& y_pol,
                const String& iy_unit,
                // Verbosity object:
                const Verbosity& verbosity);


void ybatchCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                ArrayOfVector& ybatch,
                ArrayOfArrayOfVector& ybatch_aux,
                ArrayOfMatrix& ybatch_jacobians,
                // WS Input:
                const Index& ybatch_start,
                const Index& ybatch_n,
                const Agenda& ybatch_calc_agenda,
                // WS Generic Input:
                const Index& robust,
                // Verbosity object:
                const Verbosity& verbosity);


void yColdAtmHot(// WS Output:
                 Vector& y,
                 // WS Generic Input:
                 const Vector& cold,
                 const Vector& atm,
                 const Vector& hot,
                 const Numeric& cold_temp,
                 const Numeric& hot_temp,
                 const Index& calib,
                 // Verbosity object:
                 const Verbosity& verbosity);


void ybatchMetProfiles(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       ArrayOfVector& ybatch,
                       // WS Input:
                       const ArrayOfArrayOfSpeciesTag& abs_species,
                       const Agenda& met_profile_calc_agenda,
                       const Vector& f_grid,
                       const Matrix& met_amsu_data,
                       const Matrix& sensor_pos,
                       const Vector& refellipsoid,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Index& atmosphere_dim,
                       const ArrayOfArrayOfSingleScatteringData& scat_data,
                       // WS Generic Input:
                       const Index& nelem_p_grid,
                       const String& met_profile_path,
                       const String& met_profile_pnd_path,
                       // Verbosity object:
                       const Verbosity& verbosity);


void ybatchMetProfilesClear(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfVector& ybatch,
                            // WS Input:
                            const ArrayOfArrayOfSpeciesTag& abs_species,
                            const Agenda& met_profile_calc_agenda,
                            const Vector& f_grid,
                            const Matrix& met_amsu_data,
                            const Matrix& sensor_pos,
                            const Vector& refellipsoid,
                            // WS Generic Input:
                            const Index& nelem_p_grid,
                            const String& met_profile_path,
                            // Verbosity object:
                            const Verbosity& verbosity);


void ybatchTimeAveraging(// WS Output:
                         ArrayOfVector& ybatch,
                         ArrayOfTime& time_grid,
                         ArrayOfMatrix& covmat_sepsbatch,
                         ArrayOfIndex& counts,
                         // WS Generic Input:
                         const String& time_step,
                         const Index& disregard_first,
                         const Index& disregard_last,
                         // Verbosity object:
                         const Verbosity& verbosity);


void ybatchTroposphericCorrectionNaiveMedianForward(// WS Output:
                                                    ArrayOfVector& ybatch_corr,
                                                    ArrayOfVector& ybatch,
                                                    // WS Generic Input:
                                                    const ArrayOfIndex& range,
                                                    const Vector& trop_temp,
                                                    const Numeric& targ_temp,
                                                    // Verbosity object:
                                                    const Verbosity& verbosity);


void ybatchTroposphericCorrectionNaiveMedianInverse(// WS Output:
                                                    ArrayOfVector& ybatch,
                                                    // WS Input:
                                                    const ArrayOfVector& ybatch_corr,
                                                    // Verbosity object:
                                                    const Verbosity& verbosity);


void yCalc(// Workspace reference:
           Workspace& ws,
           // WS Output:
           Vector& y,
           Vector& y_f,
           ArrayOfIndex& y_pol,
           Matrix& y_pos,
           Matrix& y_los,
           ArrayOfVector& y_aux,
           Matrix& y_geo,
           Matrix& jacobian,
           // WS Input:
           const Index& atmgeom_checked,
           const Index& atmfields_checked,
           const Index& atmosphere_dim,
           const EnergyLevelMap& nlte_field,
           const Index& cloudbox_on,
           const Index& cloudbox_checked,
           const Index& scat_data_checked,
           const Index& sensor_checked,
           const Index& stokes_dim,
           const Vector& f_grid,
           const Matrix& sensor_pos,
           const Matrix& sensor_los,
           const Matrix& transmitter_pos,
           const Matrix& mblock_dlos_grid,
           const Sparse& sensor_response,
           const Vector& sensor_response_f,
           const ArrayOfIndex& sensor_response_pol,
           const Matrix& sensor_response_dlos,
           const String& iy_unit,
           const Agenda& iy_main_agenda,
           const Agenda& geo_pos_agenda,
           const Agenda& jacobian_agenda,
           const Index& jacobian_do,
           const ArrayOfRetrievalQuantity& jacobian_quantities,
           const ArrayOfString& iy_aux_vars,
           // Verbosity object:
           const Verbosity& verbosity);


void yCalcAppend(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 Vector& y,
                 Vector& y_f,
                 ArrayOfIndex& y_pol,
                 Matrix& y_pos,
                 Matrix& y_los,
                 ArrayOfVector& y_aux,
                 Matrix& y_geo,
                 Matrix& jacobian,
                 ArrayOfRetrievalQuantity& jacobian_quantities,
                 // WS Input:
                 const Index& atmgeom_checked,
                 const Index& atmfields_checked,
                 const Index& atmosphere_dim,
                 const EnergyLevelMap& nlte_field,
                 const Index& cloudbox_on,
                 const Index& cloudbox_checked,
                 const Index& scat_data_checked,
                 const Index& sensor_checked,
                 const Index& stokes_dim,
                 const Vector& f_grid,
                 const Matrix& sensor_pos,
                 const Matrix& sensor_los,
                 const Matrix& transmitter_pos,
                 const Matrix& mblock_dlos_grid,
                 const Sparse& sensor_response,
                 const Vector& sensor_response_f,
                 const ArrayOfIndex& sensor_response_pol,
                 const Matrix& sensor_response_dlos,
                 const String& iy_unit,
                 const Agenda& iy_main_agenda,
                 const Agenda& geo_pos_agenda,
                 const Agenda& jacobian_agenda,
                 const Index& jacobian_do,
                 const ArrayOfString& iy_aux_vars,
                 // WS Generic Input:
                 const ArrayOfRetrievalQuantity& jacobian_quantities_copy,
                 const Index& append_instrument_wfs,
                 // Verbosity object:
                 const Verbosity& verbosity);


void yActive(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Vector& y,
             Vector& y_f,
             ArrayOfIndex& y_pol,
             Matrix& y_pos,
             Matrix& y_los,
             ArrayOfVector& y_aux,
             Matrix& y_geo,
             Matrix& jacobian,
             // WS Input:
             const Index& atmgeom_checked,
             const Index& atmfields_checked,
             const String& iy_unit,
             const ArrayOfString& iy_aux_vars,
             const Index& stokes_dim,
             const Vector& f_grid,
             const Index& atmosphere_dim,
             const EnergyLevelMap& nlte_field,
             const Index& cloudbox_on,
             const Index& cloudbox_checked,
             const Matrix& sensor_pos,
             const Matrix& sensor_los,
             const Index& sensor_checked,
             const Index& jacobian_do,
             const ArrayOfRetrievalQuantity& jacobian_quantities,
             const Agenda& iy_main_agenda,
             const Agenda& geo_pos_agenda,
             const ArrayOfArrayOfIndex& instrument_pol_array,
             const Vector& range_bins,
             // WS Generic Input:
             const Numeric& ze_tref,
             const Numeric& k2,
             const Numeric& dbze_min,
             // Verbosity object:
             const Verbosity& verbosity);


void ySimpleSpectrometer(// WS Output:
                         Vector& y,
                         Vector& y_f,
                         // WS Input:
                         const Matrix& iy,
                         const Index& stokes_dim,
                         const Vector& f_grid,
                         // WS Generic Input:
                         const Numeric& df,
                         // Verbosity object:
                         const Verbosity& verbosity);


void z_fieldFromHSE(// Workspace reference:
                    Workspace& ws,
                    // WS Output:
                    Tensor3& z_field,
                    // WS Input:
                    const Index& atmosphere_dim,
                    const Vector& p_grid,
                    const Vector& lat_grid,
                    const Vector& lon_grid,
                    const Vector& lat_true,
                    const Vector& lon_true,
                    const ArrayOfArrayOfSpeciesTag& abs_species,
                    const Tensor3& t_field,
                    const Tensor4& vmr_field,
                    const Vector& refellipsoid,
                    const Matrix& z_surface,
                    const Index& atmfields_checked,
                    const Agenda& g0_agenda,
                    const Numeric& molarmass_dry_air,
                    const Numeric& p_hse,
                    const Numeric& z_hse_accuracy,
                    // Verbosity object:
                    const Verbosity& verbosity);

// Supergeneric template function declarations:


template <typename T>
void Append(// WS Generic Output:
            T& out,
            // WS Generic Output Names:
            const String& out_wsvname,
            // WS Generic Input:
            const T& in,
            const String& dimension,
            // WS Generic Input Names:
            const String& in_wsvname,
            const String& dimension_wsvname,
            // Verbosity object:
            const Verbosity& verbosity);


template <typename T>
void ArrayOfGriddedFieldGetNames(// WS Generic Output:
                                 ArrayOfString& names,
                                 // WS Generic Input:
                                 const T& griddedfields,
                                 // Verbosity object:
                                 const Verbosity& verbosity);


template <typename T>
void Copy(// WS Generic Output:
          T& out,
          // WS Generic Output Names:
          const String& out_wsvname,
          // WS Generic Input:
          const T& in,
          // WS Generic Input Names:
          const String& in_wsvname,
          // Verbosity object:
          const Verbosity& verbosity);


template <typename T>
void covmat1D(// WS Generic Output:
              T& out,
              // WS Generic Input:
              const Vector& grid_1,
              const Vector& grid_2,
              const Vector& sigma_1,
              const Vector& sigma_2,
              const Vector& cls_1,
              const Vector& cls_2,
              const Numeric& co,
              const String& fname,
              // Verbosity object:
              const Verbosity& verbosity);


template <typename T>
void covmat1DMarkov(// WS Generic Output:
                    T& out,
                    T& out_inverse,
                    // WS Generic Input:
                    const Vector& grid,
                    const Vector& sigma,
                    const Numeric& lc,
                    const Numeric& co,
                    // Verbosity object:
                    const Verbosity& verbosity);


template <typename T>
void covmatDiagonal(// WS Generic Output:
                    T& out,
                    T& out_inverse,
                    // WS Generic Input:
                    const Vector& vars,
                    // Verbosity object:
                    const Verbosity& verbosity);


template <typename T>
void covmat_seAddBlock(// WS Output:
                       CovarianceMatrix& covmat_se,
                       // WS Generic Input:
                       const T& block,
                       const Index& i,
                       const Index& j,
                       // Verbosity object:
                       const Verbosity& verbosity);


template <typename T>
void covmat_seAddInverseBlock(// WS Output:
                              CovarianceMatrix& covmat_se,
                              // WS Generic Input:
                              const T& block,
                              const Index& i,
                              const Index& j,
                              // Verbosity object:
                              const Verbosity& verbosity);


template <typename T>
void covmat_seSet(// WS Output:
                  CovarianceMatrix& covmat_se,
                  // WS Generic Input:
                  const T& covmat,
                  // Verbosity object:
                  const Verbosity& verbosity);


template <typename T>
void covmat_sxSet(// WS Output:
                  CovarianceMatrix& covmat_sx,
                  // WS Generic Input:
                  const T& covmat,
                  // Verbosity object:
                  const Verbosity& verbosity);


template <typename T>
void covmat_sxAddBlock(// WS Output:
                       CovarianceMatrix& covmat_sx,
                       // WS Input:
                       const ArrayOfRetrievalQuantity& jacobian_quantities,
                       // WS Generic Input:
                       const T& block,
                       const Index& i,
                       const Index& j,
                       // Verbosity object:
                       const Verbosity& verbosity);


template <typename T>
void covmat_sxAddInverseBlock(// WS Output:
                              CovarianceMatrix& covmat_sx,
                              // WS Input:
                              const ArrayOfRetrievalQuantity& jacobian_quantities,
                              // WS Generic Input:
                              const T& block,
                              const Index& i,
                              const Index& j,
                              // Verbosity object:
                              const Verbosity& verbosity);


template <typename T>
void Delete(// Workspace reference:
            Workspace& ws,
            // WS Generic Input:
            const T& v,
            // WS Generic Input Names:
            const String& v_wsvname,
            // Verbosity object:
            const Verbosity& verbosity);


template <typename T>
void Extract(// WS Generic Output:
             T& needle,
             // WS Generic Input:
             const T& haystack,
             const Index& index,
             // Verbosity object:
             const Verbosity& verbosity);


template <typename T>
void GriddedFieldGetName(// WS Generic Output:
                         String& name,
                         // WS Generic Input:
                         const T& griddedfield,
                         // Verbosity object:
                         const Verbosity& verbosity);


template <typename T>
void Ignore(// WS Generic Input:
            const T& in,
            // Verbosity object:
            const Verbosity& verbosity);


template <typename T>
void IndexSetToLast(// WS Output:
                    Index& nelem,
                    // WS Generic Input:
                    const T& v,
                    // Verbosity object:
                    const Verbosity& verbosity);


template <typename T>
void nelemGet(// WS Output:
              Index& nelem,
              // WS Generic Input:
              const T& v,
              // Verbosity object:
              const Verbosity& verbosity);


template <typename T>
void ncolsGet(// WS Output:
              Index& ncols,
              // WS Generic Input:
              const T& v,
              // Verbosity object:
              const Verbosity& verbosity);


template <typename T>
void nrowsGet(// WS Output:
              Index& nrows,
              // WS Generic Input:
              const T& v,
              // Verbosity object:
              const Verbosity& verbosity);


template <typename T>
void npagesGet(// WS Output:
               Index& npages,
               // WS Generic Input:
               const T& v,
               // Verbosity object:
               const Verbosity& verbosity);


template <typename T>
void nbooksGet(// WS Output:
               Index& nbooks,
               // WS Generic Input:
               const T& v,
               // Verbosity object:
               const Verbosity& verbosity);


template <typename T>
void nshelvesGet(// WS Output:
                 Index& nshelves,
                 // WS Generic Input:
                 const T& v,
                 // Verbosity object:
                 const Verbosity& verbosity);


template <typename T>
void nvitrinesGet(// WS Output:
                  Index& nvitrines,
                  // WS Generic Input:
                  const T& v,
                  // Verbosity object:
                  const Verbosity& verbosity);


template <typename T>
void Print(// WS Generic Input:
           const T& in,
           const Index& level,
           // Verbosity object:
           const Verbosity& verbosity);


template <typename T>
void ReadNetCDF(// WS Generic Output:
                T& out,
                // WS Generic Output Names:
                const String& out_wsvname,
                // WS Generic Input:
                const String& filename,
                // WS Generic Input Names:
                const String& filename_wsvname,
                // Verbosity object:
                const Verbosity& verbosity);


template <typename T>
void ReadXML(// WS Generic Output:
             T& out,
             // WS Generic Output Names:
             const String& out_wsvname,
             // WS Generic Input:
             const String& filename,
             // WS Generic Input Names:
             const String& filename_wsvname,
             // Verbosity object:
             const Verbosity& verbosity);


template <typename T>
void ReadXMLIndexed(// WS Generic Output:
                    T& out,
                    // WS Generic Output Names:
                    const String& out_wsvname,
                    // WS Input:
                    const Index& file_index,
                    // WS Generic Input:
                    const String& filename,
                    const Index& digits,
                    // WS Generic Input Names:
                    const String& filename_wsvname,
                    const String& digits_wsvname,
                    // Verbosity object:
                    const Verbosity& verbosity);


template <typename T>
void Select(// WS Generic Output:
            T& needles,
            // WS Generic Input:
            const T& haystack,
            const ArrayOfIndex& needleindexes,
            // Verbosity object:
            const Verbosity& verbosity);


template <typename T>
void Touch(// WS Generic Output:
           T& in,
           // Verbosity object:
           const Verbosity& verbosity);


template <typename T>
void WriteNetCDF(// WS Generic Input:
                 const T& in,
                 const String& filename,
                 // WS Generic Input Names:
                 const String& in_wsvname,
                 const String& filename_wsvname,
                 // Verbosity object:
                 const Verbosity& verbosity);


template <typename T>
void WriteNetCDFIndexed(// WS Input:
                        const Index& file_index,
                        // WS Generic Input:
                        const T& in,
                        const String& filename,
                        // WS Generic Input Names:
                        const String& in_wsvname,
                        const String& filename_wsvname,
                        // Verbosity object:
                        const Verbosity& verbosity);


template <typename T>
void WriteXML(// WS Input:
              const String& output_file_format,
              // WS Generic Input:
              const T& in,
              const String& filename,
              const Index& no_clobber,
              // WS Generic Input Names:
              const String& in_wsvname,
              const String& filename_wsvname,
              const String& no_clobber_wsvname,
              // Verbosity object:
              const Verbosity& verbosity);


template <typename T>
void WriteXMLIndexed(// WS Input:
                     const String& output_file_format,
                     const Index& file_index,
                     // WS Generic Input:
                     const T& in,
                     const String& filename,
                     const Index& digits,
                     // WS Generic Input Names:
                     const String& in_wsvname,
                     const String& filename_wsvname,
                     const String& digits_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);

// Get-away function declarations:

void AbsorptionLinesCreate_g(Workspace& ws, const MRecord& mr);
void AgendaCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfAbsorptionLinesCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfAbsorptionLinesCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfAgendaCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfGriddedField1Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfGriddedField2Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfGriddedField3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfIndexCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfPpathCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfPropagationMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfRadiationVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfScatteringMetaDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfSingleScatteringDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfSpeciesTagCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfStokesVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfStringCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTensor3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTensor6Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTimeCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTransmissionMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfCIARecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedField1Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedField2Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedField3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedField4Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfPropagationMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfQuantumIdentifierCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfRadiationVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfRetrievalQuantityCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfScatteringMetaDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfSingleScatteringDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfSparseCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfStokesVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfTelsemAtlasCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor4Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor5Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor6Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor7Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTimeCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfTransmissionMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfXsecRecordCreate_g(Workspace& ws, const MRecord& mr);
void CIARecordCreate_g(Workspace& ws, const MRecord& mr);
void CovarianceMatrixCreate_g(Workspace& ws, const MRecord& mr);
void EnergyLevelMapCreate_g(Workspace& ws, const MRecord& mr);
void GasAbsLookupCreate_g(Workspace& ws, const MRecord& mr);
void GridPosCreate_g(Workspace& ws, const MRecord& mr);
void GriddedField1Create_g(Workspace& ws, const MRecord& mr);
void GriddedField2Create_g(Workspace& ws, const MRecord& mr);
void GriddedField3Create_g(Workspace& ws, const MRecord& mr);
void GriddedField4Create_g(Workspace& ws, const MRecord& mr);
void GriddedField5Create_g(Workspace& ws, const MRecord& mr);
void GriddedField6Create_g(Workspace& ws, const MRecord& mr);
void HitranRelaxationMatrixDataCreate_g(Workspace& ws, const MRecord& mr);
void IndexCreate_g(Workspace& ws, const MRecord& mr);
void MCAntennaCreate_g(Workspace& ws, const MRecord& mr);
void MatrixCreate_g(Workspace& ws, const MRecord& mr);
void NumericCreate_g(Workspace& ws, const MRecord& mr);
void PpathCreate_g(Workspace& ws, const MRecord& mr);
void PropagationMatrixCreate_g(Workspace& ws, const MRecord& mr);
void QuantumIdentifierCreate_g(Workspace& ws, const MRecord& mr);
void RadiationVectorCreate_g(Workspace& ws, const MRecord& mr);
void RationalCreate_g(Workspace& ws, const MRecord& mr);
void ScatteringMetaDataCreate_g(Workspace& ws, const MRecord& mr);
void SingleScatteringDataCreate_g(Workspace& ws, const MRecord& mr);
void SparseCreate_g(Workspace& ws, const MRecord& mr);
void SpeciesAuxDataCreate_g(Workspace& ws, const MRecord& mr);
void StokesVectorCreate_g(Workspace& ws, const MRecord& mr);
void StringCreate_g(Workspace& ws, const MRecord& mr);
void TelsemAtlasCreate_g(Workspace& ws, const MRecord& mr);
void Tensor3Create_g(Workspace& ws, const MRecord& mr);
void Tensor4Create_g(Workspace& ws, const MRecord& mr);
void Tensor5Create_g(Workspace& ws, const MRecord& mr);
void Tensor6Create_g(Workspace& ws, const MRecord& mr);
void Tensor7Create_g(Workspace& ws, const MRecord& mr);
void TimerCreate_g(Workspace& ws, const MRecord& mr);
void TimeCreate_g(Workspace& ws, const MRecord& mr);
void TessemNNCreate_g(Workspace& ws, const MRecord& mr);
void TransmissionMatrixCreate_g(Workspace& ws, const MRecord& mr);
void VectorCreate_g(Workspace& ws, const MRecord& mr);
void VerbosityCreate_g(Workspace& ws, const MRecord& mr);
void AbsInputFromAtmFields_g(Workspace& ws, const MRecord& mr);
void AbsInputFromRteScalars_g(Workspace& ws, const MRecord& mr);
void abs_cia_dataAddCIARecord_g(Workspace& ws, const MRecord& mr);
void abs_cia_dataReadFromCIA_g(Workspace& ws, const MRecord& mr);
void abs_cia_dataReadFromXML_g(Workspace& ws, const MRecord& mr);
void abs_coefCalcFromXsec_g(Workspace& ws, const MRecord& mr);
void abs_cont_descriptionAppend_g(Workspace& ws, const MRecord& mr);
void abs_cont_descriptionInit_g(Workspace& ws, const MRecord& mr);
void abs_hitran_relmat_dataReadHitranRelmatDataAndLines_g(Workspace& ws, const MRecord& mr);
void abs_linesCleanupEmpty_g(Workspace& ws, const MRecord& mr);
void abs_linesKeepBands_g(Workspace& ws, const MRecord& mr);
void abs_linesRemoveBand_g(Workspace& ws, const MRecord& mr);
void abs_linesRemoveUnusedLocalQuantumNumbers_g(Workspace& ws, const MRecord& mr);
void abs_linesReplaceWithLines_g(Workspace& ws, const MRecord& mr);
void abs_linesAppendWithLines_g(Workspace& ws, const MRecord& mr);
void abs_linesDeleteWithLines_g(Workspace& ws, const MRecord& mr);
void abs_linesDeleteBadF0_g(Workspace& ws, const MRecord& mr);
void abs_linesDeleteLinesWithUndefinedLocalQuanta_g(Workspace& ws, const MRecord& mr);
void abs_linesDeleteLinesWithBadOrHighChangingJs_g(Workspace& ws, const MRecord& mr);
void abs_linesDeleteLinesWithQuantumNumberAbove_g(Workspace& ws, const MRecord& mr);
void abs_linesPrintDefinedQuantumNumbers_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesReadSplitCatalog_g(Workspace& ws, const MRecord& mr);
void abs_linesReadSpeciesSplitCatalog_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesReadSpeciesSplitCatalog_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetEmpty_g(Workspace& ws, const MRecord& mr);
void abs_linesSetEmptyBroadeningParametersToEmpty_g(Workspace& ws, const MRecord& mr);
void abs_linesSetNormalization_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetNormalization_g(Workspace& ws, const MRecord& mr);
void abs_linesSetNormalizationForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetNormalizationForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetNormalizationForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetMirroring_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetMirroring_g(Workspace& ws, const MRecord& mr);
void abs_linesSetMirroringForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetMirroringForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetMirroringForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetPopulation_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetPopulation_g(Workspace& ws, const MRecord& mr);
void abs_linesSetPopulationForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetPopulationForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetPopulationForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetLineShapeType_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLineShapeType_g(Workspace& ws, const MRecord& mr);
void abs_linesSetLineShapeTypeForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLineShapeTypeForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLineShapeTypeForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetCutoff_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetCutoff_g(Workspace& ws, const MRecord& mr);
void abs_linesSetCutoffForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetCutoffForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetCutoffForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetLinemixingLimit_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLinemixingLimit_g(Workspace& ws, const MRecord& mr);
void abs_linesSetLinemixingLimitForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLinemixingLimitForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLinemixingLimitForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetT0_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetT0_g(Workspace& ws, const MRecord& mr);
void abs_linesSetT0ForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetT0ForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetT0ForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetQuantumNumberForMatch_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetQuantumNumberForMatch_g(Workspace& ws, const MRecord& mr);
void abs_linesChangeBaseParameterForMatchingLevel_g(Workspace& ws, const MRecord& mr);
void abs_linesChangeBaseParameterForMatchingLevels_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeBaseParameterForMatchingLevel_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeBaseParameterForMatchingLevels_g(Workspace& ws, const MRecord& mr);
void abs_linesSetBaseParameterForMatchingLevel_g(Workspace& ws, const MRecord& mr);
void abs_linesSetBaseParameterForMatchingLevels_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetBaseParameterForMatchingLevel_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetBaseParameterForMatchingLevels_g(Workspace& ws, const MRecord& mr);
void abs_linesChangeBaseParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeBaseParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeBaseParameterForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetBaseParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetBaseParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetBaseParameterForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesSetLineShapeModelParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLineShapeModelParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetLineShapeModelParameterForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesChangeLineShapeModelParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeLineShapeModelParameterForMatchingLines_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesChangeLineShapeModelParameterForSpecies_g(Workspace& ws, const MRecord& mr);
void abs_linesCompact_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesCompact_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesCreateFromLines_g(Workspace& ws, const MRecord& mr);
void abs_lookupAdapt_g(Workspace& ws, const MRecord& mr);
void abs_lookupCalc_g(Workspace& ws, const MRecord& mr);
void abs_lookupInit_g(Workspace& ws, const MRecord& mr);
void abs_lookupSetup_g(Workspace& ws, const MRecord& mr);
void abs_lookupSetupBatch_g(Workspace& ws, const MRecord& mr);
void abs_lookupSetupWide_g(Workspace& ws, const MRecord& mr);
void abs_lookupTestAccuracy_g(Workspace& ws, const MRecord& mr);
void abs_lookupTestAccMC_g(Workspace& ws, const MRecord& mr);
void abs_nlteFromRaw_g(Workspace& ws, const MRecord& mr);
void abs_speciesAdd_g(Workspace& ws, const MRecord& mr);
void abs_speciesAdd2_g(Workspace& ws, const MRecord& mr);
void abs_speciesDefineAllInScenario_g(Workspace& ws, const MRecord& mr);
void abs_speciesDefineAll_g(Workspace& ws, const MRecord& mr);
void abs_speciesInit_g(Workspace& ws, const MRecord& mr);
void abs_speciesSet_g(Workspace& ws, const MRecord& mr);
void abs_vecAddGas_g(Workspace& ws, const MRecord& mr);
void abs_xsec_agenda_checkedCalc_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddCIA_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddHitranXsec_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddConts_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddLines_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddPredefinedO2MPM2020_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesInit_g(Workspace& ws, const MRecord& mr);
void AddZaAa_g(Workspace& ws, const MRecord& mr);
void AgendaAppend_g(Workspace& ws, const MRecord& mr);
void AgendaExecute_g(Workspace& ws, const MRecord& mr);
void AgendaExecuteExclusive_g(Workspace& ws, const MRecord& mr);
void AgendaSet_g(Workspace& ws, const MRecord& mr);
void AngularGridsSetFluxCalc_g(Workspace& ws, const MRecord& mr);
void ArrayOfAgendaAppend_g(Workspace& ws, const MRecord& mr);
void ArrayOfAgendaExecute_g(Workspace& ws, const MRecord& mr);
void AntennaConstantGaussian1D_g(Workspace& ws, const MRecord& mr);
void AntennaMultiBeamsToPencilBeams_g(Workspace& ws, const MRecord& mr);
void AntennaOff_g(Workspace& ws, const MRecord& mr);
void antenna_responseGaussian_g(Workspace& ws, const MRecord& mr);
void antenna_responseVaryingGaussian_g(Workspace& ws, const MRecord& mr);
void Append_sg_VectorNumeric_g(Workspace& ws, const MRecord& mr);
void Append_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_MatrixVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_Tensor3Matrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_Tensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_Tensor4Tensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_Tensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void Append_sg_StringString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfAbsorptionLinesArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfAbsorptionLinesArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfAgendaArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField1ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField2ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField3ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfIndexArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfMatrixArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfPpathArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfPropagationMatrixArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfRadiationVectorArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfScatteringMetaDataArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfSingleScatteringDataArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfSpeciesTagArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfStokesVectorArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfStringArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor3ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor6ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTimeArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTransmissionMatrixArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfCIARecordArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField1ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField2ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField4ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfPropagationMatrixArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfQuantumIdentifierArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfRadiationVectorArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfScatteringMetaDataArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSparseArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStokesVectorArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTelsemAtlasArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor4ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor5ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor6ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor7ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTimeArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTransmissionMatrixArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfXsecRecordArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfAbsorptionLinesAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfAbsorptionLinesArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfAgendaAgenda_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField1ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField2ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfPpathPpath_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfPropagationMatrixArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfRadiationVectorArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfScatteringMetaDataArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfStokesVectorArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfStringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor6ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTimeArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTransmissionMatrixArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfCIARecordCIARecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField1GriddedField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField2GriddedField2_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGriddedField4GriddedField4_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfIndexIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfMatrixMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfPropagationMatrixPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfQuantumIdentifierQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfRadiationVectorRadiationVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfScatteringMetaDataScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSingleScatteringDataSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSparseSparse_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStokesVectorStokesVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStringString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTelsemAtlasTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor5Tensor5_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor6Tensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor7Tensor7_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTimeTime_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTransmissionMatrixTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfVectorVector_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedFieldGetNames_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedFieldGetNames_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedFieldGetNames_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void ArrayOfGriddedFieldGetNames_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexLinSpace_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexSet_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexSetConstant_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringSet_g(Workspace& ws, const MRecord& mr);
void Arts_g(Workspace& ws, const MRecord& mr);
void Arts2_g(Workspace& ws, const MRecord& mr);
void AtmFieldPerturb_g(Workspace& ws, const MRecord& mr);
void AtmFieldPerturbAtmGrids_g(Workspace& ws, const MRecord& mr);
void AtmFieldPRegrid_sg_Tensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void AtmFieldPRegrid_sg_Tensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void AtmFieldsCalc_g(Workspace& ws, const MRecord& mr);
void AtmFieldsCalcExpand1D_g(Workspace& ws, const MRecord& mr);
void AtmFieldsExpand1D_g(Workspace& ws, const MRecord& mr);
void AtmFieldsExtract1D_g(Workspace& ws, const MRecord& mr);
void AtmFieldsRefinePgrid_g(Workspace& ws, const MRecord& mr);
void AtmFieldsAndParticleBulkPropFieldFromCompact_g(Workspace& ws, const MRecord& mr);
void atmfields_checkedCalc_g(Workspace& ws, const MRecord& mr);
void atmgeom_checkedCalc_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet1D_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet2D_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet3D_g(Workspace& ws, const MRecord& mr);
void AtmRawRead_g(Workspace& ws, const MRecord& mr);
void AtmWithNLTERawRead_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactAddConstant_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactAddSpecies_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactCleanup_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactCreateFromField_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactFromMatrix_g(Workspace& ws, const MRecord& mr);
void backend_channel_responseFlat_g(Workspace& ws, const MRecord& mr);
void backend_channel_responseGaussian_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactAddConstant_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactAddSpecies_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactCleanup_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactFromArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void CIAInfo_g(Workspace& ws, const MRecord& mr);
void CIARecordReadFromFile_g(Workspace& ws, const MRecord& mr);
void cloudboxOff_g(Workspace& ws, const MRecord& mr);
void cloudboxSetAutomatically_g(Workspace& ws, const MRecord& mr);
void cloudboxSetFullAtm_g(Workspace& ws, const MRecord& mr);
void cloudboxSetManually_g(Workspace& ws, const MRecord& mr);
void cloudboxSetManuallyAltitude_g(Workspace& ws, const MRecord& mr);
void cloudbox_checkedCalc_g(Workspace& ws, const MRecord& mr);
void cloudbox_field_monoIterate_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldCrop_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldSetFromPrecalc_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldSetClearsky_g(Workspace& ws, const MRecord& mr);
void cloudbox_field_monoSetConst_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldSetConst_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldSetConstPerFreq_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldUpdate1D_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldUpdateSeq1D_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldUpdateSeq1DPP_g(Workspace& ws, const MRecord& mr);
void cloudbox_fieldUpdateSeq3D_g(Workspace& ws, const MRecord& mr);
void cloudbox_field_monoOptimizeReverse_g(Workspace& ws, const MRecord& mr);
void Compare_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void Compare_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void Compare_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void Compare_sg_Tensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void Compare_sg_Tensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void Compare_sg_Tensor5Tensor5_g(Workspace& ws, const MRecord& mr);
void Compare_sg_Tensor7Tensor7_g(Workspace& ws, const MRecord& mr);
void Compare_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Compare_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Compare_sg_ArrayOfTensor7ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Compare_sg_GriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void Compare_sg_SparseSparse_g(Workspace& ws, const MRecord& mr);
void Compare_sg_SingleScatteringDataSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_Tensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_Tensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_Tensor5Tensor5_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_Tensor6Tensor6_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_Tensor7Tensor7_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfTensor4ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfTensor6ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfTensor7ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfMatrixArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfTensor3ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfTensor6ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfPropagationMatrixArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfPropagationMatrixArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfStokesVectorArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_ArrayOfArrayOfStokesVectorArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void CompareRelative_sg_EnergyLevelMapEnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void complex_refr_indexConstant_g(Workspace& ws, const MRecord& mr);
void complex_refr_indexIceMatzler06_g(Workspace& ws, const MRecord& mr);
void complex_refr_indexIceWarren84_g(Workspace& ws, const MRecord& mr);
void complex_refr_indexWaterLiebe93_g(Workspace& ws, const MRecord& mr);
void Copy_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void Copy_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Index_g(Workspace& ws, const MRecord& mr);
void Copy_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Copy_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Copy_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Rational_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void Copy_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_String_g(Workspace& ws, const MRecord& mr);
void Copy_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Timer_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Time_g(Workspace& ws, const MRecord& mr);
void Copy_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void Copy_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void covmat1D_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat1D_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat1DMarkov_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void covmat1DMarkov_sg_SparseSparse_g(Workspace& ws, const MRecord& mr);
void covmatDiagonal_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void covmatDiagonal_sg_SparseSparse_g(Workspace& ws, const MRecord& mr);
void covmat_seAddBlock_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_seAddBlock_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_seAddInverseBlock_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_seAddInverseBlock_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_seSet_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void covmat_seSet_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_seSet_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_sxSet_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void covmat_sxSet_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_sxSet_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_sxAddBlock_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_sxAddBlock_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_sxAddInverseBlock_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void covmat_sxAddInverseBlock_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void covmat_sxExtractSqrtDiagonal_g(Workspace& ws, const MRecord& mr);
void Delete_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void Delete_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Index_g(Workspace& ws, const MRecord& mr);
void Delete_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Delete_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Delete_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Rational_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void Delete_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_String_g(Workspace& ws, const MRecord& mr);
void Delete_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Timer_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Time_g(Workspace& ws, const MRecord& mr);
void Delete_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void Delete_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void diameter_maxFromDiameter_volume_equ_g(Workspace& ws, const MRecord& mr);
void diameter_volume_equFromDiameter_max_g(Workspace& ws, const MRecord& mr);
void DiagonalMatrix_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void DiagonalMatrix_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void DiffZaAa_g(Workspace& ws, const MRecord& mr);
void DisortCalc_g(Workspace& ws, const MRecord& mr);
void DisortCalcWithARTSSurface_g(Workspace& ws, const MRecord& mr);
void DisortCalcClearsky_g(Workspace& ws, const MRecord& mr);
void DOBatchCalc_g(Workspace& ws, const MRecord& mr);
void DOAngularGridsSet_g(Workspace& ws, const MRecord& mr);
void DoitCalc_g(Workspace& ws, const MRecord& mr);
void DoitGetIncoming_g(Workspace& ws, const MRecord& mr);
void DoitGetIncoming1DAtm_g(Workspace& ws, const MRecord& mr);
void DoitInit_g(Workspace& ws, const MRecord& mr);
void DoitScatteringDataPrepare_g(Workspace& ws, const MRecord& mr);
void DoitWriteIterationFields_g(Workspace& ws, const MRecord& mr);
void doit_conv_flagAbs_g(Workspace& ws, const MRecord& mr);
void doit_conv_flagAbsBT_g(Workspace& ws, const MRecord& mr);
void doit_conv_flagLsq_g(Workspace& ws, const MRecord& mr);
void OptimizeDoitPressureGrid_g(Workspace& ws, const MRecord& mr);
void doit_scat_fieldCalc_g(Workspace& ws, const MRecord& mr);
void doit_scat_fieldCalcLimb_g(Workspace& ws, const MRecord& mr);
void doit_za_grid_optCalc_g(Workspace& ws, const MRecord& mr);
void doit_za_interpSet_g(Workspace& ws, const MRecord& mr);
void Duration_g(Workspace& ws, const MRecord& mr);
void EnergyLevelMapSet_g(Workspace& ws, const MRecord& mr);
void Error_g(Workspace& ws, const MRecord& mr);
void Exit_g(Workspace& ws, const MRecord& mr);
void Extract_sg_IndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Extract_sg_ArrayOfIndexArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Extract_sg_NumericVector_g(Workspace& ws, const MRecord& mr);
void Extract_sg_VectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Extract_sg_MatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Extract_sg_MatrixTensor3_g(Workspace& ws, const MRecord& mr);
void Extract_sg_Tensor3Tensor4_g(Workspace& ws, const MRecord& mr);
void Extract_sg_Tensor4ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Extract_sg_Tensor4Tensor5_g(Workspace& ws, const MRecord& mr);
void Extract_sg_GriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Extract_sg_ArrayOfGriddedField3ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Extract_sg_GriddedField4ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Extract_sg_StringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Extract_sg_SingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Extract_sg_ArrayOfSingleScatteringDataArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Extract_sg_TelsemAtlasArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Extract_sg_QuantumIdentifierArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void ExtractFromMetaSingleScatSpecies_g(Workspace& ws, const MRecord& mr);
void ext_matAddGas_g(Workspace& ws, const MRecord& mr);
void FastemStandAlone_g(Workspace& ws, const MRecord& mr);
void FieldFromGriddedField_sg_MatrixGriddedField2_g(Workspace& ws, const MRecord& mr);
void FieldFromGriddedField_sg_Tensor3GriddedField3_g(Workspace& ws, const MRecord& mr);
void FieldFromGriddedField_sg_Tensor4GriddedField4_g(Workspace& ws, const MRecord& mr);
void FieldFromGriddedField_sg_Tensor4ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void FlagOff_g(Workspace& ws, const MRecord& mr);
void FlagOn_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_ArrayOfTimeArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_ArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_MatrixArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_Tensor3ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_Tensor4ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_Tensor5ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_Tensor6ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Flatten_sg_Tensor7ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ForLoop_g(Workspace& ws, const MRecord& mr);
void FrequencyFromWavelength_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void FrequencyFromWavelength_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void FrequencyFromCGSAngularWavenumber_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void FrequencyFromCGSAngularWavenumber_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void FrequencyFromCGSKayserWavenumber_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void FrequencyFromCGSKayserWavenumber_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void f_gridFromAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void f_gridFromGasAbsLookup_g(Workspace& ws, const MRecord& mr);
void f_gridFromSensorAMSU_g(Workspace& ws, const MRecord& mr);
void f_gridFromSensorAMSUgeneric_g(Workspace& ws, const MRecord& mr);
void f_gridFromSensorHIRS_g(Workspace& ws, const MRecord& mr);
void f_gridMetMM_g(Workspace& ws, const MRecord& mr);
void g0Earth_g(Workspace& ws, const MRecord& mr);
void g0Io_g(Workspace& ws, const MRecord& mr);
void g0Jupiter_g(Workspace& ws, const MRecord& mr);
void g0Mars_g(Workspace& ws, const MRecord& mr);
void g0Venus_g(Workspace& ws, const MRecord& mr);
void geo_posEndOfPpath_g(Workspace& ws, const MRecord& mr);
void geo_posLowestAltitudeOfPpath_g(Workspace& ws, const MRecord& mr);
void geo_posWherePpathPassesZref_g(Workspace& ws, const MRecord& mr);
void GetEnvironmentVariable_sg_String_g(Workspace& ws, const MRecord& mr);
void GetEnvironmentVariable_sg_Index_g(Workspace& ws, const MRecord& mr);
void GetNumberOfThreads_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void GriddedFieldGetName_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonExpand_sg_GriddedField2GriddedField2_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonExpand_sg_GriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonExpand_sg_GriddedField4GriddedField4_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonExpand_sg_ArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonRegrid_sg_GriddedField2GriddedField2_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonRegrid_sg_GriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonRegrid_sg_GriddedField4GriddedField4_g(Workspace& ws, const MRecord& mr);
void GriddedFieldLatLonRegrid_sg_ArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldPRegrid_sg_GriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldPRegrid_sg_GriddedField4GriddedField4_g(Workspace& ws, const MRecord& mr);
void GriddedFieldPRegrid_sg_ArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void GriddedFieldZToPRegrid_g(Workspace& ws, const MRecord& mr);
void heating_ratesFromIrradiance_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Index_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Rational_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_String_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Timer_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Time_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void INCLUDE_g(Workspace& ws, const MRecord& mr);
void IndexAdd_g(Workspace& ws, const MRecord& mr);
void IndexNumberOfAtmosphericPoints_g(Workspace& ws, const MRecord& mr);
void IndexSet_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void IndexSetToLast_sg_Vector_g(Workspace& ws, const MRecord& mr);
void IndexStepDown_g(Workspace& ws, const MRecord& mr);
void IndexStepUp_g(Workspace& ws, const MRecord& mr);
void InterpAtmFieldToPosition_g(Workspace& ws, const MRecord& mr);
void InterpGriddedField2ToPosition_g(Workspace& ws, const MRecord& mr);
void InterpSurfaceFieldToPosition_g(Workspace& ws, const MRecord& mr);
void irradiance_fieldFromRadiance_g(Workspace& ws, const MRecord& mr);
void isotopologue_ratiosInitFromBuiltin_g(Workspace& ws, const MRecord& mr);
void iyActiveSingleScat_g(Workspace& ws, const MRecord& mr);
void iyActiveSingleScat2_g(Workspace& ws, const MRecord& mr);
void iyApplyUnit_g(Workspace& ws, const MRecord& mr);
void iyCalc_g(Workspace& ws, const MRecord& mr);
void iyEmissionStandard_g(Workspace& ws, const MRecord& mr);
void iyEmissionStandardSequential_g(Workspace& ws, const MRecord& mr);
void iyHybrid_g(Workspace& ws, const MRecord& mr);
void iyHybrid2_g(Workspace& ws, const MRecord& mr);
void iyIndependentBeamApproximation_g(Workspace& ws, const MRecord& mr);
void iyInterpCloudboxField_g(Workspace& ws, const MRecord& mr);
void iyLoopFrequencies_g(Workspace& ws, const MRecord& mr);
void iyMC_g(Workspace& ws, const MRecord& mr);
void iyReplaceFromAux_g(Workspace& ws, const MRecord& mr);
void iySurfaceCallAgendaX_g(Workspace& ws, const MRecord& mr);
void iySurfaceFastem_g(Workspace& ws, const MRecord& mr);
void iySurfaceRtpropAgenda_g(Workspace& ws, const MRecord& mr);
void iySurfaceRtpropCalc_g(Workspace& ws, const MRecord& mr);
void iyTransmissionStandard_g(Workspace& ws, const MRecord& mr);
void iy_transmitterMultiplePol_g(Workspace& ws, const MRecord& mr);
void iy_transmitterSinglePol_g(Workspace& ws, const MRecord& mr);
void jacobianAddAbsSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianAddBasicCatalogParameter_g(Workspace& ws, const MRecord& mr);
void jacobianAddBasicCatalogParameters_g(Workspace& ws, const MRecord& mr);
void jacobianAddFreqShift_g(Workspace& ws, const MRecord& mr);
void jacobianAddFreqStretch_g(Workspace& ws, const MRecord& mr);
void jacobianAddShapeCatalogParameter_g(Workspace& ws, const MRecord& mr);
void jacobianAddShapeCatalogParameters_g(Workspace& ws, const MRecord& mr);
void jacobianAddMagField_g(Workspace& ws, const MRecord& mr);
void jacobianAddNLTE_g(Workspace& ws, const MRecord& mr);
void jacobianAddNLTEs_g(Workspace& ws, const MRecord& mr);
void jacobianAddPointingZa_g(Workspace& ws, const MRecord& mr);
void jacobianAddPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianAddScatSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianAddSinefit_g(Workspace& ws, const MRecord& mr);
void jacobianAddSpecialSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianAddSurfaceQuantity_g(Workspace& ws, const MRecord& mr);
void jacobianAddTemperature_g(Workspace& ws, const MRecord& mr);
void jacobianAddWind_g(Workspace& ws, const MRecord& mr);
void jacobianAdjustAndTransform_g(Workspace& ws, const MRecord& mr);
void jacobianCalcDoNothing_g(Workspace& ws, const MRecord& mr);
void jacobianCalcFreqShift_g(Workspace& ws, const MRecord& mr);
void jacobianCalcFreqStretch_g(Workspace& ws, const MRecord& mr);
void jacobianCalcPointingZaInterp_g(Workspace& ws, const MRecord& mr);
void jacobianCalcPointingZaRecalc_g(Workspace& ws, const MRecord& mr);
void jacobianCalcPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianCalcSinefit_g(Workspace& ws, const MRecord& mr);
void jacobianClose_g(Workspace& ws, const MRecord& mr);
void jacobianFromTwoY_g(Workspace& ws, const MRecord& mr);
void jacobianFromYbatch_g(Workspace& ws, const MRecord& mr);
void jacobianInit_g(Workspace& ws, const MRecord& mr);
void jacobianOff_g(Workspace& ws, const MRecord& mr);
void jacobianSetAffineTransformation_g(Workspace& ws, const MRecord& mr);
void jacobianSetFuncTransformation_g(Workspace& ws, const MRecord& mr);
void lat_gridFromRawField_g(Workspace& ws, const MRecord& mr);
void lbl_checkedCalc_g(Workspace& ws, const MRecord& mr);
void LocalTimeOffset_g(Workspace& ws, const MRecord& mr);
void lon_gridFromRawField_g(Workspace& ws, const MRecord& mr);
void MagFieldsCalc_g(Workspace& ws, const MRecord& mr);
void MagFieldsCalcExpand1D_g(Workspace& ws, const MRecord& mr);
void MagFieldsFromAltitudeRawCalc_g(Workspace& ws, const MRecord& mr);
void MagRawRead_g(Workspace& ws, const MRecord& mr);
void MatrixAddScalar_g(Workspace& ws, const MRecord& mr);
void MatrixCBR_g(Workspace& ws, const MRecord& mr);
void MatrixCopySparse_g(Workspace& ws, const MRecord& mr);
void MatrixExtractFromTensor3_g(Workspace& ws, const MRecord& mr);
void MatrixFromCovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void MatrixIdentity_g(Workspace& ws, const MRecord& mr);
void MatrixMatrixMultiply_g(Workspace& ws, const MRecord& mr);
void MatrixPlanck_g(Workspace& ws, const MRecord& mr);
void MatrixScale_g(Workspace& ws, const MRecord& mr);
void MatrixSet_g(Workspace& ws, const MRecord& mr);
void MatrixSetConstant_g(Workspace& ws, const MRecord& mr);
void MatrixUnitIntensity_g(Workspace& ws, const MRecord& mr);
void MatrixVectorMultiply_g(Workspace& ws, const MRecord& mr);
void Matrix1ColFromVector_g(Workspace& ws, const MRecord& mr);
void Matrix2ColFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix3ColFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix1RowFromVector_g(Workspace& ws, const MRecord& mr);
void Matrix2RowFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix3RowFromVectors_g(Workspace& ws, const MRecord& mr);
void mblock_dlos_gridUniformCircular_g(Workspace& ws, const MRecord& mr);
void mblock_dlos_gridUniformRectangular_g(Workspace& ws, const MRecord& mr);
void mc_antennaSetGaussian_g(Workspace& ws, const MRecord& mr);
void mc_antennaSetGaussianByFWHM_g(Workspace& ws, const MRecord& mr);
void mc_antennaSetPencilBeam_g(Workspace& ws, const MRecord& mr);
void MCGeneral_g(Workspace& ws, const MRecord& mr);
void MCRadar_g(Workspace& ws, const MRecord& mr);
void MCSetSeedFromTime_g(Workspace& ws, const MRecord& mr);
void nlte_fieldRescalePopulationLevels_g(Workspace& ws, const MRecord& mr);
void nlte_fieldForSingleSpeciesNonOverlappingLines_g(Workspace& ws, const MRecord& mr);
void collision_coefficientsFromSplitFiles_g(Workspace& ws, const MRecord& mr);
void NumericAdd_g(Workspace& ws, const MRecord& mr);
void NumericFromVector_g(Workspace& ws, const MRecord& mr);
void NumericInvScale_g(Workspace& ws, const MRecord& mr);
void NumericScale_g(Workspace& ws, const MRecord& mr);
void NumericSet_g(Workspace& ws, const MRecord& mr);
void QuantumIdentifierSet_g(Workspace& ws, const MRecord& mr);
void ArrayOfQuantumIdentifierSet_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void ncolsGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void nrowsGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void npagesGet_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void npagesGet_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void npagesGet_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void npagesGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void npagesGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void nbooksGet_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void nbooksGet_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void nbooksGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void nbooksGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void nshelvesGet_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void nshelvesGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void nshelvesGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void nvitrinesGet_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void nvitrinesGet_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void nlibrariesGet_g(Workspace& ws, const MRecord& mr);
void nlte_sourceFromTemperatureAndSrcCoefPerSpecies_g(Workspace& ws, const MRecord& mr);
void nlteOff_g(Workspace& ws, const MRecord& mr);
void nlteSetByQuantumIdentifiers_g(Workspace& ws, const MRecord& mr);
void nlte_fieldFromRaw_g(Workspace& ws, const MRecord& mr);
void nlte_fieldSetLteExternalPartitionFunction_g(Workspace& ws, const MRecord& mr);
void ArrayOfQuantumIdentifierFromLines_g(Workspace& ws, const MRecord& mr);
void nlte_fieldSetLteInternalPartitionFunction_g(Workspace& ws, const MRecord& mr);
void timeNow_g(Workspace& ws, const MRecord& mr);
void timeOffset_g(Workspace& ws, const MRecord& mr);
void OEM_g(Workspace& ws, const MRecord& mr);
void avkCalc_g(Workspace& ws, const MRecord& mr);
void covmat_soCalc_g(Workspace& ws, const MRecord& mr);
void covmat_ssCalc_g(Workspace& ws, const MRecord& mr);
void opt_prop_bulkCalc_g(Workspace& ws, const MRecord& mr);
void opt_prop_sptFromData_g(Workspace& ws, const MRecord& mr);
void opt_prop_sptFromScat_data_g(Workspace& ws, const MRecord& mr);
void opt_prop_sptFromMonoData_g(Workspace& ws, const MRecord& mr);
void output_file_formatSetAscii_g(Workspace& ws, const MRecord& mr);
void output_file_formatSetBinary_g(Workspace& ws, const MRecord& mr);
void output_file_formatSetZippedAscii_g(Workspace& ws, const MRecord& mr);
void particle_bulkprop_fieldClip_g(Workspace& ws, const MRecord& mr);
void particle_bulkprop_fieldPerturb_g(Workspace& ws, const MRecord& mr);
void particle_bulkprop_fieldPerturbAtmGrids_g(Workspace& ws, const MRecord& mr);
void particle_massesFromMetaDataSingleCategory_g(Workspace& ws, const MRecord& mr);
void particle_massesFromMetaData_g(Workspace& ws, const MRecord& mr);
void partition_functionsInitFromBuiltin_g(Workspace& ws, const MRecord& mr);
void pha_matCalc_g(Workspace& ws, const MRecord& mr);
void pha_mat_sptFromData_g(Workspace& ws, const MRecord& mr);
void pha_mat_sptFromDataDOITOpt_g(Workspace& ws, const MRecord& mr);
void pha_mat_sptFromMonoData_g(Workspace& ws, const MRecord& mr);
void pha_mat_sptFromScat_data_g(Workspace& ws, const MRecord& mr);
void pndFromPsd_g(Workspace& ws, const MRecord& mr);
void pndFromPsdBasic_g(Workspace& ws, const MRecord& mr);
void pnd_fieldCalcFromParticleBulkProps_g(Workspace& ws, const MRecord& mr);
void pnd_fieldCalcFrompnd_field_raw_g(Workspace& ws, const MRecord& mr);
void pnd_fieldExpand1D_g(Workspace& ws, const MRecord& mr);
void pnd_fieldZero_g(Workspace& ws, const MRecord& mr);
void ppath_fieldFromDownUpLimbGeoms_g(Workspace& ws, const MRecord& mr);
void ppathCalc_g(Workspace& ws, const MRecord& mr);
void ppath_fieldCalc_g(Workspace& ws, const MRecord& mr);
void ppathCalcFromAltitude_g(Workspace& ws, const MRecord& mr);
void ppathFromRtePos2_g(Workspace& ws, const MRecord& mr);
void ppathPlaneParallel_g(Workspace& ws, const MRecord& mr);
void ppathStepByStep_g(Workspace& ws, const MRecord& mr);
void ppathWriteXMLPartial_g(Workspace& ws, const MRecord& mr);
void ppath_stepGeometric_g(Workspace& ws, const MRecord& mr);
void ppath_stepRefractionBasic_g(Workspace& ws, const MRecord& mr);
void ppvar_optical_depthFromPpvar_trans_cumulat_g(Workspace& ws, const MRecord& mr);
void Print_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Print_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void Print_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Print_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void Print_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void Print_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void Print_sg_Index_g(Workspace& ws, const MRecord& mr);
void Print_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Print_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Print_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Print_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Print_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_Rational_g(Workspace& ws, const MRecord& mr);
void Print_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Print_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Print_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void Print_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Print_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_String_g(Workspace& ws, const MRecord& mr);
void Print_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Print_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void Print_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void Print_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void Print_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void Print_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void Print_sg_Timer_g(Workspace& ws, const MRecord& mr);
void Print_sg_Time_g(Workspace& ws, const MRecord& mr);
void Print_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void Print_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Print_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void PrintPhysicalConstants_g(Workspace& ws, const MRecord& mr);
void PrintWorkspace_g(Workspace& ws, const MRecord& mr);
void ZFromPSimple_g(Workspace& ws, const MRecord& mr);
void PFromZSimple_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddFaraday_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddFromAbsCoefPerSpecies_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddFromLookup_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddHitranLineMixingLines_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddOnTheFly_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddParticles_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyAddZeeman_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyInit_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyZero_g(Workspace& ws, const MRecord& mr);
void propmat_clearskyForceNegativeToZero_g(Workspace& ws, const MRecord& mr);
void propmat_clearsky_agenda_checkedCalc_g(Workspace& ws, const MRecord& mr);
void propmat_clearsky_fieldCalc_g(Workspace& ws, const MRecord& mr);
void psdAbelBoutle12_g(Workspace& ws, const MRecord& mr);
void psdDelanoeEtAl14_g(Workspace& ws, const MRecord& mr);
void psdFieldEtAl07_g(Workspace& ws, const MRecord& mr);
void psdFieldEtAl19_g(Workspace& ws, const MRecord& mr);
void psdMcFarquaharHeymsfield97_g(Workspace& ws, const MRecord& mr);
void psdMilbrandtYau05_g(Workspace& ws, const MRecord& mr);
void psdModifiedGamma_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMass_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMassNtot_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMassMeanParticleMass_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMassSingleMoment_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMassXmean_g(Workspace& ws, const MRecord& mr);
void psdModifiedGammaMassXmedian_g(Workspace& ws, const MRecord& mr);
void psdMonoDispersive_g(Workspace& ws, const MRecord& mr);
void psdMonoMass_g(Workspace& ws, const MRecord& mr);
void psdSeifertBeheng06_g(Workspace& ws, const MRecord& mr);
void psdWangEtAl16_g(Workspace& ws, const MRecord& mr);
void p_gridDensify_g(Workspace& ws, const MRecord& mr);
void p_gridFromZRaw_g(Workspace& ws, const MRecord& mr);
void lat_gridFromZRaw_g(Workspace& ws, const MRecord& mr);
void lon_gridFromZRaw_g(Workspace& ws, const MRecord& mr);
void atm_gridsFromZRaw_g(Workspace& ws, const MRecord& mr);
void p_gridFromGasAbsLookup_g(Workspace& ws, const MRecord& mr);
void p_gridRefine_g(Workspace& ws, const MRecord& mr);
void RadiationFieldSpectralIntegrate_sg_Tensor4Tensor5_g(Workspace& ws, const MRecord& mr);
void RadiationFieldSpectralIntegrate_sg_Tensor5Tensor7_g(Workspace& ws, const MRecord& mr);
void line_irradianceCalcForSingleSpeciesNonOverlappingLinesPseudo2D_g(Workspace& ws, const MRecord& mr);
void RationalAdd_g(Workspace& ws, const MRecord& mr);
void RationalInvScale_g(Workspace& ws, const MRecord& mr);
void RationalScale_g(Workspace& ws, const MRecord& mr);
void RationalSet_g(Workspace& ws, const MRecord& mr);
void ReadArrayOfARTSCAT_g(Workspace& ws, const MRecord& mr);
void ReadSplitARTSCAT_g(Workspace& ws, const MRecord& mr);
void ReadARTSCAT_g(Workspace& ws, const MRecord& mr);
void ReadHITRAN_g(Workspace& ws, const MRecord& mr);
void ReadLBLRTM_g(Workspace& ws, const MRecord& mr);
void ReadMytran2_g(Workspace& ws, const MRecord& mr);
void ReadJPL_g(Workspace& ws, const MRecord& mr);
void abs_linesTruncateGlobalQuantumNumbers_g(Workspace& ws, const MRecord& mr);
void abs_linesWriteSplitXML_g(Workspace& ws, const MRecord& mr);
void abs_linesWriteSpeciesSplitXML_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesWriteSplitXML_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesWriteSpeciesSplitXML_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadNetCDF_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Index_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Rational_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_String_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Timer_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Time_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Index_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Rational_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_String_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Timer_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Time_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericVector_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericMatrix_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericTensor3_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericTensor4_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericTensor5_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericTensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_NumericTensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorMatrix_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorTensor3_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorTensor4_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorTensor5_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorTensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_VectorTensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_MatrixTensor3_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_MatrixTensor4_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_MatrixTensor5_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_MatrixTensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_MatrixTensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor3Tensor4_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor3Tensor5_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor3Tensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor3Tensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor4Tensor5_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor4Tensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor4Tensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor5Tensor6_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor5Tensor7_g(Workspace& ws, const MRecord& mr);
void Reduce_sg_Tensor6Tensor7_g(Workspace& ws, const MRecord& mr);
void refellipsoidEarth_g(Workspace& ws, const MRecord& mr);
void refellipsoidGanymede_g(Workspace& ws, const MRecord& mr);
void refellipsoidForAzimuth_g(Workspace& ws, const MRecord& mr);
void refellipsoidEuropa_g(Workspace& ws, const MRecord& mr);
void refellipsoidIo_g(Workspace& ws, const MRecord& mr);
void refellipsoidJupiter_g(Workspace& ws, const MRecord& mr);
void refellipsoidMars_g(Workspace& ws, const MRecord& mr);
void refellipsoidMoon_g(Workspace& ws, const MRecord& mr);
void refellipsoidOrbitPlane_g(Workspace& ws, const MRecord& mr);
void refellipsoidSet_g(Workspace& ws, const MRecord& mr);
void refellipsoidVenus_g(Workspace& ws, const MRecord& mr);
void refr_index_airFreeElectrons_g(Workspace& ws, const MRecord& mr);
void refr_index_airInfraredEarth_g(Workspace& ws, const MRecord& mr);
void refr_index_airMicrowavesEarth_g(Workspace& ws, const MRecord& mr);
void refr_index_airMicrowavesGeneral_g(Workspace& ws, const MRecord& mr);
void retrievalDefClose_g(Workspace& ws, const MRecord& mr);
void retrievalAddAbsSpecies_g(Workspace& ws, const MRecord& mr);
void retrievalAddFreqShift_g(Workspace& ws, const MRecord& mr);
void retrievalAddFreqStretch_g(Workspace& ws, const MRecord& mr);
void retrievalDefInit_g(Workspace& ws, const MRecord& mr);
void retrievalAddCatalogParameter_g(Workspace& ws, const MRecord& mr);
void retrievalAddCatalogParameters_g(Workspace& ws, const MRecord& mr);
void retrievalAddMagField_g(Workspace& ws, const MRecord& mr);
void retrievalAddPointingZa_g(Workspace& ws, const MRecord& mr);
void retrievalAddPolyfit_g(Workspace& ws, const MRecord& mr);
void retrievalAddScatSpecies_g(Workspace& ws, const MRecord& mr);
void retrievalAddSinefit_g(Workspace& ws, const MRecord& mr);
void retrievalAddSpecialSpecies_g(Workspace& ws, const MRecord& mr);
void retrievalAddSurfaceQuantity_g(Workspace& ws, const MRecord& mr);
void retrievalAddTemperature_g(Workspace& ws, const MRecord& mr);
void retrievalAddWind_g(Workspace& ws, const MRecord& mr);
void retrievalErrorsExtract_g(Workspace& ws, const MRecord& mr);
void RT4Calc_g(Workspace& ws, const MRecord& mr);
void RT4CalcWithRT4Surface_g(Workspace& ws, const MRecord& mr);
void RT4Test_g(Workspace& ws, const MRecord& mr);
void rte_losGeometricFromRtePosToRtePos2_g(Workspace& ws, const MRecord& mr);
void rte_losSet_g(Workspace& ws, const MRecord& mr);
void rte_posSet_g(Workspace& ws, const MRecord& mr);
void rte_pos_losMoveToStartOfPpath_g(Workspace& ws, const MRecord& mr);
void rtp_nlteFromRaw_g(Workspace& ws, const MRecord& mr);
void ScatElementsPndAndScatAdd_g(Workspace& ws, const MRecord& mr);
void ScatElementsSelect_g(Workspace& ws, const MRecord& mr);
void ScatElementsToabs_speciesAdd_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesExtendTemperature_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesInit_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesMerge_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesPndAndScatAdd_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesScatAndMetaRead_g(Workspace& ws, const MRecord& mr);
void scat_data_singleTmatrix_g(Workspace& ws, const MRecord& mr);
void scat_data_checkedCalc_g(Workspace& ws, const MRecord& mr);
void scat_data_monoCalc_g(Workspace& ws, const MRecord& mr);
void scat_data_monoExtract_g(Workspace& ws, const MRecord& mr);
void scat_dataCalc_g(Workspace& ws, const MRecord& mr);
void scat_dataCheck_g(Workspace& ws, const MRecord& mr);
void scat_dataReduceT_g(Workspace& ws, const MRecord& mr);
void ScatSpeciesSizeMassInfo_g(Workspace& ws, const MRecord& mr);
void particle_fieldCleanup_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfAbsorptionLinesArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfAbsorptionLinesArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfAgendaArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfGriddedField1ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfGriddedField2ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfGriddedField3ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfIndexArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfMatrixArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfPpathArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfPropagationMatrixArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfRadiationVectorArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfScatteringMetaDataArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfSingleScatteringDataArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfSpeciesTagArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfStokesVectorArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfStringArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfTensor3ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfTensor6ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfTimeArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfTransmissionMatrixArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfCIARecordArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGriddedField1ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGriddedField2ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGriddedField3ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGriddedField4ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfPropagationMatrixArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfQuantumIdentifierArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfRadiationVectorArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfScatteringMetaDataArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfSparseArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfStokesVectorArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfStringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTelsemAtlasArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor4ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor5ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor6ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor7ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTimeArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTransmissionMatrixArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfXsecRecordArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_MatrixMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_SparseSparse_g(Workspace& ws, const MRecord& mr);
void sensor_checkedCalc_g(Workspace& ws, const MRecord& mr);
void sensorOff_g(Workspace& ws, const MRecord& mr);
void sensor_losGeometricFromSensorPosToOtherPositions_g(Workspace& ws, const MRecord& mr);
void sensor_responseAntenna_g(Workspace& ws, const MRecord& mr);
void sensor_responseBackend_g(Workspace& ws, const MRecord& mr);
void sensor_responseBackendFrequencySwitching_g(Workspace& ws, const MRecord& mr);
void sensor_responseBeamSwitching_g(Workspace& ws, const MRecord& mr);
void sensor_responseFillFgrid_g(Workspace& ws, const MRecord& mr);
void sensor_responseFrequencySwitching_g(Workspace& ws, const MRecord& mr);
void sensor_responseIF2RF_g(Workspace& ws, const MRecord& mr);
void sensor_responseInit_g(Workspace& ws, const MRecord& mr);
void sensor_responseMetMM_g(Workspace& ws, const MRecord& mr);
void sensor_responseMixer_g(Workspace& ws, const MRecord& mr);
void sensor_responseMixerBackendPrecalcWeights_g(Workspace& ws, const MRecord& mr);
void sensor_responseMultiMixerBackend_g(Workspace& ws, const MRecord& mr);
void sensor_responsePolarisation_g(Workspace& ws, const MRecord& mr);
void sensor_responseStokesRotation_g(Workspace& ws, const MRecord& mr);
void sensor_responseSimpleAMSU_g(Workspace& ws, const MRecord& mr);
void sensor_responseGenericAMSU_g(Workspace& ws, const MRecord& mr);
void sensor_responseWMRF_g(Workspace& ws, const MRecord& mr);
void SetNumberOfThreads_g(Workspace& ws, const MRecord& mr);
void Sleep_g(Workspace& ws, const MRecord& mr);
void timeSleep_g(Workspace& ws, const MRecord& mr);
void SparseSparseMultiply_g(Workspace& ws, const MRecord& mr);
void SparseMatrixIdentity_g(Workspace& ws, const MRecord& mr);
void spectral_irradiance_fieldFromSpectralRadianceField_g(Workspace& ws, const MRecord& mr);
void spectral_radiance_fieldClearskyPlaneParallel_g(Workspace& ws, const MRecord& mr);
void spectral_radiance_fieldCopyCloudboxField_g(Workspace& ws, const MRecord& mr);
void spectral_radiance_fieldExpandCloudboxField_g(Workspace& ws, const MRecord& mr);
void specular_losCalc_g(Workspace& ws, const MRecord& mr);
void specular_losCalcNoTopography_g(Workspace& ws, const MRecord& mr);
void StringJoin_g(Workspace& ws, const MRecord& mr);
void StringSet_g(Workspace& ws, const MRecord& mr);
void z_surfaceFromFileAndGrid_g(Workspace& ws, const MRecord& mr);
void z_surfaceConstantAltitude_g(Workspace& ws, const MRecord& mr);
void surfaceBlackbody_g(Workspace& ws, const MRecord& mr);
void surfaceFastem_g(Workspace& ws, const MRecord& mr);
void surfaceTessem_g(Workspace& ws, const MRecord& mr);
void surfaceTelsem_g(Workspace& ws, const MRecord& mr);
void surfaceFlatRefractiveIndex_g(Workspace& ws, const MRecord& mr);
void surfaceFlatReflectivity_g(Workspace& ws, const MRecord& mr);
void surfaceFlatRvRh_g(Workspace& ws, const MRecord& mr);
void surfaceFlatScalarReflectivity_g(Workspace& ws, const MRecord& mr);
void surfaceLambertianSimple_g(Workspace& ws, const MRecord& mr);
void surfaceSemiSpecularBy3beams_g(Workspace& ws, const MRecord& mr);
void surfaceSplitSpecularTo3beams_g(Workspace& ws, const MRecord& mr);
void surface_complex_refr_indexFromGriddedField5_g(Workspace& ws, const MRecord& mr);
void surface_reflectivityFromGriddedField6_g(Workspace& ws, const MRecord& mr);
void surface_rtpropCallAgendaX_g(Workspace& ws, const MRecord& mr);
void surface_scalar_reflectivityFromGriddedField4_g(Workspace& ws, const MRecord& mr);
void surface_scalar_reflectivityFromSurface_rmatrix_g(Workspace& ws, const MRecord& mr);
void surface_typeInterpTypeMask_g(Workspace& ws, const MRecord& mr);
void SurfaceDummy_g(Workspace& ws, const MRecord& mr);
void SurfaceFastem_g(Workspace& ws, const MRecord& mr);
void SurfaceTessem_g(Workspace& ws, const MRecord& mr);
void TangentPointExtract_g(Workspace& ws, const MRecord& mr);
void TangentPointPrint_g(Workspace& ws, const MRecord& mr);
void telsemStandalone_g(Workspace& ws, const MRecord& mr);
void telsemAtlasLookup_g(Workspace& ws, const MRecord& mr);
void telsemSurfaceTypeLandSea_g(Workspace& ws, const MRecord& mr);
void telsem_atlasReadAscii_g(Workspace& ws, const MRecord& mr);
void telsem_atlasesReadAscii_g(Workspace& ws, const MRecord& mr);
void Tensor3AddScalar_g(Workspace& ws, const MRecord& mr);
void Tensor3ExtractFromTensor4_g(Workspace& ws, const MRecord& mr);
void Tensor3Scale_g(Workspace& ws, const MRecord& mr);
void Tensor3SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor4AddScalar_g(Workspace& ws, const MRecord& mr);
void Tensor4Scale_g(Workspace& ws, const MRecord& mr);
void Tensor4SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor5Scale_g(Workspace& ws, const MRecord& mr);
void Tensor5SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor6Scale_g(Workspace& ws, const MRecord& mr);
void Tensor6SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor7Scale_g(Workspace& ws, const MRecord& mr);
void Tensor7SetConstant_g(Workspace& ws, const MRecord& mr);
void TestArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void TessemNNReadAscii_g(Workspace& ws, const MRecord& mr);
void TestTessem_g(Workspace& ws, const MRecord& mr);
void Test_g(Workspace& ws, const MRecord& mr);
void time_gridOffset_g(Workspace& ws, const MRecord& mr);
void timerStart_g(Workspace& ws, const MRecord& mr);
void timerStop_g(Workspace& ws, const MRecord& mr);
void time_stampsSort_sg_ArrayOfTimeArrayOfTime_g(Workspace& ws, const MRecord& mr);
void time_stampsSort_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void TMatrixTest_g(Workspace& ws, const MRecord& mr);
void Touch_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void Touch_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Index_g(Workspace& ws, const MRecord& mr);
void Touch_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Touch_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void Touch_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Rational_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void Touch_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_String_g(Workspace& ws, const MRecord& mr);
void Touch_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Timer_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Time_g(Workspace& ws, const MRecord& mr);
void Touch_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void Touch_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void transmittanceFromIy_aux_g(Workspace& ws, const MRecord& mr);
void VectorAddScalar_g(Workspace& ws, const MRecord& mr);
void VectorAddVector_g(Workspace& ws, const MRecord& mr);
void VectorCrop_g(Workspace& ws, const MRecord& mr);
void VectorExtractFromMatrix_g(Workspace& ws, const MRecord& mr);
void VectorFlip_g(Workspace& ws, const MRecord& mr);
void VectorInsertGridPoints_g(Workspace& ws, const MRecord& mr);
void VectorLinSpace_g(Workspace& ws, const MRecord& mr);
void VectorLogSpace_g(Workspace& ws, const MRecord& mr);
void VectorMatrixMultiply_g(Workspace& ws, const MRecord& mr);
void VectorNLinSpace_g(Workspace& ws, const MRecord& mr);
void VectorNLogSpace_g(Workspace& ws, const MRecord& mr);
void VectorReshapeMatrix_g(Workspace& ws, const MRecord& mr);
void VectorScale_g(Workspace& ws, const MRecord& mr);
void VectorSetConstant_g(Workspace& ws, const MRecord& mr);
void VectorSet_g(Workspace& ws, const MRecord& mr);
void VectorSubtractVector_g(Workspace& ws, const MRecord& mr);
void VectorVectorMultiply_g(Workspace& ws, const MRecord& mr);
void VectorZtanToZaRefr1D_g(Workspace& ws, const MRecord& mr);
void VectorZtanToZa1D_g(Workspace& ws, const MRecord& mr);
void verbosityInit_g(Workspace& ws, const MRecord& mr);
void verbositySet_g(Workspace& ws, const MRecord& mr);
void verbositySetAgenda_g(Workspace& ws, const MRecord& mr);
void verbositySetFile_g(Workspace& ws, const MRecord& mr);
void verbositySetScreen_g(Workspace& ws, const MRecord& mr);
void vmr_fieldClip_g(Workspace& ws, const MRecord& mr);
void vmr_fieldPerturb_g(Workspace& ws, const MRecord& mr);
void vmr_fieldPerturbAtmGrids_g(Workspace& ws, const MRecord& mr);
void vmr_fieldSetAllConstant_g(Workspace& ws, const MRecord& mr);
void water_p_eq_fieldMK05_g(Workspace& ws, const MRecord& mr);
void vmr_fieldSetConstant_g(Workspace& ws, const MRecord& mr);
void Wigner6Init_g(Workspace& ws, const MRecord& mr);
void Wigner3Init_g(Workspace& ws, const MRecord& mr);
void Wigner6Unload_g(Workspace& ws, const MRecord& mr);
void Wigner3Unload_g(Workspace& ws, const MRecord& mr);
void WignerFastInfoPrint_g(Workspace& ws, const MRecord& mr);
void WindFieldsCalc_g(Workspace& ws, const MRecord& mr);
void WindFieldsCalcExpand1D_g(Workspace& ws, const MRecord& mr);
void WindRawRead_g(Workspace& ws, const MRecord& mr);
void wind_u_fieldIncludePlanetRotation_g(Workspace& ws, const MRecord& mr);
void WMRFSelectChannels_g(Workspace& ws, const MRecord& mr);
void WriteMolTau_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteNetCDF_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteNetCDFIndexed_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Index_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Rational_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_String_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Timer_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Time_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_AbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfAbsorptionLines_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfAgenda_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfTime_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGriddedField4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfPropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfQuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfRadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfStokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTelsemAtlas_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor5_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTime_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfXsecRecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_CIARecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_CovarianceMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_EnergyLevelMap_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField2_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField5_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GriddedField6_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_HitranRelaxationMatrixData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Index_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_PropagationMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_QuantumIdentifier_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_RadiationVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Rational_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_StokesVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_String_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_TelsemAtlas_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Timer_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Time_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_TessemNN_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_TransmissionMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Verbosity_g(Workspace& ws, const MRecord& mr);
void xaStandard_g(Workspace& ws, const MRecord& mr);
void xClip_g(Workspace& ws, const MRecord& mr);
void x2artsAtmAndSurf_g(Workspace& ws, const MRecord& mr);
void x2artsSensor_g(Workspace& ws, const MRecord& mr);
void x2artsSpectroscopy_g(Workspace& ws, const MRecord& mr);
void yApplySensorPol_g(Workspace& ws, const MRecord& mr);
void yApplyUnit_g(Workspace& ws, const MRecord& mr);
void ybatchCalc_g(Workspace& ws, const MRecord& mr);
void yColdAtmHot_g(Workspace& ws, const MRecord& mr);
void ybatchMetProfiles_g(Workspace& ws, const MRecord& mr);
void ybatchMetProfilesClear_g(Workspace& ws, const MRecord& mr);
void ybatchTimeAveraging_g(Workspace& ws, const MRecord& mr);
void ybatchTroposphericCorrectionNaiveMedianForward_g(Workspace& ws, const MRecord& mr);
void ybatchTroposphericCorrectionNaiveMedianInverse_g(Workspace& ws, const MRecord& mr);
void yCalc_g(Workspace& ws, const MRecord& mr);
void yCalcAppend_g(Workspace& ws, const MRecord& mr);
void yActive_g(Workspace& ws, const MRecord& mr);
void ySimpleSpectrometer_g(Workspace& ws, const MRecord& mr);
void z_fieldFromHSE_g(Workspace& ws, const MRecord& mr);

void propmat_clearsky_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        ArrayOfPropagationMatrix& propmat_clearsky,
        ArrayOfStokesVector& nlte_source,
        ArrayOfPropagationMatrix& dpropmat_clearsky_dx,
        ArrayOfStokesVector& dnlte_dx_source,
        ArrayOfStokesVector& nlte_dsource_dx,
        // Input
        const ArrayOfRetrievalQuantity& jacobian_quantities,
        const Vector& f_grid,
        const Vector& rtp_mag,
        const Vector& rtp_los,
        const Numeric rtp_pressure,
        const Numeric rtp_temperature,
        const EnergyLevelMap& rtp_nlte,
        const Vector& rtp_vmr,
        // Wrapper Input
        const Agenda& input_agenda);

void abs_xsec_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        ArrayOfMatrix& abs_xsec_per_species,
        ArrayOfMatrix& src_xsec_per_species,
        ArrayOfArrayOfMatrix& dabs_xsec_per_species_dx,
        ArrayOfArrayOfMatrix& dsrc_xsec_per_species_dx,
        // Input
        const ArrayOfArrayOfSpeciesTag& abs_species,
        const ArrayOfRetrievalQuantity& jacobian_quantities,
        const ArrayOfIndex& abs_species_active,
        const Vector& f_grid,
        const Vector& abs_p,
        const Vector& abs_t,
        const EnergyLevelMap& abs_nlte,
        const Matrix& abs_vmrs,
        // Wrapper Input
        const Agenda& input_agenda);

void dobatch_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor7& spectral_radiance_field,
        Tensor5& radiance_field,
        Tensor4& irradiance_field,
        Tensor5& spectral_irradiance_field,
        // Input
        const Index ybatch_index,
        // Wrapper Input
        const Agenda& input_agenda);

void doit_conv_test_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Index& doit_conv_flag,
        Index& doit_iteration_counter,
        // Input
        const Tensor6& cloudbox_field_mono,
        const Tensor6& cloudbox_field_mono_old,
        // Wrapper Input
        const Agenda& input_agenda);

void doit_mono_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor6& cloudbox_field_mono,
        // Input
        const Vector& f_grid,
        const Index f_index,
        // Wrapper Input
        const Agenda& input_agenda);

void doit_scat_field_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor6& doit_scat_field,
        // Input
        const Tensor6& cloudbox_field_mono,
        // Wrapper Input
        const Agenda& input_agenda);

void doit_rte_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor6& cloudbox_field_mono,
        // Input
        const Tensor6& doit_scat_field,
        // Wrapper Input
        const Agenda& input_agenda);

void forloop_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        // Input
        const Index forloop_index,
        // Wrapper Input
        const Agenda& input_agenda);

void g0_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& g0,
        // Input
        const Numeric lat,
        const Numeric lon,
        // Wrapper Input
        const Agenda& input_agenda);

void geo_pos_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& geo_pos,
        // Input
        const Ppath& ppath,
        // Wrapper Input
        const Agenda& input_agenda);

void inversion_iterate_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& yf,
        Matrix& jacobian,
        // Input
        const Vector& x,
        const Index jacobian_do,
        const Index inversion_iteration_counter,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_cloudbox_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_independent_beam_approx_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfMatrix& iy_aux,
        Ppath& ppath,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const String& iy_unit,
        const Tensor3& iy_transmission,
        const ArrayOfString& iy_aux_vars,
        const Index iy_id,
        const Index atmosphere_dim,
        const Vector& p_grid,
        const Vector& lat_grid,
        const Vector& lon_grid,
        const Vector& lat_true,
        const Vector& lon_true,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        const Matrix& z_surface,
        const Numeric ppath_lmax,
        const Numeric ppath_lraytrace,
        const Index cloudbox_on,
        const ArrayOfIndex& cloudbox_limits,
        const Tensor4& pnd_field,
        const Index jacobian_do,
        const Vector& f_grid,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Vector& rte_pos2,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_loop_freqs_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfMatrix& iy_aux,
        Ppath& ppath,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const Tensor3& iy_transmission,
        const ArrayOfString& iy_aux_vars,
        const Index iy_id,
        const Vector& f_grid,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Vector& rte_pos2,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_main_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfMatrix& iy_aux,
        Ppath& ppath,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const Tensor3& iy_transmission,
        const ArrayOfString& iy_aux_vars,
        const Index iy_id,
        const String& iy_unit,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Vector& f_grid,
        const EnergyLevelMap& nlte_field,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Vector& rte_pos2,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_space_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_surface_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor3& diy_dx,
        ArrayOfTensor4& dsurface_rmatrix_dx,
        ArrayOfMatrix& dsurface_emission_dx,
        // Input
        const String& iy_unit,
        const Tensor3& iy_transmission,
        const Index iy_id,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Agenda& iy_main_agenda,
        const Vector& f_grid,
        const EnergyLevelMap& nlte_field,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        const Vector& rte_pos2,
        const Tensor3& surface_props_data,
        const ArrayOfString& dsurface_names,
        // Wrapper Input
        const Agenda& input_agenda);

void iy_surface_agenda_arrayExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index agenda_array_index,
        const String& iy_unit,
        const Tensor3& iy_transmission,
        const Index iy_id,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Agenda& iy_main_agenda,
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        const Vector& rte_pos2,
        const Numeric surface_type_aux,
        // Wrapper Input
        const ArrayOfAgenda& input_agenda_array);

void iy_transmitter_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        // Wrapper Input
        const Agenda& input_agenda);

void jacobian_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& jacobian,
        // Input
        const Index mblock_index,
        const Vector& iyb,
        const Vector& yb,
        // Wrapper Input
        const Agenda& input_agenda);

void main_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        // Input
        // Wrapper Input
        const Agenda& input_agenda);

void met_profile_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& y,
        // Input
        const GriddedField3& t_field_raw,
        const ArrayOfGriddedField3& vmr_field_raw,
        const GriddedField3& z_field_raw,
        const ArrayOfGriddedField3& pnd_field_raw,
        const Vector& p_grid,
        const Matrix& sensor_los,
        const Index cloudbox_on,
        const ArrayOfIndex& cloudbox_limits,
        const Matrix& z_surface,
        // Wrapper Input
        const Agenda& input_agenda);

void pha_mat_spt_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor5& pha_mat_spt,
        // Input
        const Index za_index,
        const Index scat_lat_index,
        const Index scat_lon_index,
        const Index scat_p_index,
        const Index aa_index,
        const Numeric rtp_temperature,
        // Wrapper Input
        const Agenda& input_agenda);

void pnd_agenda_arrayExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& pnd_data,
        Tensor3& dpnd_data_dx,
        // Input
        const Index agenda_array_index,
        const Vector& pnd_agenda_input_t,
        const Matrix& pnd_agenda_input,
        const ArrayOfString& pnd_agenda_input_names,
        const ArrayOfString& dpnd_data_dx_names,
        // Wrapper Input
        const ArrayOfAgenda& input_agenda_array);

void ppath_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Ppath& ppath,
        // Input
        const Numeric ppath_lmax,
        const Numeric ppath_lraytrace,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Vector& rte_pos2,
        const Index cloudbox_on,
        const Index ppath_inside_cloudbox_do,
        const Vector& f_grid,
        // Wrapper Input
        const Agenda& input_agenda);

void ppath_step_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Ppath& ppath_step,
        // Input
        const Numeric ppath_lmax,
        const Numeric ppath_lraytrace,
        const Vector& f_grid,
        // Wrapper Input
        const Agenda& input_agenda);

void refr_index_air_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& refr_index_air,
        Numeric& refr_index_air_group,
        // Input
        const Numeric rtp_pressure,
        const Numeric rtp_temperature,
        const Vector& rtp_vmr,
        const Vector& f_grid,
        // Wrapper Input
        const Agenda& input_agenda);

void sensor_response_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Sparse& sensor_response,
        Vector& sensor_response_f,
        Vector& sensor_response_f_grid,
        ArrayOfIndex& sensor_response_pol,
        ArrayOfIndex& sensor_response_pol_grid,
        Matrix& sensor_response_dlos,
        Matrix& sensor_response_dlos_grid,
        Matrix& mblock_dlos_grid,
        // Input
        const Vector& f_backend,
        // Wrapper Input
        const Agenda& input_agenda);

void spt_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        ArrayOfPropagationMatrix& ext_mat_spt,
        ArrayOfStokesVector& abs_vec_spt,
        // Input
        const Index scat_p_index,
        const Index scat_lat_index,
        const Index scat_lon_index,
        const Numeric rtp_temperature,
        const Index za_index,
        const Index aa_index,
        // Wrapper Input
        const Agenda& input_agenda);

void surface_rtprop_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& surface_skin_t,
        Matrix& surface_emission,
        Matrix& surface_los,
        Tensor4& surface_rmatrix,
        // Input
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        // Wrapper Input
        const Agenda& input_agenda);

void surface_rtprop_agenda_arrayExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& surface_skin_t,
        Matrix& surface_emission,
        Matrix& surface_los,
        Tensor4& surface_rmatrix,
        // Input
        const Index agenda_array_index,
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        const Numeric surface_type_aux,
        // Wrapper Input
        const ArrayOfAgenda& input_agenda_array);

void surface_rtprop_sub_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& surface_skin_t,
        Matrix& surface_emission,
        Matrix& surface_los,
        Tensor4& surface_rmatrix,
        // Input
        const Vector& f_grid,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        // Wrapper Input
        const Agenda& input_agenda);

void test_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        // Input
        // Wrapper Input
        const Agenda& input_agenda);

void test_agenda_arrayExecute(
        // Workspace
        Workspace& ws,
        // Output
        // Input
        const Index agenda_array_index,
        const String& iy_unit,
        // Wrapper Input
        const ArrayOfAgenda& input_agenda_array);

void water_p_eq_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor3& water_p_eq_field,
        // Input
        const Tensor3& t_field,
        // Wrapper Input
        const Agenda& input_agenda);

void ybatch_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& y,
        ArrayOfVector& y_aux,
        Matrix& jacobian,
        // Input
        const Index ybatch_index,
        // Wrapper Input
        const Agenda& input_agenda);


#endif  // auto_md_h