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  8 2020, 12:59:12
 
#ifndef auto_md_h
#define auto_md_h
 
#include "matpackI.h"
#include "matpackII.h"
#include "abs_species_tags.h"
#include "gas_abs_lookup.h"
#include "gridded_fields.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 "linemixingrecord.h"
 
// This is only used for a consistency check. You can get the
// number of WSMs from md_data.nelem().
#define N_MD 1190
 
// Method function declarations:
 
 
void IndexCreate(// WS Generic Output:
                 Index& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void NumericCreate(// WS Generic Output:
                   Numeric& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void StringCreate(// WS Generic Output:
                  String& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void VectorCreate(// WS Generic Output:
                  Vector& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixCreate(// WS Generic Output:
                  Matrix& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void SparseCreate(// WS Generic Output:
                  Sparse& 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 VerbosityCreate(// WS Generic Output:
                     Verbosity& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfArrayOfIndexCreate(// WS Generic Output:
                               ArrayOfArrayOfIndex& out,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfVectorCreate(// WS Generic Output:
                                ArrayOfArrayOfVector& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfMatrixCreate(// WS Generic Output:
                                ArrayOfArrayOfMatrix& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfSparseCreate(// WS Generic Output:
                         ArrayOfSparse& out,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfTensor3Create(// WS Generic Output:
                          ArrayOfTensor3& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor3Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor3& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfTensor4Create(// WS Generic Output:
                          ArrayOfTensor4& 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 ArrayOfArrayOfTensor6Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor6& out,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfLineMixingRecordCreate(// WS Generic Output:
                                   ArrayOfLineMixingRecord& out,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void ArrayOfLineRecordCreate(// WS Generic Output:
                             ArrayOfLineRecord& out,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfArrayOfLineRecordCreate(// WS Generic Output:
                                    ArrayOfArrayOfLineRecord& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfLineshapeSpecCreate(// WS Generic Output:
                                ArrayOfLineshapeSpec& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSpeciesTagCreate(// WS Generic Output:
                                    ArrayOfArrayOfSpeciesTag& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void PpathCreate(// WS Generic Output:
                 Ppath& out,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void AgendaCreate(// WS Generic Output:
                  Agenda& out,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void GridPosCreate(// WS Generic Output:
                   GridPos& out,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void GasAbsLookupCreate(// WS Generic Output:
                        GasAbsLookup& out,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void SingleScatteringDataCreate(// WS Generic Output:
                                SingleScatteringData& out,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                       ArrayOfSingleScatteringData& out,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ScatteringMetaDataCreate(// WS Generic Output:
                              ScatteringMetaData& out,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                     ArrayOfScatteringMetaData& 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 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 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 ArrayOfArrayOfLineMixingRecordCreate(// WS Generic Output:
                                          ArrayOfArrayOfLineMixingRecord& out,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void ArrayOfRetrievalQuantityCreate(// WS Generic Output:
                                    ArrayOfRetrievalQuantity& out,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void MCAntennaCreate(// WS Generic Output:
                     MCAntenna& out,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void SpeciesAuxDataCreate(// WS Generic Output:
                          SpeciesAuxData& out,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfCIARecordCreate(// WS Generic Output:
                            ArrayOfCIARecord& 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_coefCalcFromXsec(// WS Output:
                          Matrix& abs_coef,
                          ArrayOfMatrix& abs_coef_per_species,
                          // WS Input:
                          const ArrayOfMatrix& abs_xsec_per_species,
                          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_lineshapeDefine(// WS Output:
                         ArrayOfLineshapeSpec& abs_lineshape,
                         // WS Generic Input:
                         const String& shape,
                         const String& forefactor,
                         const Numeric& cutoff,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_lineshape_per_tgDefine(// WS Output:
                                ArrayOfLineshapeSpec& abs_lineshape,
                                // WS Input:
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                // WS Generic Input:
                                const ArrayOfString& shape,
                                const ArrayOfString& normalizationfactor,
                                const Vector& cutoff,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void abs_linesArtscat4FromArtscat3(// WS Output:
                                   ArrayOfLineRecord& abs_lines,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_linesReadFromArts(// WS Output:
                           ArrayOfLineRecord& abs_lines,
                           // WS Generic Input:
                           const String& filename,
                           const Numeric& fmin,
                           const Numeric& fmax,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void abs_linesReadFromHitran(// WS Output:
                             ArrayOfLineRecord& abs_lines,
                             // WS Generic Input:
                             const String& filename,
                             const Numeric& fmin,
                             const Numeric& fmax,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void abs_linesReadFromHitranPre2004(// WS Output:
                                    ArrayOfLineRecord& abs_lines,
                                    // WS Generic Input:
                                    const String& filename,
                                    const Numeric& fmin,
                                    const Numeric& fmax,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void abs_linesReadFromJpl(// WS Output:
                          ArrayOfLineRecord& abs_lines,
                          // WS Generic Input:
                          const String& filename,
                          const Numeric& fmin,
                          const Numeric& fmax,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void abs_linesReadFromMytran2(// WS Output:
                              ArrayOfLineRecord& abs_lines,
                              // WS Generic Input:
                              const String& filename,
                              const Numeric& fmin,
                              const Numeric& fmax,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void abs_linesReadFromSplitArtscat(// WS Output:
                                   ArrayOfLineRecord& abs_lines,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   // WS Generic Input:
                                   const String& basename,
                                   const Numeric& fmin,
                                   const Numeric& fmax,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesAddMirrorLines(// WS Output:
                                         ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                         // WS Generic Input:
                                         const Numeric& max_f,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCompact(// WS Output:
                                  ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                  // WS Input:
                                  const ArrayOfLineshapeSpec& abs_lineshape,
                                  const Vector& f_grid,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_lines_per_speciesCreateFromLines(// WS Output:
                                          ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfLineRecord& abs_lines,
                                          const ArrayOfArrayOfSpeciesTag& abs_species,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void abs_lines_per_speciesReadFromCatalogues(// WS Output:
                                             ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                             // WS Input:
                                             const ArrayOfArrayOfSpeciesTag& abs_species,
                                             // WS Generic Input:
                                             const ArrayOfString& filenames,
                                             const ArrayOfString& formats,
                                             const Vector& fmin,
                                             const Vector& fmax,
                                             // Verbosity object:
                                             const Verbosity& verbosity);
 
 
void abs_lines_per_speciesSetEmpty(// WS Output:
                                   ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void abs_lines_per_speciesWriteToSplitArtscat(// WS Input:
                                              const String& output_file_format,
                                              const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                              // WS Generic Input:
                                              const String& basename,
                                              // 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,
                          // WS Generic Input:
                          const Numeric& p_step,
                          const Numeric& t_step,
                          const Numeric& h2o_step,
                          const Vector& extremes,
                          // 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_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_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& method,
                     const String& unit,
                     const Numeric& dx,
                     // 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_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:
                   Matrix& abs_vec,
                   // WS Input:
                   const Tensor4& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void abs_vecAddPart(// WS Output:
                    Matrix& abs_vec,
                    // WS Input:
                    const Matrix& abs_vec_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 abs_vecInit(// WS Output:
                 Matrix& abs_vec,
                 // WS Input:
                 const Vector& f_grid,
                 const Index& stokes_dim,
                 const Index& f_index,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesAddCIA(// WS Output:
                                ArrayOfMatrix& abs_xsec_per_species,
                                // WS Input:
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                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_speciesAddConts(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  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,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const ArrayOfIndex& abs_species_active,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                  const ArrayOfLineshapeSpec& abs_lineshape,
                                  const SpeciesAuxData& isotopologue_ratios,
                                  const ArrayOfArrayOfLineMixingRecord& line_mixing_data,
                                  const ArrayOfArrayOfIndex& line_mixing_data_lut,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesInit(// WS Output:
                              ArrayOfMatrix& abs_xsec_per_species,
                              // WS Input:
                              const ArrayOfArrayOfSpeciesTag& abs_species,
                              const ArrayOfIndex& abs_species_active,
                              const Vector& f_grid,
                              const Vector& abs_p,
                              const Index& abs_xsec_agenda_checked,
                              // 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 AntennaConstantGaussian1D(// WS Output:
                               Index& antenna_dim,
                               Vector& mblock_za_grid,
                               Vector& mblock_aa_grid,
                               GriddedField4& antenna_response,
                               Matrix& antenna_los,
                               // 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_los,
                                    Index& antenna_dim,
                                    Vector& mblock_za_grid,
                                    Vector& mblock_aa_grid,
                                    // WS Input:
                                    const Index& atmosphere_dim,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void AntennaOff(// WS Output:
                Index& antenna_dim,
                Vector& mblock_za_grid,
                Vector& mblock_aa_grid,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void AntennaSet1D(// WS Output:
                  Index& antenna_dim,
                  Vector& mblock_aa_grid,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void AntennaSet2D(// WS Output:
                  Index& antenna_dim,
                  // WS Input:
                  const Index& atmosphere_dim,
                  // 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,
                              // 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,
                                     // 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 ArrayOfLineMixingRecordReadAscii(// WS Generic Output:
                                      ArrayOfLineMixingRecord& line_mixing_records,
                                      // WS Generic Input:
                                      const String& filename,
                                      // 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 AtmFieldsCalc(// 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 GriddedField3& t_field_raw,
                   const GriddedField3& z_field_raw,
                   const ArrayOfGriddedField3& vmr_field_raw,
                   const Index& atmosphere_dim,
                   // WS Generic Input:
                   const Index& interp_order,
                   const Index& vmr_zeropadding,
                   const Index& vmr_nonegative,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AtmFieldsCalcExpand1D(// 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 GriddedField3& t_field_raw,
                           const GriddedField3& z_field_raw,
                           const ArrayOfGriddedField3& vmr_field_raw,
                           const Index& atmosphere_dim,
                           // WS Generic Input:
                           const Index& interp_order,
                           const Index& vmr_zeropadding,
                           const Index& vmr_nonegative,
                           // 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,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void AtmFieldsRefinePgrid(// WS Output:
                          Vector& p_grid,
                          Tensor3& t_field,
                          Tensor3& z_field,
                          Tensor4& vmr_field,
                          // WS Input:
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const Numeric& p_step,
                          // 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 Index& abs_f_interp_order,
                           // WS Generic Input:
                           const Index& negative_vmr_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,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void atm_fields_compactAddConstant(// WS Output:
                                   GriddedField4& atm_fields_compact,
                                   // WS Generic Input:
                                   const String& name,
                                   const Numeric& value,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void atm_fields_compactAddSpecies(// WS Output:
                                  GriddedField4& atm_fields_compact,
                                  // WS Generic Input:
                                  const String& name,
                                  const GriddedField3& value,
                                  // 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 AtmFieldsFromCompact(// WS Output:
                          Vector& p_grid,
                          Vector& lat_grid,
                          Vector& lon_grid,
                          Tensor3& t_field,
                          Tensor3& z_field,
                          Tensor4& vmr_field,
                          Tensor4& massdensity_field,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const ArrayOfString& part_species,
                          const GriddedField4& atm_fields_compact,
                          const Index& atmosphere_dim,
                          // WS Generic Input:
                          const String& delim,
                          // 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,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void AtmRawRead(// WS Output:
                GriddedField3& t_field_raw,
                GriddedField3& z_field_raw,
                ArrayOfGriddedField3& vmr_field_raw,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                // WS Generic Input:
                const String& basename,
                // 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 Numeric& fwhm,
                                      const Numeric& xwidth_si,
                                      const Numeric& 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,
                                         // 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,
                                        // 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& gin1,
                                               const ArrayOfString& field_names,
                                               const ArrayOfString& extra_field_names,
                                               const Vector& extra_field_values,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void blackbody_radiationPlanck(// WS Output:
                               Vector& blackbody_radiation,
                               // WS Input:
                               const Vector& f_grid,
                               const Numeric& rtp_temperature,
                               // 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 CIAInfo(// WS Generic Input:
             const String& catalogpath,
             const ArrayOfString& cia_tags,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void CloudboxGetIncoming(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor7& scat_i_p,
                         Tensor7& scat_i_lat,
                         Tensor7& scat_i_lon,
                         // 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 Tensor3& t_field,
                         const Tensor4& vmr_field,
                         const Index& cloudbox_on,
                         const ArrayOfIndex& cloudbox_limits,
                         const Vector& f_grid,
                         const Index& stokes_dim,
                         const String& iy_unit,
                         const Agenda& blackbody_radiation_agenda,
                         const Vector& scat_za_grid,
                         const Vector& scat_aa_grid,
                         // WS Generic Input:
                         const Index& rigorous,
                         const Numeric& maxratio,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void CloudboxGetIncoming1DAtm(// Workspace reference:
                              Workspace& ws,
                              // WS Output:
                              Tensor7& scat_i_p,
                              Tensor7& scat_i_lat,
                              Tensor7& scat_i_lon,
                              Index& cloudbox_on,
                              // WS Input:
                              const Index& atmfields_checked,
                              const Index& atmgeom_checked,
                              const Index& cloudbox_checked,
                              const Agenda& iy_main_agenda,
                              const Index& atmosphere_dim,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              const Tensor3& z_field,
                              const Tensor3& t_field,
                              const Tensor4& vmr_field,
                              const ArrayOfIndex& cloudbox_limits,
                              const Vector& f_grid,
                              const Index& stokes_dim,
                              const String& iy_unit,
                              const Agenda& blackbody_radiation_agenda,
                              const Vector& scat_za_grid,
                              const Vector& scat_aa_grid,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void cloudboxOff(// WS Output:
                 Index& cloudbox_on,
                 ArrayOfIndex& cloudbox_limits,
                 Agenda& iy_cloudbox_agenda,
                 Tensor4& pnd_field,
                 ArrayOfSingleScatteringData& scat_data_array,
                 Matrix& particle_masses,
                 // 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,
                              const Tensor4& massdensity_field,
                              // WS Generic Input:
                              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,
                        // 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 ArrayOfSingleScatteringData& scat_data_array,
                          const Matrix& particle_masses,
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          // 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 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 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 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_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 dN_H11(// WS Generic Output:
            Vector& dN,
            // WS Generic Input:
            const Vector& Dmax,
            const Numeric& t,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void dN_Ar_H13(// WS Generic Output:
               Vector& dN,
               Vector& Ar,
               // WS Generic Input:
               const Vector& Dmax,
               const Numeric& t,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void dN_H98(// WS Generic Output:
            Vector& dN,
            // WS Generic Input:
            const Vector& R,
            const Numeric& LWC,
            const Vector& density,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void dN_MH97(// WS Generic Output:
             Vector& dN,
             // WS Generic Input:
             const Vector& Dme,
             const Numeric& IWC,
             const Numeric& t,
             const Vector& density,
             const Index& noisy,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void dN_F07TR(// WS Generic Output:
              Vector& dN,
              // WS Generic Input:
              const Vector& diameter_max,
              const Numeric& SWC,
              const Numeric& t,
              const Numeric& alpha,
              const Numeric& beta,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void dN_F07ML(// WS Generic Output:
              Vector& dN,
              // WS Generic Input:
              const Vector& diameter_max,
              const Numeric& SWC,
              const Numeric& t,
              const Numeric& alpha,
              const Numeric& beta,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void dN_MGD_LWC(// WS Generic Output:
                Vector& dN,
                // WS Generic Input:
                const Vector& deq,
                const Numeric& rho,
                const Numeric& LWC,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void dN_MGD_IWC(// WS Generic Output:
                Vector& dN,
                // WS Generic Input:
                const Vector& deq,
                const Numeric& rho,
                const Numeric& IWC,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void dN_MP48(// WS Generic Output:
             Vector& dN,
             // WS Generic Input:
             const Vector& Dme,
             const Numeric& PR,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void DoitAngularGridsSet(// WS Output:
                         Index& doit_za_grid_size,
                         Vector& scat_aa_grid,
                         Vector& scat_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 DoitCloudboxFieldPut(// WS Output:
                          Tensor7& scat_i_p,
                          Tensor7& scat_i_lat,
                          Tensor7& scat_i_lon,
                          Tensor4& doit_i_field1D_spectrum,
                          // WS Input:
                          const Tensor6& doit_i_field,
                          const Vector& f_grid,
                          const Index& f_index,
                          const Vector& p_grid,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Vector& scat_za_grid,
                          const Vector& scat_aa_grid,
                          const Index& stokes_dim,
                          const Index& atmosphere_dim,
                          const ArrayOfIndex& cloudbox_limits,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void doit_conv_flagAbs(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       Tensor6& doit_i_field,
                       // WS Input:
                       const Tensor6& doit_i_field_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& doit_i_field,
                         // WS Input:
                         const Tensor6& doit_i_field_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& doit_i_field,
                       // WS Input:
                       const Tensor6& doit_i_field_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 DoitInit(// WS Output:
              Index& scat_p_index,
              Index& scat_lat_index,
              Index& scat_lon_index,
              Index& scat_za_index,
              Index& scat_aa_index,
              Tensor6& doit_scat_field,
              Tensor6& doit_i_field,
              Tensor4& doit_i_field1D_spectrum,
              Tensor7& scat_i_p,
              Tensor7& scat_i_lat,
              Tensor7& scat_i_lon,
              Index& doit_is_initialized,
              // WS Input:
              const Index& stokes_dim,
              const Index& atmosphere_dim,
              const Vector& f_grid,
              const Vector& scat_za_grid,
              const Vector& scat_aa_grid,
              const Index& doit_za_grid_size,
              const Index& cloudbox_on,
              const ArrayOfIndex& cloudbox_limits,
              const ArrayOfSingleScatteringData& scat_data_array,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void doit_i_fieldIterate(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor6& doit_i_field,
                         // WS Input:
                         const Agenda& doit_scat_field_agenda,
                         const Agenda& doit_rte_agenda,
                         const Agenda& doit_conv_test_agenda,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void doit_i_fieldSetFromdoit_i_field1D_spectrum(// WS Output:
                                                Tensor6& doit_i_field,
                                                // WS Input:
                                                const Tensor4& doit_i_field1D_spectrum,
                                                const Tensor7& scat_i_p,
                                                const Vector& scat_za_grid,
                                                const Vector& f_grid,
                                                const Index& f_index,
                                                const Index& atmosphere_dim,
                                                const Index& stokes_dim,
                                                const ArrayOfIndex& cloudbox_limits,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void doit_i_fieldSetClearsky(// WS Output:
                             Tensor6& doit_i_field,
                             // WS Input:
                             const Tensor7& scat_i_p,
                             const Tensor7& scat_i_lat,
                             const Tensor7& scat_i_lon,
                             const Vector& f_grid,
                             const Index& f_index,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             const ArrayOfIndex& cloudbox_limits,
                             const Index& atmosphere_dim,
                             // WS Generic Input:
                             const Index& all_frequencies,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void doit_i_fieldSetConst(// WS Output:
                          Tensor6& doit_i_field,
                          // WS Input:
                          const Tensor7& scat_i_p,
                          const Tensor7& scat_i_lat,
                          const Tensor7& scat_i_lon,
                          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 doit_i_fieldUpdate1D(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Tensor6& doit_i_field,
                          // 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& scat_za_grid,
                          const Tensor4& pnd_field,
                          const Agenda& opt_prop_part_agenda,
                          const Agenda& ppath_step_agenda,
                          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 doit_i_fieldUpdateSeq1D(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Tensor6& doit_i_field,
                             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& scat_za_grid,
                             const Vector& scat_aa_grid,
                             const Tensor4& pnd_field,
                             const Agenda& opt_prop_part_agenda,
                             const Agenda& ppath_step_agenda,
                             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 doit_i_fieldUpdateSeq1DPP(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Tensor6& doit_i_field,
                               Index& scat_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& scat_za_grid,
                               const Tensor4& pnd_field,
                               const Agenda& opt_prop_part_agenda,
                               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 doit_i_fieldUpdateSeq3D(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Tensor6& doit_i_field,
                             // 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& scat_za_grid,
                             const Vector& scat_aa_grid,
                             const Tensor4& pnd_field,
                             const Agenda& opt_prop_part_agenda,
                             const Agenda& ppath_step_agenda,
                             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 doit_scat_fieldCalc(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor6& doit_scat_field,
                         // WS Input:
                         const Agenda& pha_mat_spt_agenda,
                         const Tensor6& doit_i_field,
                         const Tensor4& pnd_field,
                         const Tensor3& t_field,
                         const Index& atmosphere_dim,
                         const ArrayOfIndex& cloudbox_limits,
                         const Vector& scat_za_grid,
                         const Vector& scat_aa_grid,
                         const Index& doit_za_grid_size,
                         // 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& doit_i_field,
                             const Tensor4& pnd_field,
                             const Tensor3& t_field,
                             const Index& atmosphere_dim,
                             const ArrayOfIndex& cloudbox_limits,
                             const Vector& scat_za_grid,
                             const Vector& scat_aa_grid,
                             const Index& doit_za_grid_size,
                             const Index& doit_za_interp,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void DoitScatteringDataPrepare(// WS Output:
                               ArrayOfTensor7& pha_mat_sptDOITOpt,
                               ArrayOfSingleScatteringData& scat_data_array_mono,
                               // WS Input:
                               const Index& doit_za_grid_size,
                               const Vector& scat_aa_grid,
                               const ArrayOfSingleScatteringData& scat_data_array,
                               const Vector& f_grid,
                               const Index& f_index,
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void DoitWriteIterationFields(// WS Input:
                              const Index& doit_iteration_counter,
                              const Tensor6& doit_i_field,
                              // WS Generic Input:
                              const ArrayOfIndex& iterations,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void doit_za_grid_optCalc(// WS Output:
                          Vector& doit_za_grid_opt,
                          // WS Input:
                          const Tensor6& doit_i_field,
                          const Vector& scat_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 Error(// WS Generic Input:
           const String& msg,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void Exit(// Verbosity object:
          const Verbosity& verbosity);
 
 
void ExtractFromMetaSinglePartSpecies(// WS Generic Output:
                                      Vector& meta_param,
                                      // WS Input:
                                      const ArrayOfScatteringMetaData& scat_meta_array,
                                      const ArrayOfIndex& scat_data_per_part_species,
                                      // WS Generic Input:
                                      const String& meta_name,
                                      const Index& part_species_index,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void ext_matAddGas(// WS Output:
                   Tensor3& ext_mat,
                   // WS Input:
                   const Tensor4& propmat_clearsky,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void ext_matAddPart(// WS Output:
                    Tensor3& ext_mat,
                    // WS Input:
                    const Tensor3& ext_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 ext_matInit(// WS Output:
                 Tensor3& ext_mat,
                 // WS Input:
                 const Vector& f_grid,
                 const Index& stokes_dim,
                 const Index& f_index,
                 // 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 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 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 g0Earth(// WS Output:
             Numeric& g0,
             // WS Input:
             const Numeric& lat,
             // 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 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 INCLUDE(// 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 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 isotopologue_ratiosInitFromBuiltin(// WS Output:
                                        SpeciesAuxData& isotopologue_ratios,
                                        // Verbosity object:
                                        const Verbosity& verbosity);
 
 
void iyApplyUnit(// WS Output:
                 Matrix& iy,
                 ArrayOfTensor4& 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,
            ArrayOfTensor4& iy_aux,
            Ppath& ppath,
            // WS Input:
            const Index& atmgeom_checked,
            const Index& atmfields_checked,
            const ArrayOfString& iy_aux_vars,
            const Vector& f_grid,
            const Tensor3& t_field,
            const Tensor3& z_field,
            const Tensor4& vmr_field,
            const Index& cloudbox_on,
            const Index& cloudbox_checked,
            const Vector& rte_pos,
            const Vector& rte_los,
            const Vector& rte_pos2,
            const Agenda& iy_main_agenda,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void iyCloudRadar(// Workspace reference:
                  Workspace& ws,
                  // WS Output:
                  Matrix& iy,
                  ArrayOfTensor4& iy_aux,
                  Ppath& ppath,
                  // WS Input:
                  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 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 Index& cloudbox_on,
                  const ArrayOfIndex& cloudbox_limits,
                  const Tensor4& pnd_field,
                  const Index& use_mean_scat_data,
                  const ArrayOfSingleScatteringData& scat_data_array,
                  const Matrix& particle_masses,
                  const String& iy_unit,
                  const ArrayOfString& iy_aux_vars,
                  const Index& jacobian_do,
                  const Agenda& ppath_agenda,
                  const Agenda& propmat_clearsky_agenda,
                  const Agenda& iy_transmitter_agenda,
                  const Index& iy_agenda_call1,
                  const Tensor3& iy_transmission,
                  const Vector& rte_pos,
                  const Vector& rte_los,
                  const Numeric& rte_alonglos_v,
                  const Numeric& ppath_lraytrace,
                  // WS Generic Input:
                  const Numeric& ze_tref,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void iyEmissionStandard(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        Matrix& iy,
                        ArrayOfTensor4& iy_aux,
                        Ppath& ppath,
                        ArrayOfTensor3& diy_dx,
                        // WS Input:
                        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 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 ArrayOfArrayOfIndex& jacobian_indices,
                        const Agenda& ppath_agenda,
                        const Agenda& blackbody_radiation_agenda,
                        const Agenda& propmat_clearsky_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 Vector& rte_pos,
                        const Vector& rte_los,
                        const Vector& rte_pos2,
                        const Numeric& rte_alonglos_v,
                        const Numeric& ppath_lraytrace,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void iyFOS(// Workspace reference:
           Workspace& ws,
           // WS Output:
           Matrix& iy,
           ArrayOfTensor4& iy_aux,
           Ppath& ppath,
           ArrayOfTensor3& diy_dx,
           // WS Input:
           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 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 Index& use_mean_scat_data,
           const ArrayOfSingleScatteringData& scat_data_array,
           const Matrix& particle_masses,
           const String& iy_unit,
           const ArrayOfString& iy_aux_vars,
           const Index& jacobian_do,
           const Agenda& ppath_agenda,
           const Agenda& blackbody_radiation_agenda,
           const Agenda& propmat_clearsky_agenda,
           const Agenda& iy_main_agenda,
           const Agenda& iy_space_agenda,
           const Agenda& iy_surface_agenda,
           const Index& iy_agenda_call1,
           const Tensor3& iy_transmission,
           const Vector& rte_pos,
           const Vector& rte_los,
           const Vector& rte_pos2,
           const Numeric& rte_alonglos_v,
           const Numeric& ppath_lraytrace,
           const Matrix& fos_scatint_angles,
           const Vector& fos_iyin_za_angles,
           // WS Generic Input:
           const Index& fos_za_interporder,
           const Index& fos_n,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void iyMC(// Workspace reference:
          Workspace& ws,
          // WS Output:
          Matrix& iy,
          ArrayOfTensor4& 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 ArrayOfSingleScatteringData& scat_data_array,
          const Agenda& iy_space_agenda,
          const Agenda& surface_rtprop_agenda,
          const Agenda& propmat_clearsky_agenda,
          const Agenda& ppath_step_agenda,
          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,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void iyInterpCloudboxField(// WS Output:
                           Matrix& iy,
                           // WS Input:
                           const Tensor7& scat_i_p,
                           const Tensor7& scat_i_lat,
                           const Tensor7& scat_i_lon,
                           const Tensor4& doit_i_field1D_spectrum,
                           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 Index& stokes_dim,
                           const Vector& scat_za_grid,
                           const Vector& scat_aa_grid,
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Index& rigorous,
                           const Numeric& maxratio,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void iyInterpPolyCloudboxField(// WS Output:
                               Matrix& iy,
                               // WS Input:
                               const Tensor7& scat_i_p,
                               const Tensor7& scat_i_lat,
                               const Tensor7& scat_i_lon,
                               const Tensor4& doit_i_field1D_spectrum,
                               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 Index& stokes_dim,
                               const Vector& scat_za_grid,
                               const Vector& scat_aa_grid,
                               const Vector& f_grid,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void iyLoopFrequencies(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Matrix& iy,
                       ArrayOfTensor4& iy_aux,
                       Ppath& ppath,
                       ArrayOfTensor3& diy_dx,
                       // WS Input:
                       const ArrayOfString& iy_aux_vars,
                       const Index& stokes_dim,
                       const Vector& f_grid,
                       const Tensor3& t_field,
                       const Tensor3& z_field,
                       const Tensor4& vmr_field,
                       const Index& cloudbox_on,
                       const Index& iy_agenda_call1,
                       const Tensor3& iy_transmission,
                       const Vector& rte_pos,
                       const Vector& rte_los,
                       const Vector& rte_pos2,
                       const Index& jacobian_do,
                       const Agenda& iy_sub_agenda,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void iyRadioLink(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 Matrix& iy,
                 ArrayOfTensor4& iy_aux,
                 Ppath& ppath,
                 ArrayOfTensor3& diy_dx,
                 // WS Input:
                 const Index& stokes_dim,
                 const Vector& f_grid,
                 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 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 Vector& refellipsoid,
                 const Matrix& z_surface,
                 const Index& cloudbox_on,
                 const ArrayOfIndex& cloudbox_limits,
                 const Tensor4& pnd_field,
                 const Index& use_mean_scat_data,
                 const ArrayOfSingleScatteringData& scat_data_array,
                 const Matrix& particle_masses,
                 const ArrayOfString& iy_aux_vars,
                 const Index& jacobian_do,
                 const Agenda& ppath_agenda,
                 const Agenda& ppath_step_agenda,
                 const Agenda& propmat_clearsky_agenda,
                 const Agenda& iy_transmitter_agenda,
                 const Index& iy_agenda_call1,
                 const Tensor3& iy_transmission,
                 const Vector& rte_pos,
                 const Vector& rte_los,
                 const Vector& rte_pos2,
                 const Numeric& rte_alonglos_v,
                 const Numeric& ppath_lraytrace,
                 // WS Generic Input:
                 const Index& defocus_method,
                 const Numeric& defocus_shift,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void iyReplaceFromAux(// WS Output:
                      Matrix& iy,
                      // WS Input:
                      const ArrayOfTensor4& iy_aux,
                      const ArrayOfString& iy_aux_vars,
                      const Index& jacobian_do,
                      // WS Generic Input:
                      const String& aux_var,
                      // 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& jacobian_do,
                           const Index& atmosphere_dim,
                           const Tensor3& t_field,
                           const Tensor3& z_field,
                           const Tensor4& vmr_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 Agenda& iy_main_agenda,
                           const Agenda& surface_rtprop_agenda,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void iyTransmissionStandard(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Matrix& iy,
                            ArrayOfTensor4& iy_aux,
                            Ppath& ppath,
                            ArrayOfTensor3& diy_dx,
                            // WS Input:
                            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 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 Index& use_mean_scat_data,
                            const ArrayOfSingleScatteringData& scat_data_array,
                            const Matrix& particle_masses,
                            const ArrayOfString& iy_aux_vars,
                            const Index& jacobian_do,
                            const ArrayOfRetrievalQuantity& jacobian_quantities,
                            const ArrayOfArrayOfIndex& jacobian_indices,
                            const Agenda& ppath_agenda,
                            const Agenda& propmat_clearsky_agenda,
                            const Agenda& iy_transmitter_agenda,
                            const Index& iy_agenda_call1,
                            const Tensor3& iy_transmission,
                            const Vector& rte_pos,
                            const Vector& rte_los,
                            const Vector& rte_pos2,
                            const Numeric& rte_alonglos_v,
                            const Numeric& ppath_lraytrace,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void iy_auxFillParticleVariables(// WS Output:
                                 ArrayOfTensor4& iy_aux,
                                 // WS Input:
                                 const Index& atmfields_checked,
                                 const Index& cloudbox_checked,
                                 const Index& atmosphere_dim,
                                 const Index& cloudbox_on,
                                 const ArrayOfIndex& cloudbox_limits,
                                 const Tensor4& pnd_field,
                                 const Matrix& particle_masses,
                                 const Ppath& ppath,
                                 const ArrayOfString& iy_aux_vars,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void iy_transmitterMultiplePol(// WS Output:
                               Matrix& iy,
                               // WS Input:
                               const Index& stokes_dim,
                               const Vector& f_grid,
                               const ArrayOfIndex& sensor_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& sensor_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& method,
                           const String& unit,
                           const Numeric& dx,
                           // 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,
                          const Matrix& sensor_pos,
                          const Vector& sensor_time,
                          // WS Generic Input:
                          const Index& poly_order,
                          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,
                            const Matrix& sensor_pos,
                            const Vector& sensor_time,
                            // WS Generic Input:
                            const Index& poly_order,
                            const Numeric& df,
                            // 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 Vector& sensor_response_za_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 jacobianAddSinefit(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        ArrayOfRetrievalQuantity& jacobian_quantities,
                        Agenda& jacobian_agenda,
                        // WS Input:
                        const ArrayOfIndex& sensor_response_pol_grid,
                        const Vector& sensor_response_za_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 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,
                            const String& method,
                            const Numeric& dt,
                            // 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,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void jacobianCalcAbsSpeciesAnalytical(// WS Output:
                                      Matrix& jacobian,
                                      // WS Input:
                                      const Index& mblock_index,
                                      const Vector& iyb,
                                      const Vector& yb,
                                      // Verbosity object:
                                      const Verbosity& verbosity);
 
 
void jacobianCalcAbsSpeciesPerturbations(// 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 Vector& p_grid,
                                         const Vector& lat_grid,
                                         const Vector& lon_grid,
                                         const Tensor3& t_field,
                                         const Tensor3& z_field,
                                         const Tensor4& vmr_field,
                                         const ArrayOfArrayOfSpeciesTag& abs_species,
                                         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 Vector& mblock_za_grid,
                                         const Vector& mblock_aa_grid,
                                         const Index& antenna_dim,
                                         const Sparse& sensor_response,
                                         const Agenda& iy_main_agenda,
                                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                                         const ArrayOfArrayOfIndex& jacobian_indices,
                                         // WS Generic Input:
                                         const String& species,
                                         // 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& sensor_los,
                           const Vector& mblock_za_grid,
                           const Vector& mblock_aa_grid,
                           const Index& antenna_dim,
                           const Sparse& sensor_response,
                           const Vector& sensor_time,
                           const ArrayOfRetrievalQuantity& jacobian_quantities,
                           const ArrayOfArrayOfIndex& jacobian_indices,
                           // 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& sensor_los,
                             const Vector& mblock_za_grid,
                             const Vector& mblock_aa_grid,
                             const Index& antenna_dim,
                             const Sparse& sensor_response,
                             const ArrayOfIndex& sensor_response_pol_grid,
                             const Vector& sensor_response_f_grid,
                             const Vector& sensor_response_za_grid,
                             const Vector& sensor_time,
                             const ArrayOfRetrievalQuantity& jacobian_quantities,
                             const ArrayOfArrayOfIndex& jacobian_indices,
                             // 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 Vector& mblock_za_grid,
                                  const Vector& mblock_aa_grid,
                                  const Index& antenna_dim,
                                  const Sparse& sensor_response,
                                  const Vector& sensor_time,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfArrayOfIndex& jacobian_indices,
                                  // 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 Tensor3& t_field,
                                  const Tensor3& z_field,
                                  const Tensor4& vmr_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 Vector& mblock_za_grid,
                                  const Vector& mblock_aa_grid,
                                  const Index& antenna_dim,
                                  const Sparse& sensor_response,
                                  const Vector& sensor_time,
                                  const Agenda& iy_main_agenda,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfArrayOfIndex& jacobian_indices,
                                  // 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 Vector& sensor_response_za_grid,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const ArrayOfArrayOfIndex& jacobian_indices,
                         // 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 Vector& sensor_response_za_grid,
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const ArrayOfArrayOfIndex& jacobian_indices,
                         // WS Generic Input:
                         const Index& period_index,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void jacobianCalcTemperatureAnalytical(// WS Output:
                                       Matrix& jacobian,
                                       // WS Input:
                                       const Index& mblock_index,
                                       const Vector& iyb,
                                       const Vector& yb,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void jacobianCalcTemperaturePerturbations(// 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 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 ArrayOfArrayOfSpeciesTag& abs_species,
                                          const Vector& refellipsoid,
                                          const Matrix& z_surface,
                                          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 Vector& mblock_za_grid,
                                          const Vector& mblock_aa_grid,
                                          const Index& antenna_dim,
                                          const Sparse& sensor_response,
                                          const Agenda& iy_main_agenda,
                                          const Agenda& g0_agenda,
                                          const Numeric& molarmass_dry_air,
                                          const Numeric& p_hse,
                                          const Numeric& z_hse_accuracy,
                                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                                          const ArrayOfArrayOfIndex& jacobian_indices,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void jacobianCalcWindAnalytical(// WS Output:
                                Matrix& jacobian,
                                // WS Input:
                                const Index& mblock_index,
                                const Vector& iyb,
                                const Vector& yb,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void jacobianClose(// Workspace reference:
                   Workspace& ws,
                   // WS Output:
                   Index& jacobian_do,
                   ArrayOfArrayOfIndex& jacobian_indices,
                   Agenda& jacobian_agenda,
                   // WS Input:
                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                   const Matrix& sensor_pos,
                   const Sparse& sensor_response,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void jacobianInit(// WS Output:
                  ArrayOfRetrievalQuantity& jacobian_quantities,
                  ArrayOfArrayOfIndex& jacobian_indices,
                  Agenda& jacobian_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void jacobianOff(// WS Output:
                 Index& jacobian_do,
                 Agenda& jacobian_agenda,
                 ArrayOfRetrievalQuantity& jacobian_quantities,
                 ArrayOfArrayOfIndex& jacobian_indices,
                 // 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 lon_gridFromRawField(// WS Output:
                          Vector& lon_grid,
                          // WS Generic Input:
                          const GriddedField3& field_raw,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void line_mixing_dataInit(// WS Output:
                          ArrayOfArrayOfLineMixingRecord& line_mixing_data,
                          ArrayOfArrayOfIndex& line_mixing_data_lut,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void line_mixing_dataMatch(// WS Output:
                           ArrayOfArrayOfLineMixingRecord& line_mixing_data,
                           ArrayOfArrayOfIndex& line_mixing_data_lut,
                           // WS Input:
                           const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                           const ArrayOfArrayOfSpeciesTag& abs_species,
                           // WS Generic Input:
                           const String& species_tag,
                           const ArrayOfLineMixingRecord& line_mixing_records,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Massdensity_cleanup(// WS Output:
                         Tensor4& massdensity_field,
                         // WS Generic Input:
                         const Numeric& massdensity_threshold,
                         // 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 MatrixExtractFromTensor3(// WS Generic Output:
                              Matrix& out,
                              // WS Generic Input:
                              const Tensor3& in,
                              const Index& i,
                              const String& direction,
                              // 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 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 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,
               // 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_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 ArrayOfSingleScatteringData& scat_data_array_mono,
               const Index& atmfields_checked,
               const Index& atmgeom_checked,
               const Index& cloudbox_checked,
               const Index& mc_seed,
               const String& iy_unit,
               const Numeric& mc_std_err,
               const Index& mc_max_time,
               const Index& mc_max_iter,
               const Index& mc_min_iter,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MCSetSeedFromTime(// WS Output:
                       Index& mc_seed,
                       // 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 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 opt_prop_sptFromData(// WS Output:
                          Tensor3& ext_mat_spt,
                          Matrix& abs_vec_spt,
                          // WS Input:
                          const ArrayOfSingleScatteringData& scat_data_array,
                          const Vector& scat_za_grid,
                          const Vector& scat_aa_grid,
                          const Index& scat_za_index,
                          const Index& scat_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_sptFromMonoData(// WS Output:
                              Tensor3& ext_mat_spt,
                              Matrix& abs_vec_spt,
                              // WS Input:
                              const ArrayOfSingleScatteringData& scat_data_array_mono,
                              const Vector& scat_za_grid,
                              const Vector& scat_aa_grid,
                              const Index& scat_za_index,
                              const Index& scat_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_massesFromMetaDataSingleCategory(// WS Output:
                                               Matrix& particle_masses,
                                               // WS Input:
                                               const ArrayOfScatteringMetaData& scat_meta_array,
                                               // Verbosity object:
                                               const Verbosity& verbosity);
 
 
void particle_massesFromMetaDataAndPart_species(// WS Output:
                                                Matrix& particle_masses,
                                                // WS Input:
                                                const ArrayOfScatteringMetaData& scat_meta_array,
                                                const ArrayOfIndex& scat_data_per_part_species,
                                                const ArrayOfString& part_species,
                                                // Verbosity object:
                                                const Verbosity& verbosity);
 
 
void ParticleSpeciesInit(// WS Output:
                         ArrayOfString& part_species,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ParticleSpeciesSet(// WS Output:
                        ArrayOfString& part_species,
                        // WS Generic Input:
                        const ArrayOfString& particle_tags,
                        const String& delim,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ParticleTypeAdd(// WS Output:
                     ArrayOfSingleScatteringData& scat_data_array,
                     ArrayOfGriddedField3& pnd_field_raw,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& f_grid,
                     // WS Generic Input:
                     const String& filename_scat_data,
                     const String& filename_pnd_field,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ParticleTypeAddAll(// WS Output:
                        ArrayOfSingleScatteringData& scat_data_array,
                        ArrayOfGriddedField3& pnd_field_raw,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Vector& f_grid,
                        // WS Generic Input:
                        const String& filelist_scat_data,
                        const String& filename_pnd_fieldarray,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ParticleTypeInit(// WS Output:
                      ArrayOfSingleScatteringData& scat_data_array,
                      ArrayOfGriddedField3& pnd_field_raw,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ParticleType2abs_speciesAdd(// WS Output:
                                 ArrayOfSingleScatteringData& scat_data_array,
                                 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 String& filename_scat_data,
                                 const String& filename_pnd_field,
                                 // 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 ArrayOfSingleScatteringData& scat_data_array,
                         const Vector& scat_za_grid,
                         const Vector& scat_aa_grid,
                         const Index& scat_za_index,
                         const Index& scat_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_sptFromMonoData(// WS Output:
                             Tensor5& pha_mat_spt,
                             // WS Input:
                             const ArrayOfSingleScatteringData& scat_data_array_mono,
                             const Index& doit_za_grid_size,
                             const Vector& scat_aa_grid,
                             const Index& scat_za_index,
                             const Index& scat_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_sptFromDataDOITOpt(// WS Output:
                                Tensor5& pha_mat_spt,
                                // WS Input:
                                const ArrayOfTensor7& pha_mat_sptDOITOpt,
                                const ArrayOfSingleScatteringData& scat_data_array_mono,
                                const Index& doit_za_grid_size,
                                const Vector& scat_aa_grid,
                                const Index& scat_za_index,
                                const Index& scat_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 pnd_fieldCalc(// WS Output:
                   Tensor4& pnd_field,
                   // 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,
                   // 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_fieldSetup(// WS Output:
                    Tensor4& pnd_field,
                    // WS Input:
                    const Index& atmosphere_dim,
                    const Index& cloudbox_on,
                    const ArrayOfIndex& cloudbox_limits,
                    const Tensor4& massdensity_field,
                    const Tensor3& t_field,
                    const ArrayOfScatteringMetaData& scat_meta_array,
                    const ArrayOfString& part_species,
                    const ArrayOfIndex& scat_data_per_part_species,
                    // WS Generic Input:
                    const String& delim,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void pnd_fieldZero(// WS Output:
                   Tensor4& pnd_field,
                   ArrayOfSingleScatteringData& scat_data_array,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void pndFromdN(// WS Generic Output:
               Vector& pnd,
               // WS Generic Input:
               const Vector& dN,
               const Vector& diameter,
               const Numeric& total_content,
               const Vector& scatelem_volume,
               const Vector& scatelem_density,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void ppathCalc(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Ppath& ppath,
               // WS Input:
               const Agenda& ppath_agenda,
               const Numeric& ppath_lraytrace,
               const Index& atmgeom_checked,
               const Tensor3& t_field,
               const Tensor3& z_field,
               const Tensor4& vmr_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,
               // 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& t_field,
                      const Tensor3& z_field,
                      const Tensor4& vmr_field,
                      const Vector& f_grid,
                      const Vector& refellipsoid,
                      const Matrix& z_surface,
                      const Vector& rte_pos,
                      const Vector& rte_pos2,
                      // WS Generic Input:
                      const Numeric& za_accuracy,
                      const Numeric& pplrt_factor,
                      const Numeric& pplrt_lowest,
                      // 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& t_field,
                     const Tensor3& z_field,
                     const Tensor4& vmr_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_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 propmat_clearskyAddFaraday(// WS Output:
                                Tensor4& propmat_clearsky,
                                // WS Input:
                                const Index& stokes_dim,
                                const Index& atmosphere_dim,
                                const Vector& f_grid,
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                const Vector& rtp_vmr,
                                const Vector& rtp_los,
                                const Vector& rtp_mag,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void propmat_clearskyAddFromAbsCoefPerSpecies(// WS Output:
                                              Tensor4& propmat_clearsky,
                                              // WS Input:
                                              const ArrayOfMatrix& abs_coef_per_species,
                                              // Verbosity object:
                                              const Verbosity& verbosity);
 
 
void propmat_clearskyAddFromLookup(// WS Output:
                                   Tensor4& propmat_clearsky,
                                   // 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,
                                   // WS Generic Input:
                                   const Numeric& extpolfac,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void propmat_clearskyAddOnTheFly(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Tensor4& propmat_clearsky,
                                 // WS Input:
                                 const Vector& f_grid,
                                 const ArrayOfArrayOfSpeciesTag& abs_species,
                                 const Numeric& rtp_pressure,
                                 const Numeric& rtp_temperature,
                                 const Vector& rtp_vmr,
                                 const Agenda& abs_xsec_agenda,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void propmat_clearskyAddParticles(// WS Output:
                                  Tensor4& propmat_clearsky,
                                  // WS Input:
                                  const Index& stokes_dim,
                                  const Index& atmosphere_dim,
                                  const Vector& f_grid,
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const Vector& rtp_vmr,
                                  const Vector& rtp_los,
                                  const Numeric& rtp_temperature,
                                  const ArrayOfSingleScatteringData& scat_data_array,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void propmat_clearskyAddZeeman(// WS Output:
                               Tensor4& propmat_clearsky,
                               // WS Input:
                               const Vector& f_grid,
                               const ArrayOfArrayOfSpeciesTag& abs_species,
                               const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                               const ArrayOfLineshapeSpec& abs_lineshape,
                               const SpeciesAuxData& isotopologue_ratios,
                               const SpeciesAuxData& isotopologue_quantum,
                               const Numeric& rtp_pressure,
                               const Numeric& rtp_temperature,
                               const Vector& rtp_vmr,
                               const Vector& rtp_mag,
                               const Vector& rtp_los,
                               const Index& atmosphere_dim,
                               const ArrayOfArrayOfLineMixingRecord& line_mixing_data,
                               const ArrayOfArrayOfIndex& line_mixing_data_lut,
                               // 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:
                          Tensor4& propmat_clearsky,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          const Index& propmat_clearsky_agenda_checked,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void propmat_clearskyZero(// WS Output:
                          Tensor4& propmat_clearsky,
                          // WS Input:
                          const Vector& f_grid,
                          const Index& stokes_dim,
                          // 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,
                                // 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 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 p_gridDensify(// WS Output:
                   Vector& p_grid,
                   // WS Generic Input:
                   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 p_gridFromGasAbsLookup(// WS Output:
                            Vector& p_grid,
                            // WS Input:
                            const GasAbsLookup& abs_lookup,
                            // 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 refellipsoidForAzimuth(// WS Output:
                            Vector& refellipsoid,
                            // WS Generic Input:
                            const Numeric& latitude,
                            const Numeric& azimuth,
                            // 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_airIR(// 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_airMWgeneral(// 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 refr_index_airThayer(// 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& a,
                          const Numeric& b,
                          const Numeric& c,
                          // 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 ScatteringDisort(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      Tensor7& scat_i_p,
                      Tensor7& scat_i_lat,
                      Tensor7& scat_i_lon,
                      Index& f_index,
                      ArrayOfSingleScatteringData& scat_data_array_mono,
                      Tensor4& doit_i_field1D_spectrum,
                      // WS Input:
                      const Index& atmfields_checked,
                      const Index& atmgeom_checked,
                      const Index& cloudbox_checked,
                      const ArrayOfIndex& cloudbox_limits,
                      const Index& stokes_dim,
                      const Agenda& opt_prop_part_agenda,
                      const Agenda& propmat_clearsky_agenda,
                      const Agenda& spt_calc_agenda,
                      const Tensor4& pnd_field,
                      const Tensor3& t_field,
                      const Tensor3& z_field,
                      const Vector& p_grid,
                      const Tensor4& vmr_field,
                      const ArrayOfSingleScatteringData& scat_data_array,
                      const Vector& f_grid,
                      const Vector& scat_za_grid,
                      const Matrix& surface_emissivity_DISORT,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void ScatteringDoit(// Workspace reference:
                    Workspace& ws,
                    // WS Output:
                    Tensor6& doit_i_field,
                    Tensor7& scat_i_p,
                    Tensor7& scat_i_lat,
                    Tensor7& scat_i_lon,
                    Tensor4& doit_i_field1D_spectrum,
                    // WS Input:
                    const Index& atmfields_checked,
                    const Index& atmgeom_checked,
                    const Index& cloudbox_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 ScatteringMergeParticles1D(// WS Output:
                                Tensor4& pnd_field,
                                ArrayOfSingleScatteringData& scat_data_array,
                                // 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,
                                const Index& cloudbox_checked,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ScatteringParticleTypeAndMetaRead(// WS Output:
                                       ArrayOfSingleScatteringData& scat_data_array,
                                       ArrayOfScatteringMetaData& scat_meta_array,
                                       // WS Input:
                                       const Vector& f_grid,
                                       // WS Generic Input:
                                       const String& filename_scat_data,
                                       const String& filename_scat_meta_data,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ScatteringParticlesSelect(// WS Output:
                               ArrayOfSingleScatteringData& scat_data_array,
                               ArrayOfScatteringMetaData& scat_meta_array,
                               ArrayOfIndex& scat_data_per_part_species,
                               // WS Input:
                               const ArrayOfString& part_species,
                               // WS Generic Input:
                               const String& delim,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void scat_meta_arrayAddTmatrix(// WS Output:
                               ArrayOfScatteringMetaData& scat_meta_array,
                               // WS Input:
                               const GriddedField3& complex_refr_index,
                               // WS Generic Input:
                               const String& description,
                               const String& material,
                               const String& shape,
                               const String& particle_type,
                               const Numeric& density,
                               const Vector& aspect_ratio_grid,
                               const Vector& diameter_max_grid,
                               const Vector& scat_f_grid,
                               const Vector& scat_T_grid,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void scat_meta_arrayAddTmatrixOldVersion(// WS Output:
                                         ArrayOfScatteringMetaData& scat_meta_array,
                                         // WS Input:
                                         const GriddedField3& complex_refr_index,
                                         // WS Generic Input:
                                         const String& description,
                                         const String& material,
                                         const String& shape,
                                         const String& particle_type,
                                         const Numeric& density,
                                         const Numeric& aspect_ratio,
                                         const Vector& diameter_grid,
                                         const Vector& scat_f_grid,
                                         const Vector& scat_T_grid,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void scat_meta_arrayInit(// WS Output:
                         ArrayOfScatteringMetaData& scat_meta_array,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void scat_data_array_monoCalc(// WS Output:
                              ArrayOfSingleScatteringData& scat_data_array_mono,
                              // WS Input:
                              const ArrayOfSingleScatteringData& scat_data_array,
                              const Vector& f_grid,
                              const Index& f_index,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void scat_data_arrayCheck(// WS Input:
                          const ArrayOfSingleScatteringData& scat_data_array,
                          // WS Generic Input:
                          const Numeric& threshold,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void scat_data_arrayFromMeta(// WS Output:
                             ArrayOfSingleScatteringData& scat_data_array,
                             // WS Input:
                             const ArrayOfScatteringMetaData& scat_meta_array,
                             // WS Generic Input:
                             const Vector& za_grid,
                             const Vector& aa_grid,
                             const Numeric& precision,
                             // 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 Vector& mblock_za_grid,
                        const Vector& mblock_aa_grid,
                        const Index& antenna_dim,
                        const Sparse& sensor_response,
                        const Vector& sensor_response_f,
                        const ArrayOfIndex& sensor_response_pol,
                        const Vector& sensor_response_za,
                        const Vector& sensor_response_aa,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void sensorOff(// WS Output:
               Sparse& sensor_response,
               Vector& sensor_response_f,
               ArrayOfIndex& sensor_response_pol,
               Vector& sensor_response_za,
               Vector& sensor_response_aa,
               Vector& sensor_response_f_grid,
               ArrayOfIndex& sensor_response_pol_grid,
               Vector& sensor_response_za_grid,
               Vector& sensor_response_aa_grid,
               Index& antenna_dim,
               Vector& mblock_za_grid,
               Vector& mblock_aa_grid,
               // WS Input:
               const Index& stokes_dim,
               const Vector& f_grid,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void sensor_responseAntenna(// WS Output:
                            Sparse& sensor_response,
                            Vector& sensor_response_f,
                            ArrayOfIndex& sensor_response_pol,
                            Vector& sensor_response_za,
                            Vector& sensor_response_aa,
                            Vector& sensor_response_za_grid,
                            Vector& sensor_response_aa_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_los,
                            const GriddedField4& antenna_response,
                            const Index& sensor_norm,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void sensor_responseBackend(// WS Output:
                            Sparse& sensor_response,
                            Vector& sensor_response_f,
                            ArrayOfIndex& sensor_response_pol,
                            Vector& sensor_response_za,
                            Vector& sensor_response_aa,
                            Vector& sensor_response_f_grid,
                            // WS Input:
                            const ArrayOfIndex& sensor_response_pol_grid,
                            const Vector& sensor_response_za_grid,
                            const Vector& sensor_response_aa_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,
                                              Vector& sensor_response_za,
                                              Vector& sensor_response_aa,
                                              Vector& sensor_response_f_grid,
                                              // WS Input:
                                              const ArrayOfIndex& sensor_response_pol_grid,
                                              const Vector& sensor_response_za_grid,
                                              const Vector& sensor_response_aa_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,
                                  Vector& sensor_response_za,
                                  Vector& sensor_response_aa,
                                  Vector& sensor_response_za_grid,
                                  Vector& sensor_response_aa_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,
                              Vector& sensor_response_za,
                              Vector& sensor_response_aa,
                              Vector& sensor_response_f_grid,
                              // WS Input:
                              const ArrayOfIndex& sensor_response_pol_grid,
                              const Vector& sensor_response_za_grid,
                              const Vector& sensor_response_aa_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,
                                       Vector& sensor_response_za,
                                       Vector& sensor_response_aa,
                                       Vector& sensor_response_f_grid,
                                       // WS Input:
                                       const ArrayOfIndex& sensor_response_pol_grid,
                                       const Vector& sensor_response_za_grid,
                                       const Vector& sensor_response_aa_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,
                         Vector& sensor_response_za,
                         Vector& sensor_response_aa,
                         Vector& sensor_response_f_grid,
                         ArrayOfIndex& sensor_response_pol_grid,
                         Vector& sensor_response_za_grid,
                         Vector& sensor_response_aa_grid,
                         // WS Input:
                         const Vector& f_grid,
                         const Vector& mblock_za_grid,
                         const Vector& mblock_aa_grid,
                         const Index& antenna_dim,
                         const Index& atmosphere_dim,
                         const Index& stokes_dim,
                         const Index& sensor_norm,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void sensor_responseMixer(// WS Output:
                          Sparse& sensor_response,
                          Vector& sensor_response_f,
                          ArrayOfIndex& sensor_response_pol,
                          Vector& sensor_response_za,
                          Vector& sensor_response_aa,
                          Vector& sensor_response_f_grid,
                          // WS Input:
                          const ArrayOfIndex& sensor_response_pol_grid,
                          const Vector& sensor_response_za_grid,
                          const Vector& sensor_response_aa_grid,
                          const Numeric& lo,
                          const GriddedField1& sideband_response,
                          const Index& sensor_norm,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void sensor_responseMultiMixerBackend(// WS Output:
                                      Sparse& sensor_response,
                                      Vector& sensor_response_f,
                                      ArrayOfIndex& sensor_response_pol,
                                      Vector& sensor_response_za,
                                      Vector& sensor_response_aa,
                                      Vector& sensor_response_f_grid,
                                      // WS Input:
                                      const ArrayOfIndex& sensor_response_pol_grid,
                                      const Vector& sensor_response_za_grid,
                                      const Vector& sensor_response_aa_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,
                                 Vector& sensor_response_za,
                                 Vector& sensor_response_aa,
                                 ArrayOfIndex& sensor_response_pol_grid,
                                 // WS Input:
                                 const Vector& sensor_response_f_grid,
                                 const Vector& sensor_response_za_grid,
                                 const Vector& sensor_response_aa_grid,
                                 const Index& stokes_dim,
                                 const String& iy_unit,
                                 const ArrayOfIndex& sensor_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 Vector& sensor_response_za_grid,
                                   const Vector& sensor_response_aa_grid,
                                   const Index& stokes_dim,
                                   const Matrix& stokes_rotation,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void sensor_responseSimpleAMSU(// WS Output:
                               Vector& f_grid,
                               Index& antenna_dim,
                               Vector& mblock_za_grid,
                               Vector& mblock_aa_grid,
                               Sparse& sensor_response,
                               Vector& sensor_response_f,
                               ArrayOfIndex& sensor_response_pol,
                               Vector& sensor_response_za,
                               Vector& sensor_response_aa,
                               Vector& sensor_response_f_grid,
                               ArrayOfIndex& sensor_response_pol_grid,
                               Vector& sensor_response_za_grid,
                               Vector& sensor_response_aa_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,
                                Vector& mblock_za_grid,
                                Vector& mblock_aa_grid,
                                Sparse& sensor_response,
                                Vector& sensor_response_f,
                                ArrayOfIndex& sensor_response_pol,
                                Vector& sensor_response_za,
                                Vector& sensor_response_aa,
                                Vector& sensor_response_f_grid,
                                ArrayOfIndex& sensor_response_pol_grid,
                                Vector& sensor_response_za_grid,
                                Vector& sensor_response_aa_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,
                         Vector& sensor_response_za,
                         Vector& sensor_response_aa,
                         Vector& sensor_response_f_grid,
                         // WS Input:
                         const ArrayOfIndex& sensor_response_pol_grid,
                         const Vector& sensor_response_za_grid,
                         const Vector& sensor_response_aa_grid,
                         const Sparse& wmrf_weights,
                         const Vector& f_backend,
                         // 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 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,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void StringCompose(// 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 surfaceBlackbody(// Workspace reference:
                      Workspace& ws,
                      // WS Output:
                      Matrix& surface_los,
                      Tensor4& surface_rmatrix,
                      Matrix& surface_emission,
                      // WS Input:
                      const Vector& f_grid,
                      const Index& stokes_dim,
                      const Numeric& surface_skin_t,
                      const Agenda& blackbody_radiation_agenda,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void surfaceFlatRefractiveIndex(// Workspace reference:
                                Workspace& ws,
                                // 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_los,
                                const Vector& specular_los,
                                const Numeric& surface_skin_t,
                                const GriddedField3& surface_complex_refr_index,
                                const Agenda& blackbody_radiation_agenda,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void surfaceFlatReflectivity(// Workspace reference:
                             Workspace& ws,
                             // 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& specular_los,
                             const Numeric& surface_skin_t,
                             const Tensor3& surface_reflectivity,
                             const Agenda& blackbody_radiation_agenda,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void surfaceFlatScalarReflectivity(// Workspace reference:
                                   Workspace& ws,
                                   // 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& specular_los,
                                   const Numeric& surface_skin_t,
                                   const Vector& surface_scalar_reflectivity,
                                   const Agenda& blackbody_radiation_agenda,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void surfaceLambertianSimple(// Workspace reference:
                             Workspace& ws,
                             // 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_los,
                             const Numeric& surface_skin_t,
                             const Vector& surface_scalar_reflectivity,
                             const Index& lambertian_nza,
                             const Agenda& blackbody_radiation_agenda,
                             // WS Generic Input:
                             const Numeric& za_pos,
                             // 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_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 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 Tensor3AddScalar(// WS Generic Output:
                      Tensor3& out,
                      // WS Generic Input:
                      const Tensor3& in,
                      const Numeric& value,
                      // 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 Test(// 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 TMatrixTest(// 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 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 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 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 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 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 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 ArrayOfSingleScatteringData& scat_data_array,
                       // 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 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& jacobian,
           // WS Input:
           const Index& atmgeom_checked,
           const Index& atmfields_checked,
           const Index& atmosphere_dim,
           const Tensor3& t_field,
           const Tensor3& z_field,
           const Tensor4& vmr_field,
           const Index& cloudbox_on,
           const Index& cloudbox_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 Vector& mblock_za_grid,
           const Vector& mblock_aa_grid,
           const Index& antenna_dim,
           const Sparse& sensor_response,
           const Vector& sensor_response_f,
           const ArrayOfIndex& sensor_response_pol,
           const Vector& sensor_response_za,
           const Vector& sensor_response_aa,
           const Agenda& iy_main_agenda,
           const Agenda& jacobian_agenda,
           const Index& jacobian_do,
           const ArrayOfRetrievalQuantity& jacobian_quantities,
           const ArrayOfArrayOfIndex& jacobian_indices,
           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& jacobian,
                 ArrayOfRetrievalQuantity& jacobian_quantities,
                 ArrayOfArrayOfIndex& jacobian_indices,
                 // WS Input:
                 const Index& atmgeom_checked,
                 const Index& atmfields_checked,
                 const Index& atmosphere_dim,
                 const Tensor3& t_field,
                 const Tensor3& z_field,
                 const Tensor4& vmr_field,
                 const Index& cloudbox_on,
                 const Index& cloudbox_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 Vector& mblock_za_grid,
                 const Vector& mblock_aa_grid,
                 const Index& antenna_dim,
                 const Sparse& sensor_response,
                 const Vector& sensor_response_f,
                 const ArrayOfIndex& sensor_response_pol,
                 const Vector& sensor_response_za,
                 const Vector& sensor_response_aa,
                 const Agenda& iy_main_agenda,
                 const Agenda& jacobian_agenda,
                 const Index& jacobian_do,
                 const ArrayOfString& iy_aux_vars,
                 // WS Generic Input:
                 const ArrayOfRetrievalQuantity& jacobian_quantities_copy,
                 const ArrayOfArrayOfIndex& jacobian_indices_copy,
                 const Index& append_instrument_wfs,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void yCloudRadar(// Workspace reference:
                 Workspace& ws,
                 // WS Output:
                 Vector& y,
                 ArrayOfVector& y_aux,
                 // WS Input:
                 const Index& atmgeom_checked,
                 const Index& atmfields_checked,
                 const ArrayOfString& iy_aux_vars,
                 const Index& stokes_dim,
                 const Vector& f_grid,
                 const Tensor3& t_field,
                 const Tensor3& z_field,
                 const Tensor4& vmr_field,
                 const Index& cloudbox_on,
                 const Index& cloudbox_checked,
                 const Matrix& sensor_pos,
                 const Matrix& sensor_los,
                 const Index& sensor_checked,
                 const Agenda& iy_main_agenda,
                 const ArrayOfArrayOfIndex& sensor_pol_array,
                 const Vector& range_bins,
                 // 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 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 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 Input:
            const T& in,
            const String& dimension,
            // 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 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 Ignore(// WS Generic Input:
            const T& in,
            // 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,
                    // WS Generic Input Names:
                    const String& filename_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,
                     // WS Generic Input Names:
                     const String& in_wsvname,
                     const String& filename_wsvname,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
// Get-away function declarations:
 
void IndexCreate_g(Workspace& ws, const MRecord& mr);
void NumericCreate_g(Workspace& ws, const MRecord& mr);
void StringCreate_g(Workspace& ws, const MRecord& mr);
void VectorCreate_g(Workspace& ws, const MRecord& mr);
void MatrixCreate_g(Workspace& ws, const MRecord& mr);
void SparseCreate_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 VerbosityCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfIndexCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfVectorCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfSparseCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTensor3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor4Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor6Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfTensor7Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfTensor6Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfLineMixingRecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfLineRecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfLineRecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfLineshapeSpecCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfSpeciesTagCreate_g(Workspace& ws, const MRecord& mr);
void PpathCreate_g(Workspace& ws, const MRecord& mr);
void AgendaCreate_g(Workspace& ws, const MRecord& mr);
void GridPosCreate_g(Workspace& ws, const MRecord& mr);
void GasAbsLookupCreate_g(Workspace& ws, const MRecord& mr);
void SingleScatteringDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfSingleScatteringDataCreate_g(Workspace& ws, const MRecord& mr);
void ScatteringMetaDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfScatteringMetaDataCreate_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 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 ArrayOfArrayOfGriddedField1Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfGriddedField2Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfGriddedField3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfArrayOfLineMixingRecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfRetrievalQuantityCreate_g(Workspace& ws, const MRecord& mr);
void MCAntennaCreate_g(Workspace& ws, const MRecord& mr);
void SpeciesAuxDataCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfCIARecordCreate_g(Workspace& ws, const MRecord& mr);
void AbsInputFromAtmFields_g(Workspace& ws, const MRecord& mr);
void AbsInputFromRteScalars_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_lineshapeDefine_g(Workspace& ws, const MRecord& mr);
void abs_lineshape_per_tgDefine_g(Workspace& ws, const MRecord& mr);
void abs_linesArtscat4FromArtscat3_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromArts_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromHitran_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromHitranPre2004_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromJpl_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromMytran2_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromSplitArtscat_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesAddMirrorLines_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_lines_per_speciesReadFromCatalogues_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesSetEmpty_g(Workspace& ws, const MRecord& mr);
void abs_lines_per_speciesWriteToSplitArtscat_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_xsec_agenda_checkedCalc_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_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_vecAddPart_g(Workspace& ws, const MRecord& mr);
void abs_vecInit_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_speciesAddCIA_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_speciesInit_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 AntennaConstantGaussian1D_g(Workspace& ws, const MRecord& mr);
void AntennaMultiBeamsToPencilBeams_g(Workspace& ws, const MRecord& mr);
void AntennaOff_g(Workspace& ws, const MRecord& mr);
void AntennaSet1D_g(Workspace& ws, const MRecord& mr);
void AntennaSet2D_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_Tensor4Tensor4_g(Workspace& ws, const MRecord& mr);
void Append_sg_StringString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfIndexArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfMatrixArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSparseArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor3ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor4ArrayOfTensor4_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_ArrayOfArrayOfTensor6ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfLineMixingRecordArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfLineRecordArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfLineRecordArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfLineshapeSpecArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfSpeciesTagArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfScatteringMetaDataArrayOfScatteringMetaData_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_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_ArrayOfArrayOfLineMixingRecordArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfCIARecordArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfIndexIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfStringString_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfVectorVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfMatrixMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSparseSparse_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor3Tensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfTensor4Tensor4_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_ArrayOfArrayOfTensor6ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfLineRecordArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSingleScatteringDataSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfScatteringMetaDataScatteringMetaData_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_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_ArrayOfArrayOfLineMixingRecordArrayOfLineMixingRecord_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 ArrayOfLineMixingRecordReadAscii_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 AtmFieldsCalc_g(Workspace& ws, const MRecord& mr);
void AtmFieldsCalcExpand1D_g(Workspace& ws, const MRecord& mr);
void AtmFieldsExpand1D_g(Workspace& ws, const MRecord& mr);
void AtmFieldsRefinePgrid_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 atm_fields_compactAddConstant_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactAddSpecies_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactFromMatrix_g(Workspace& ws, const MRecord& mr);
void AtmFieldsFromCompact_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 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_compactFromArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void blackbody_radiationPlanck_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 CIAInfo_g(Workspace& ws, const MRecord& mr);
void CloudboxGetIncoming_g(Workspace& ws, const MRecord& mr);
void CloudboxGetIncoming1DAtm_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 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_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_GriddedField3GriddedField3_g(Workspace& ws, const MRecord& mr);
void complex_refr_indexConstant_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_Index_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Copy_sg_String_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Copy_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Copy_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Copy_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Copy_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Index_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Delete_sg_String_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Delete_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Delete_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Delete_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Delete_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void dN_H11_g(Workspace& ws, const MRecord& mr);
void dN_Ar_H13_g(Workspace& ws, const MRecord& mr);
void dN_H98_g(Workspace& ws, const MRecord& mr);
void dN_MH97_g(Workspace& ws, const MRecord& mr);
void dN_F07TR_g(Workspace& ws, const MRecord& mr);
void dN_F07ML_g(Workspace& ws, const MRecord& mr);
void dN_MGD_LWC_g(Workspace& ws, const MRecord& mr);
void dN_MGD_IWC_g(Workspace& ws, const MRecord& mr);
void dN_MP48_g(Workspace& ws, const MRecord& mr);
void DoitAngularGridsSet_g(Workspace& ws, const MRecord& mr);
void DoitCloudboxFieldPut_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 DoitInit_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldIterate_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldSetFromdoit_i_field1D_spectrum_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldSetClearsky_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldSetConst_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldUpdate1D_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldUpdateSeq1D_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldUpdateSeq1DPP_g(Workspace& ws, const MRecord& mr);
void doit_i_fieldUpdateSeq3D_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 DoitScatteringDataPrepare_g(Workspace& ws, const MRecord& mr);
void DoitWriteIterationFields_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 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 ExtractFromMetaSinglePartSpecies_g(Workspace& ws, const MRecord& mr);
void ext_matAddGas_g(Workspace& ws, const MRecord& mr);
void ext_matAddPart_g(Workspace& ws, const MRecord& mr);
void ext_matInit_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 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 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 g0Earth_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 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 Ignore_sg_Index_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_String_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void INCLUDE_g(Workspace& ws, const MRecord& mr);
void IndexSet_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 InterpSurfaceFieldToPosition_g(Workspace& ws, const MRecord& mr);
void isotopologue_ratiosInitFromBuiltin_g(Workspace& ws, const MRecord& mr);
void iyApplyUnit_g(Workspace& ws, const MRecord& mr);
void iyCalc_g(Workspace& ws, const MRecord& mr);
void iyCloudRadar_g(Workspace& ws, const MRecord& mr);
void iyEmissionStandard_g(Workspace& ws, const MRecord& mr);
void iyFOS_g(Workspace& ws, const MRecord& mr);
void iyMC_g(Workspace& ws, const MRecord& mr);
void iyInterpCloudboxField_g(Workspace& ws, const MRecord& mr);
void iyInterpPolyCloudboxField_g(Workspace& ws, const MRecord& mr);
void iyLoopFrequencies_g(Workspace& ws, const MRecord& mr);
void iyRadioLink_g(Workspace& ws, const MRecord& mr);
void iyReplaceFromAux_g(Workspace& ws, const MRecord& mr);
void iySurfaceRtpropAgenda_g(Workspace& ws, const MRecord& mr);
void iyTransmissionStandard_g(Workspace& ws, const MRecord& mr);
void iy_auxFillParticleVariables_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 jacobianAddFreqShift_g(Workspace& ws, const MRecord& mr);
void jacobianAddFreqStretch_g(Workspace& ws, const MRecord& mr);
void jacobianAddPointingZa_g(Workspace& ws, const MRecord& mr);
void jacobianAddPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianAddSinefit_g(Workspace& ws, const MRecord& mr);
void jacobianAddTemperature_g(Workspace& ws, const MRecord& mr);
void jacobianAddWind_g(Workspace& ws, const MRecord& mr);
void jacobianCalcAbsSpeciesAnalytical_g(Workspace& ws, const MRecord& mr);
void jacobianCalcAbsSpeciesPerturbations_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 jacobianCalcTemperatureAnalytical_g(Workspace& ws, const MRecord& mr);
void jacobianCalcTemperaturePerturbations_g(Workspace& ws, const MRecord& mr);
void jacobianCalcWindAnalytical_g(Workspace& ws, const MRecord& mr);
void jacobianClose_g(Workspace& ws, const MRecord& mr);
void jacobianInit_g(Workspace& ws, const MRecord& mr);
void jacobianOff_g(Workspace& ws, const MRecord& mr);
void lat_gridFromRawField_g(Workspace& ws, const MRecord& mr);
void lon_gridFromRawField_g(Workspace& ws, const MRecord& mr);
void line_mixing_dataInit_g(Workspace& ws, const MRecord& mr);
void line_mixing_dataMatch_g(Workspace& ws, const MRecord& mr);
void Massdensity_cleanup_g(Workspace& ws, const MRecord& mr);
void MatrixAddScalar_g(Workspace& ws, const MRecord& mr);
void MatrixCBR_g(Workspace& ws, const MRecord& mr);
void MatrixExtractFromTensor3_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 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 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 MCSetSeedFromTime_g(Workspace& ws, const MRecord& mr);
void NumericAdd_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 nelemGet_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfScatteringMetaData_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfCIARecord_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 opt_prop_sptFromData_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_massesFromMetaDataSingleCategory_g(Workspace& ws, const MRecord& mr);
void particle_massesFromMetaDataAndPart_species_g(Workspace& ws, const MRecord& mr);
void ParticleSpeciesInit_g(Workspace& ws, const MRecord& mr);
void ParticleSpeciesSet_g(Workspace& ws, const MRecord& mr);
void ParticleTypeAdd_g(Workspace& ws, const MRecord& mr);
void ParticleTypeAddAll_g(Workspace& ws, const MRecord& mr);
void ParticleTypeInit_g(Workspace& ws, const MRecord& mr);
void ParticleType2abs_speciesAdd_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_sptFromMonoData_g(Workspace& ws, const MRecord& mr);
void pha_mat_sptFromDataDOITOpt_g(Workspace& ws, const MRecord& mr);
void pnd_fieldCalc_g(Workspace& ws, const MRecord& mr);
void pnd_fieldExpand1D_g(Workspace& ws, const MRecord& mr);
void pnd_fieldSetup_g(Workspace& ws, const MRecord& mr);
void pnd_fieldZero_g(Workspace& ws, const MRecord& mr);
void pndFromdN_g(Workspace& ws, const MRecord& mr);
void ppathCalc_g(Workspace& ws, const MRecord& mr);
void ppathFromRtePos2_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 Print_sg_Index_g(Workspace& ws, const MRecord& mr);
void Print_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Print_sg_String_g(Workspace& ws, const MRecord& mr);
void Print_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Print_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Print_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Print_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Print_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Print_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Print_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Print_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Print_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void PrintWorkspace_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_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_clearsky_agenda_checkedCalc_g(Workspace& ws, const MRecord& mr);
void propmat_clearsky_fieldCalc_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 p_gridFromGasAbsLookup_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_Index_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_String_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Index_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_String_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Vector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void ReadXMLIndexed_sg_ArrayOfCIARecord_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 refellipsoidForAzimuth_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_airIR_g(Workspace& ws, const MRecord& mr);
void refr_index_airMWgeneral_g(Workspace& ws, const MRecord& mr);
void refr_index_airThayer_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 ScatteringDisort_g(Workspace& ws, const MRecord& mr);
void ScatteringDoit_g(Workspace& ws, const MRecord& mr);
void ScatteringMergeParticles1D_g(Workspace& ws, const MRecord& mr);
void ScatteringParticleTypeAndMetaRead_g(Workspace& ws, const MRecord& mr);
void ScatteringParticlesSelect_g(Workspace& ws, const MRecord& mr);
void scat_meta_arrayAddTmatrix_g(Workspace& ws, const MRecord& mr);
void scat_meta_arrayAddTmatrixOldVersion_g(Workspace& ws, const MRecord& mr);
void scat_meta_arrayInit_g(Workspace& ws, const MRecord& mr);
void scat_data_array_monoCalc_g(Workspace& ws, const MRecord& mr);
void scat_data_arrayCheck_g(Workspace& ws, const MRecord& mr);
void scat_data_arrayFromMeta_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfIndexArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfIndexArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfStringArrayOfString_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfVectorArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfVectorArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfMatrixArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfMatrixArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfSparseArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor3ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfTensor3ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfTensor4ArrayOfTensor4_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_ArrayOfArrayOfTensor6ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfLineMixingRecordArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfLineRecordArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfLineRecordArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfLineshapeSpecArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfSpeciesTagArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfScatteringMetaDataArrayOfScatteringMetaData_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_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_ArrayOfArrayOfLineMixingRecordArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfCIARecordArrayOfCIARecord_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_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_responseMixer_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 SparseSparseMultiply_g(Workspace& ws, const MRecord& mr);
void specular_losCalc_g(Workspace& ws, const MRecord& mr);
void StringCompose_g(Workspace& ws, const MRecord& mr);
void StringSet_g(Workspace& ws, const MRecord& mr);
void surfaceBlackbody_g(Workspace& ws, const MRecord& mr);
void surfaceFlatRefractiveIndex_g(Workspace& ws, const MRecord& mr);
void surfaceFlatReflectivity_g(Workspace& ws, const MRecord& mr);
void surfaceFlatScalarReflectivity_g(Workspace& ws, const MRecord& mr);
void surfaceLambertianSimple_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_scalar_reflectivityFromGriddedField4_g(Workspace& ws, const MRecord& mr);
void TangentPointExtract_g(Workspace& ws, const MRecord& mr);
void TangentPointPrint_g(Workspace& ws, const MRecord& mr);
void Tensor3AddScalar_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 Test_g(Workspace& ws, const MRecord& mr);
void timerStart_g(Workspace& ws, const MRecord& mr);
void timerStop_g(Workspace& ws, const MRecord& mr);
void TMatrixTest_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Index_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void Touch_sg_String_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Vector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void Touch_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void Touch_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void Touch_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Touch_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Touch_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void Touch_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void VectorAddScalar_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 VectorScale_g(Workspace& ws, const MRecord& mr);
void VectorSetConstant_g(Workspace& ws, const MRecord& mr);
void VectorSet_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 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_Index_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_String_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Index_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_String_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Vector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Sparse_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_Verbosity_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfVector_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfSparse_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfTensor4_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_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ScatteringMetaData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfScatteringMetaData_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_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_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_ArrayOfArrayOfLineMixingRecord_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_SpeciesAuxData_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfCIARecord_g(Workspace& ws, const MRecord& mr);
void yApplyUnit_g(Workspace& ws, const MRecord& mr);
void ybatchCalc_g(Workspace& ws, const MRecord& mr);
void ybatchMetProfiles_g(Workspace& ws, const MRecord& mr);
void ybatchMetProfilesClear_g(Workspace& ws, const MRecord& mr);
void yCalc_g(Workspace& ws, const MRecord& mr);
void yCalcAppend_g(Workspace& ws, const MRecord& mr);
void yCloudRadar_g(Workspace& ws, const MRecord& mr);
void ySimpleSpectrometer_g(Workspace& ws, const MRecord& mr);
void wind_u_fieldIncludePlanetRotation_g(Workspace& ws, const MRecord& mr);
void z_fieldFromHSE_g(Workspace& ws, const MRecord& mr);
 
void propmat_clearsky_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor4& propmat_clearsky,
        // Input
        const Vector& f_grid,
        const Vector& rtp_mag,
        const Vector& rtp_los,
        const Numeric rtp_pressure,
        const Numeric rtp_temperature,
        const Vector& rtp_vmr,
        // Wrapper Input
        const Agenda& input_agenda);
 
void abs_xsec_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        ArrayOfMatrix& abs_xsec_per_species,
        // Input
        const ArrayOfArrayOfSpeciesTag& abs_species,
        const ArrayOfIndex& abs_species_active,
        const Vector& f_grid,
        const Vector& abs_p,
        const Vector& abs_t,
        const Matrix& abs_vmrs,
        // Wrapper Input
        const Agenda& input_agenda);
 
void blackbody_radiation_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& blackbody_radiation,
        // Input
        const Numeric rtp_temperature,
        const Vector& f_grid,
        // 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& doit_i_field,
        const Tensor6& doit_i_field_old,
        // Wrapper Input
        const Agenda& input_agenda);
 
void doit_mono_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor6& doit_i_field,
        Tensor7& scat_i_p,
        Tensor7& scat_i_lat,
        Tensor7& scat_i_lon,
        Tensor4& doit_i_field1D_spectrum,
        // 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& doit_i_field,
        // Wrapper Input
        const Agenda& input_agenda);
 
void doit_rte_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor6& doit_i_field,
        // 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 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_main_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor4& iy_aux,
        Ppath& ppath,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const Tensor3& iy_transmission,
        const ArrayOfString& iy_aux_vars,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        const Vector& f_grid,
        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_sub_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor4& iy_aux,
        Ppath& ppath,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const Tensor3& iy_transmission,
        const ArrayOfString& iy_aux_vars,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        const Vector& f_grid,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Vector& rte_pos2,
        // Wrapper Input
        const Agenda& input_agenda);
 
void iy_surface_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor3& diy_dx,
        // Input
        const Tensor3& iy_transmission,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        const Vector& f_grid,
        const Agenda& iy_main_agenda,
        const Vector& rtp_pos,
        const Vector& rtp_los,
        const Vector& rte_pos2,
        // Wrapper Input
        const Agenda& input_agenda);
 
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 opt_prop_part_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor3& ext_mat,
        Matrix& abs_vec,
        // Input
        const Tensor3& ext_mat_spt,
        const Matrix& abs_vec_spt,
        const Index scat_p_index,
        const Index scat_lat_index,
        const Index scat_lon_index,
        // Wrapper Input
        const Agenda& input_agenda);
 
void pha_mat_spt_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor5& pha_mat_spt,
        // Input
        const Index scat_za_index,
        const Index scat_lat_index,
        const Index scat_lon_index,
        const Index scat_p_index,
        const Index scat_aa_index,
        const Numeric rtp_temperature,
        // Wrapper Input
        const Agenda& input_agenda);
 
void ppath_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Ppath& ppath,
        // Input
        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 Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        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_lraytrace,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        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,
        ArrayOfIndex& sensor_response_pol,
        Vector& sensor_response_za,
        Vector& sensor_response_aa,
        // Input
        const Index mblock_index,
        // Wrapper Input
        const Agenda& input_agenda);
 
void spt_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor3& ext_mat_spt,
        Matrix& 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 scat_za_index,
        const Index scat_aa_index,
        // Wrapper Input
        const Agenda& input_agenda);
 
void surface_rtprop_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        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 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