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, 14:13:47
 
#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"
 
// This is only used for a consistency check. You can get the
// number of WSMs from md_data.nelem().
#define N_MD 873
 
// Method function declarations:
 
 
void IndexCreate(// WS Generic Output:
                 Index& var,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void NumericCreate(// WS Generic Output:
                   Numeric& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void StringCreate(// WS Generic Output:
                  String& var,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void VectorCreate(// WS Generic Output:
                  Vector& var,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixCreate(// WS Generic Output:
                  Matrix& var,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void SparseCreate(// WS Generic Output:
                  Sparse& var,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor3Create(// WS Generic Output:
                   Tensor3& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor4Create(// WS Generic Output:
                   Tensor4& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor5Create(// WS Generic Output:
                   Tensor5& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor6Create(// WS Generic Output:
                   Tensor6& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Tensor7Create(// WS Generic Output:
                   Tensor7& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void TimerCreate(// WS Generic Output:
                 Timer& var,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void VerbosityCreate(// WS Generic Output:
                     Verbosity& var,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& var,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ArrayOfArrayOfIndexCreate(// WS Generic Output:
                               ArrayOfArrayOfIndex& var,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfArrayOfMatrixCreate(// WS Generic Output:
                                ArrayOfArrayOfMatrix& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfSparseCreate(// WS Generic Output:
                         ArrayOfSparse& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfTensor3Create(// WS Generic Output:
                          ArrayOfTensor3& var,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor3Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor3& var,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfTensor4Create(// WS Generic Output:
                          ArrayOfTensor4& var,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor6Create(// WS Generic Output:
                          ArrayOfTensor6& var,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfTensor7Create(// WS Generic Output:
                          ArrayOfTensor7& var,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void ArrayOfArrayOfTensor6Create(// WS Generic Output:
                                 ArrayOfArrayOfTensor6& var,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void ArrayOfLineRecordCreate(// WS Generic Output:
                             ArrayOfLineRecord& var,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfArrayOfLineRecordCreate(// WS Generic Output:
                                    ArrayOfArrayOfLineRecord& var,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void ArrayOfLineshapeSpecCreate(// WS Generic Output:
                                ArrayOfLineshapeSpec& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfSpeciesTagCreate(// WS Generic Output:
                                    ArrayOfArrayOfSpeciesTag& var,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void PpathCreate(// WS Generic Output:
                 Ppath& var,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void AgendaCreate(// WS Generic Output:
                  Agenda& var,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void GridPosCreate(// WS Generic Output:
                   GridPos& var,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void GasAbsLookupCreate(// WS Generic Output:
                        GasAbsLookup& var,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void SingleScatteringDataCreate(// WS Generic Output:
                                SingleScatteringData& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfSingleScatteringDataCreate(// WS Generic Output:
                                       ArrayOfSingleScatteringData& var,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ScatteringMetaDataCreate(// WS Generic Output:
                              ScatteringMetaData& var,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void ArrayOfScatteringMetaDataCreate(// WS Generic Output:
                                     ArrayOfScatteringMetaData& var,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void GriddedField1Create(// WS Generic Output:
                         GriddedField1& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField2Create(// WS Generic Output:
                         GriddedField2& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField3Create(// WS Generic Output:
                         GriddedField3& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void GriddedField4Create(// WS Generic Output:
                         GriddedField4& var,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ArrayOfGriddedField1Create(// WS Generic Output:
                                ArrayOfGriddedField1& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField2Create(// WS Generic Output:
                                ArrayOfGriddedField2& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField3Create(// WS Generic Output:
                                ArrayOfGriddedField3& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfGriddedField4Create(// WS Generic Output:
                                ArrayOfGriddedField4& var,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField1Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField1& var,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfArrayOfGriddedField3Create(// WS Generic Output:
                                       ArrayOfArrayOfGriddedField3& var,
                                       // Verbosity object:
                                       const Verbosity& verbosity);
 
 
void ArrayOfRetrievalQuantityCreate(// WS Generic Output:
                                    ArrayOfRetrievalQuantity& var,
                                    // Verbosity object:
                                    const Verbosity& verbosity);
 
 
void MCAntennaCreate(// WS Generic Output:
                     MCAntenna& var,
                     // 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& rte_pressure,
                            const Numeric& rte_temperature,
                            const Vector& rte_vmr_list,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_coefCalc(// WS Output:
                  Matrix& abs_coef,
                  ArrayOfMatrix& abs_coef_per_species,
                  // WS Input:
                  const ArrayOfArrayOfSpeciesTag& abs_species,
                  const Vector& f_grid,
                  const Vector& abs_p,
                  const Vector& abs_t,
                  const Vector& abs_n2,
                  const Vector& abs_h2o,
                  const Matrix& abs_vmrs,
                  const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                  const ArrayOfLineshapeSpec& abs_lineshape,
                  const ArrayOfString& abs_cont_names,
                  const ArrayOfString& abs_cont_models,
                  const ArrayOfVector& abs_cont_parameters,
                  // 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_coefCalcSaveMemory(// WS Output:
                            Matrix& abs_coef,
                            // WS Input:
                            const ArrayOfArrayOfSpeciesTag& abs_species,
                            const Vector& f_grid,
                            const Vector& abs_p,
                            const Vector& abs_t,
                            const Vector& abs_n2,
                            const Vector& abs_h2o,
                            const Matrix& abs_vmrs,
                            const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                            const ArrayOfLineshapeSpec& abs_lineshape,
                            const ArrayOfString& abs_cont_names,
                            const ArrayOfString& abs_cont_models,
                            const ArrayOfVector& abs_cont_parameters,
                            // 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& userparameters,
                                // 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_h2oSet(// WS Output:
                Vector& abs_h2o,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                const Matrix& abs_vmrs,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void abs_lineshapeDefine(// WS Output:
                         ArrayOfLineshapeSpec& abs_lineshape,
                         // WS Generic Input:
                         const String& shape,
                         const String& normalizationfactor,
                         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_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_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_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_linesReadFromHitran2004(// 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_lines_per_speciesAddMirrorLines(// WS Output:
                                         ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                         // 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_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_lookupCreate(// WS Output:
                      GasAbsLookup& abs_lookup,
                      Index& abs_lookup_is_adapted,
                      // WS Input:
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                      const ArrayOfLineshapeSpec& abs_lineshape,
                      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 Vector& abs_n2,
                      const ArrayOfString& abs_cont_names,
                      const ArrayOfString& abs_cont_models,
                      const ArrayOfVector& abs_cont_parameters,
                      // 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 Vector& lat_grid,
                     const Vector& lon_grid,
                     const Tensor3& t_field,
                     const Tensor4& vmr_field,
                     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(// 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 Vector& abs_n2,
                            const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                            const ArrayOfLineshapeSpec& abs_lineshape,
                            const ArrayOfString& abs_cont_names,
                            const ArrayOfString& abs_cont_models,
                            const ArrayOfVector& abs_cont_parameters,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void abs_lookupTestAccMC(// 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 Vector& abs_n2,
                         const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                         const ArrayOfLineshapeSpec& abs_lineshape,
                         const ArrayOfString& abs_cont_names,
                         const ArrayOfString& abs_cont_models,
                         const ArrayOfVector& abs_cont_parameters,
                         const Index& mc_seed,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void abs_n2Set(// WS Output:
               Vector& abs_n2,
               // WS Input:
               const ArrayOfArrayOfSpeciesTag& abs_species,
               const Matrix& abs_vmrs,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void abs_scalar_gasCalcLBL(// WS Output:
                           Matrix& abs_scalar_gas,
                           // WS Input:
                           const Vector& f_grid,
                           const ArrayOfArrayOfSpeciesTag& abs_species,
                           const Vector& abs_n2,
                           const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                           const ArrayOfLineshapeSpec& abs_lineshape,
                           const ArrayOfString& abs_cont_names,
                           const ArrayOfString& abs_cont_models,
                           const ArrayOfVector& abs_cont_parameters,
                           const Index& f_index,
                           const Numeric& rte_pressure,
                           const Numeric& rte_temperature,
                           const Vector& rte_vmr_list,
                           const Numeric& rte_doppler,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void abs_scalar_gasExtractFromLookup(// WS Output:
                                     Matrix& abs_scalar_gas,
                                     // 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& f_index,
                                     const Numeric& rte_pressure,
                                     const Numeric& rte_temperature,
                                     const Vector& rte_vmr_list,
                                     const Numeric& rte_doppler,
                                     // WS Generic Input:
                                     const Numeric& extpolfac,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void abs_scalar_gasFromAbsCoef(// WS Output:
                               Matrix& abs_scalar_gas,
                               // WS Input:
                               const ArrayOfMatrix& abs_coef_per_species,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void abs_fieldCalc(// Workspace reference:
                   Workspace& ws,
                   // WS Output:
                   Tensor5& abs_field,
                   // WS Input:
                   const Agenda& abs_scalar_gas_agenda,
                   const Index& f_index,
                   const Vector& f_grid,
                   const Index& atmosphere_dim,
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const Tensor3& t_field,
                   const Tensor4& vmr_field,
                   // WS Generic Input:
                   const Vector& doppler,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void abs_speciesAdd(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    // 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,
                     // 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,
                                    // 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_vecAddGas(// WS Output:
                   Matrix& abs_vec,
                   // WS Input:
                   const Matrix& abs_scalar_gas,
                   // 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_speciesAddConts(// WS Output:
                                  ArrayOfMatrix& abs_xsec_per_species,
                                  // WS Input:
                                  const ArrayOfArrayOfSpeciesTag& abs_species,
                                  const Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Vector& abs_n2,
                                  const Vector& abs_h2o,
                                  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 Vector& f_grid,
                                  const Vector& abs_p,
                                  const Vector& abs_t,
                                  const Vector& abs_h2o,
                                  const Matrix& abs_vmrs,
                                  const ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                  const ArrayOfLineshapeSpec& abs_lineshape,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void abs_xsec_per_speciesInit(// WS Output:
                              ArrayOfMatrix& abs_xsec_per_species,
                              // WS Input:
                              const ArrayOfArrayOfSpeciesTag& abs_species,
                              const Vector& f_grid,
                              const Vector& abs_p,
                              // Verbosity object:
                              const Verbosity& verbosity);
 
 
void AgendaExecute(// Workspace reference:
                   Workspace& ws,
                   // WS Generic Input:
                   const Agenda& a,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void AgendaAppend(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& aout,
                  // WS Generic Output Names:
                  const String& aout_wsvname,
                  // WS Generic Input:
                  const Agenda& ain,
                  // WS Generic Input Names:
                  const String& ain_wsvname,
                  // Agenda from controlfile:
                  const Agenda& input_agenda,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void AgendaSet(// Workspace reference:
               Workspace& ws,
               // WS Generic Output:
               Agenda& a,
               // WS Generic Output Names:
               const String& a_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 ArrayOfIndexSet(// WS Generic Output:
                     ArrayOfIndex& ai,
                     // WS Generic Input:
                     const ArrayOfIndex& values,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ArrayOfIndexSetConstant(// WS Generic Output:
                             ArrayOfIndex& ai,
                             // WS Input:
                             const Index& nelem,
                             // WS Generic Input:
                             const Index& value,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString& as,
                      // WS Generic Input:
                      const ArrayOfString& text,
                      // 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,
                   // 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,
                           // 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 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 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 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 atm_fields_compactFromMatrixChevalAll(// WS Output:
                                           GriddedField4& atm_fields_compact_all,
                                           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,
                          // WS Input:
                          const ArrayOfArrayOfSpeciesTag& abs_species,
                          const GriddedField4& atm_fields_compact,
                          const Index& atmosphere_dim,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void AtmFieldsFromCompactChevalAll(// WS Output:
                                   Vector& p_grid,
                                   Vector& lat_grid,
                                   Vector& lon_grid,
                                   Tensor3& t_field,
                                   Tensor3& z_field,
                                   Tensor4& massdensity_field,
                                   Tensor4& vmr_field,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   const GriddedField4& atm_fields_compact_all,
                                   const Index& atmosphere_dim,
                                   // 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 basics_checkedCalc(// WS Output:
                        Index& basics_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& 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 Matrix& r_geoid,
                        const Matrix& z_surface,
                        const Index& stokes_dim,
                        const Vector& f_grid,
                        // 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 batch_atm_fields_compactFromArrayOfMatrixChevalAll(// WS Output:
                                                        ArrayOfGriddedField4& batch_atm_fields_compact,
                                                        ArrayOfGriddedField4& batch_atm_fields_compact_all,
                                                        // 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 CloudboxGetIncoming(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         Tensor7& scat_i_p,
                         Tensor7& scat_i_lat,
                         Tensor7& scat_i_lon,
                         // WS Input:
                         const Agenda& iy_clearsky_basic_agenda,
                         const Index& atmosphere_dim,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Tensor3& z_field,
                         const Matrix& r_geoid,
                         const Index& cloudbox_on,
                         const ArrayOfIndex& cloudbox_limits,
                         const Vector& f_grid,
                         const Index& stokes_dim,
                         const Vector& scat_za_grid,
                         const Vector& scat_aa_grid,
                         // 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 Agenda& iy_clearsky_basic_agenda,
                              const Index& atmosphere_dim,
                              const Vector& lat_grid,
                              const Vector& lon_grid,
                              const Tensor3& z_field,
                              const Matrix& r_geoid,
                              const ArrayOfIndex& cloudbox_limits,
                              const Vector& f_grid,
                              const Index& stokes_dim,
                              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,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void cloudboxSetAutomatically(// WS Output:
                              Index& cloudbox_on,
                              ArrayOfIndex& cloudbox_limits,
                              // WS Input:
                              const Index& atmosphere_dim,
                              const ArrayOfString& part_species,
                              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 cloudboxSetDisort(// WS Output:
                       Index& cloudbox_on,
                       ArrayOfIndex& cloudbox_limits,
                       // WS Input:
                       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& basics_checked,
                          const Index& atmosphere_dim,
                          const Vector& p_grid,
                          const Vector& lat_grid,
                          const Vector& lon_grid,
                          const Tensor3& wind_u_field,
                          const Tensor3& wind_v_field,
                          const Tensor3& wind_w_field,
                          const Index& cloudbox_on,
                          const ArrayOfIndex& cloudbox_limits,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void complex_nWaterLiebe93(// WS Output:
                           Matrix& complex_n,
                           // WS Input:
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Numeric& t,
                           // 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,
                          const Matrix& sensor_pos,
                          const Tensor3& z_field,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void doit_conv_flagAbs(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       // WS Input:
                       const Tensor6& doit_i_field,
                       const Tensor6& doit_i_field_old,
                       // WS Generic Input:
                       const Vector& epsilon,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void doit_conv_flagLsq(// WS Output:
                       Index& doit_conv_flag,
                       Index& doit_iteration_counter,
                       // WS Input:
                       const Tensor6& doit_i_field,
                       const Tensor6& doit_i_field_old,
                       const Vector& f_grid,
                       const Index& f_index,
                       // WS Generic Input:
                       const Vector& epsilon,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void doit_conv_flagAbsBT(// WS Output:
                         Index& doit_conv_flag,
                         Index& doit_iteration_counter,
                         // WS Input:
                         const Tensor6& doit_i_field,
                         const Tensor6& doit_i_field_old,
                         const Vector& f_grid,
                         const Index& f_index,
                         // WS Generic Input:
                         const Vector& epsilon,
                         // 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,
              Index& doit_is_initialized,
              // WS Input:
              const Index& stokes_dim,
              const Index& atmosphere_dim,
              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_raw,
              // 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_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_i_field_old,
                          const Tensor6& doit_scat_field,
                          const ArrayOfIndex& cloudbox_limits,
                          const Agenda& abs_scalar_gas_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& opt_prop_gas_agenda,
                          const Agenda& ppath_step_agenda,
                          const Vector& p_grid,
                          const Tensor3& z_field,
                          const Matrix& r_geoid,
                          const Matrix& z_surface,
                          const Tensor3& t_field,
                          const Vector& f_grid,
                          const Index& f_index,
                          const Agenda& surface_prop_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,
                             // WS Input:
                             const Tensor6& doit_scat_field,
                             const ArrayOfIndex& cloudbox_limits,
                             const Agenda& abs_scalar_gas_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& opt_prop_gas_agenda,
                             const Agenda& ppath_step_agenda,
                             const Vector& p_grid,
                             const Tensor3& z_field,
                             const Matrix& r_geoid,
                             const Matrix& z_surface,
                             const Tensor3& t_field,
                             const Vector& f_grid,
                             const Index& f_index,
                             const Agenda& surface_prop_agenda,
                             const Index& doit_za_interp,
                             // 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& abs_scalar_gas_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& opt_prop_gas_agenda,
                               const Agenda& ppath_step_agenda,
                               const Vector& p_grid,
                               const Tensor3& z_field,
                               const Matrix& r_geoid,
                               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& abs_scalar_gas_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& opt_prop_gas_agenda,
                             const Agenda& ppath_step_agenda,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             const Tensor3& z_field,
                             const Matrix& r_geoid,
                             const Matrix& z_surface,
                             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_mono,
                               // WS Input:
                               const Index& doit_za_grid_size,
                               const Vector& scat_aa_grid,
                               const ArrayOfSingleScatteringData& scat_data_raw,
                               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 emissionPlanck(// WS Output:
                    Vector& emission,
                    // WS Input:
                    const Vector& f_grid,
                    const Numeric& rte_temperature,
                    // 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 ext_matAddGas(// WS Output:
                   Tensor3& ext_mat,
                   // WS Input:
                   const Matrix& abs_scalar_gas,
                   // 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 FlagOff(// WS Generic Output:
             Index& i,
             // Verbosity object:
             const Verbosity& verbosity);
 
 
void FlagOn(// WS Generic Output:
            Index& i,
            // 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 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_gridFromSensorHIRS(// WS Output:
                          Vector& f_grid,
                          // WS Input:
                          const Vector& f_backend,
                          const ArrayOfGriddedField1& backend_channel_response,
                          // WS Generic Input:
                          const Numeric& spacing,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void f_gridSelectFIndex(// WS Output:
                        Vector& f_grid,
                        // WS Input:
                        const Index& f_index,
                        // 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 INCLUDE(// Verbosity object:
             const Verbosity& verbosity);
 
 
void IndexSet(// WS Generic Output:
              Index& i,
              // WS Generic Input:
              const Index& value,
              // Verbosity object:
              const Verbosity& verbosity);
 
 
void IndexStep(// WS Generic Output:
               Index& i2,
               // WS Generic Input:
               const Index& gin1,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void InterpAtmFieldToRteGps(// WS Generic Output:
                            Numeric& x,
                            // WS Input:
                            const Index& atmosphere_dim,
                            const GridPos& rte_gp_p,
                            const GridPos& rte_gp_lat,
                            const GridPos& rte_gp_lon,
                            // WS Generic Input:
                            const Tensor3& field,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void InterpSurfaceEmissivityFieldIncLatLon(// WS Generic Output:
                                           Numeric& outvalue,
                                           // WS Input:
                                           const Index& atmosphere_dim,
                                           const Vector& rte_pos,
                                           const Vector& rte_los,
                                           // WS Generic Input:
                                           const GriddedField3& gfield,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void InterpSurfaceFieldToRteGps(// WS Generic Output:
                                Numeric& x,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const GridPos& rte_gp_lat,
                                const GridPos& rte_gp_lon,
                                // WS Generic Input:
                                const Matrix& gin1,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void iyBeerLambertStandardClearsky(// Workspace reference:
                                   Workspace& ws,
                                   // WS Output:
                                   Matrix& iy,
                                   Matrix& iy_error,
                                   Index& iy_error_type,
                                   Matrix& 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 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 Tensor3& wind_u_field,
                                   const Tensor3& wind_v_field,
                                   const Tensor3& wind_w_field,
                                   const Matrix& r_geoid,
                                   const Matrix& z_surface,
                                   const Index& cloudbox_on,
                                   const ArrayOfIndex& cloudbox_limits,
                                   const Index& stokes_dim,
                                   const Vector& f_grid,
                                   const ArrayOfArrayOfSpeciesTag& abs_species,
                                   const Agenda& ppath_step_agenda,
                                   const Agenda& abs_scalar_gas_agenda,
                                   const Agenda& iy_clearsky_agenda,
                                   const Agenda& iy_space_agenda,
                                   const Agenda& surface_prop_agenda,
                                   const Agenda& iy_cloudbox_agenda,
                                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                                   const ArrayOfArrayOfIndex& jacobian_indices,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void iyBeerLambertStandardCloudbox(// Workspace reference:
                                   Workspace& ws,
                                   // WS Output:
                                   Matrix& iy,
                                   Matrix& iy_error,
                                   Index& iy_error_type,
                                   Matrix& iy_aux,
                                   ArrayOfTensor3& diy_dx,
                                   // WS Input:
                                   const Tensor3& iy_transmission,
                                   const Vector& rte_pos,
                                   const Vector& rte_los,
                                   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 Matrix& r_geoid,
                                   const Matrix& z_surface,
                                   const Index& cloudbox_on,
                                   const ArrayOfIndex& cloudbox_limits,
                                   const Index& stokes_dim,
                                   const Vector& f_grid,
                                   const Agenda& ppath_step_agenda,
                                   const Agenda& abs_scalar_gas_agenda,
                                   const Agenda& iy_clearsky_agenda,
                                   const Tensor4& pnd_field,
                                   const Index& use_mean_scat_data,
                                   const ArrayOfSingleScatteringData& scat_data_raw,
                                   const Agenda& opt_prop_gas_agenda,
                                   // Verbosity object:
                                   const Verbosity& verbosity);
 
 
void iyEmissionStandardClearsky(// Workspace reference:
                                Workspace& ws,
                                // WS Output:
                                Matrix& iy,
                                Matrix& iy_error,
                                Index& iy_error_type,
                                Matrix& 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 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 Tensor3& wind_u_field,
                                const Tensor3& wind_v_field,
                                const Tensor3& wind_w_field,
                                const Matrix& r_geoid,
                                const Matrix& z_surface,
                                const Index& cloudbox_on,
                                const ArrayOfIndex& cloudbox_limits,
                                const Index& stokes_dim,
                                const Vector& f_grid,
                                const ArrayOfArrayOfSpeciesTag& abs_species,
                                const Agenda& ppath_step_agenda,
                                const Agenda& emission_agenda,
                                const Agenda& abs_scalar_gas_agenda,
                                const Agenda& iy_clearsky_agenda,
                                const Agenda& iy_space_agenda,
                                const Agenda& surface_prop_agenda,
                                const Agenda& iy_cloudbox_agenda,
                                const ArrayOfRetrievalQuantity& jacobian_quantities,
                                const ArrayOfArrayOfIndex& jacobian_indices,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void iyEmissionStandardClearskyBasic(// Workspace reference:
                                     Workspace& ws,
                                     // WS Output:
                                     Matrix& iy,
                                     // WS Input:
                                     const Vector& rte_pos,
                                     const Vector& rte_los,
                                     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 Tensor3& wind_u_field,
                                     const Tensor3& wind_v_field,
                                     const Tensor3& wind_w_field,
                                     const Matrix& r_geoid,
                                     const Matrix& z_surface,
                                     const Index& cloudbox_on,
                                     const ArrayOfIndex& cloudbox_limits,
                                     const Index& stokes_dim,
                                     const Vector& f_grid,
                                     const Agenda& ppath_step_agenda,
                                     const Agenda& emission_agenda,
                                     const Agenda& abs_scalar_gas_agenda,
                                     const Agenda& iy_clearsky_basic_agenda,
                                     const Agenda& iy_space_agenda,
                                     const Agenda& surface_prop_agenda,
                                     const Agenda& iy_cloudbox_agenda,
                                     // Verbosity object:
                                     const Verbosity& verbosity);
 
 
void iyMC(// Workspace reference:
          Workspace& ws,
          // WS Output:
          Matrix& iy,
          Matrix& iy_error,
          Index& iy_error_type,
          Matrix& 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 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 Matrix& r_geoid,
          const Matrix& z_surface,
          const Index& cloudbox_on,
          const ArrayOfIndex& cloudbox_limits,
          const Index& cloudbox_checked,
          const Index& stokes_dim,
          const Vector& f_grid,
          const ArrayOfSingleScatteringData& scat_data_raw,
          const Agenda& iy_space_agenda,
          const Agenda& surface_prop_agenda,
          const Agenda& abs_scalar_gas_agenda,
          const Agenda& opt_prop_gas_agenda,
          const Tensor4& pnd_field,
          const String& y_unit,
          const Numeric& mc_std_err,
          const Index& mc_max_time,
          const Index& mc_max_iter,
          // Verbosity object:
          const Verbosity& verbosity);
 
 
void iyInterpCloudboxField(// WS Output:
                           Matrix& iy,
                           Matrix& iy_error,
                           Index& iy_error_type,
                           Matrix& iy_aux,
                           ArrayOfTensor3& diy_dx,
                           // WS Input:
                           const Tensor3& iy_transmission,
                           const Tensor7& scat_i_p,
                           const Tensor7& scat_i_lat,
                           const Tensor7& scat_i_lon,
                           const Tensor4& doit_i_field1D_spectrum,
                           const GridPos& rte_gp_p,
                           const GridPos& rte_gp_lat,
                           const GridPos& rte_gp_lon,
                           const Vector& rte_los,
                           const Index& jacobian_do,
                           const Index& cloudbox_on,
                           const ArrayOfIndex& cloudbox_limits,
                           const Index& atmosphere_dim,
                           const Index& stokes_dim,
                           const Vector& scat_za_grid,
                           const Vector& scat_aa_grid,
                           const Vector& f_grid,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void iyInterpPolyCloudboxField(// WS Output:
                               Matrix& iy,
                               Matrix& iy_error,
                               Index& iy_error_type,
                               Matrix& iy_aux,
                               ArrayOfTensor3& diy_dx,
                               // WS Input:
                               const Tensor3& iy_transmission,
                               const Tensor7& scat_i_p,
                               const Tensor7& scat_i_lat,
                               const Tensor7& scat_i_lon,
                               const Tensor4& doit_i_field1D_spectrum,
                               const GridPos& rte_gp_p,
                               const GridPos& rte_gp_lat,
                               const GridPos& rte_gp_lon,
                               const Vector& rte_los,
                               const Index& jacobian_do,
                               const Index& cloudbox_on,
                               const ArrayOfIndex& cloudbox_limits,
                               const Index& atmosphere_dim,
                               const Index& stokes_dim,
                               const Vector& scat_za_grid,
                               const Vector& scat_aa_grid,
                               const Vector& f_grid,
                               // 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 jacobianAddFreqShiftAndStretch(// Workspace reference:
                                    Workspace& ws,
                                    // WS Output:
                                    ArrayOfRetrievalQuantity& jacobian_quantities,
                                    Agenda& jacobian_agenda,
                                    // WS Input:
                                    const Vector& f_grid,
                                    // WS Generic Input:
                                    const String& calcmode,
                                    const Numeric& df,
                                    const Index& do_stretch,
                                    // 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_f_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 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 jacobianCalcAbsSpeciesAnalytical(// WS Output:
                                      Matrix& jacobian,
                                      // WS Input:
                                      const Index& imblock,
                                      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& imblock,
                                         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 Vector& mblock_za_grid,
                                         const Vector& mblock_aa_grid,
                                         const Index& antenna_dim,
                                         const Sparse& sensor_response,
                                         const Agenda& iy_clearsky_agenda,
                                         const String& y_unit,
                                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                                         const ArrayOfArrayOfIndex& jacobian_indices,
                                         // WS Generic Input:
                                         const String& species,
                                         // Verbosity object:
                                         const Verbosity& verbosity);
 
 
void jacobianCalcFreqShiftAndStretchInterp(// WS Output:
                                           Matrix& jacobian,
                                           // WS Input:
                                           const Index& imblock,
                                           const Vector& iyb,
                                           const Vector& yb,
                                           const Index& stokes_dim,
                                           const Vector& f_grid,
                                           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 ArrayOfRetrievalQuantity& jacobian_quantities,
                                           const ArrayOfArrayOfIndex& jacobian_indices,
                                           // Verbosity object:
                                           const Verbosity& verbosity);
 
 
void jacobianCalcPointingZaInterp(// WS Output:
                                  Matrix& jacobian,
                                  // WS Input:
                                  const Index& imblock,
                                  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& imblock,
                                  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 Index& cloudbox_on,
                                  const Index& stokes_dim,
                                  const Vector& f_grid,
                                  const Matrix& sensor_pos,
                                  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 Agenda& iy_clearsky_agenda,
                                  const String& y_unit,
                                  const ArrayOfRetrievalQuantity& jacobian_quantities,
                                  const ArrayOfArrayOfIndex& jacobian_indices,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void jacobianCalcPolyfit(// WS Output:
                         Matrix& jacobian,
                         // WS Input:
                         const Index& imblock,
                         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 jacobianCalcTemperatureAnalytical(// WS Output:
                                       Matrix& jacobian,
                                       // WS Input:
                                       const Index& imblock,
                                       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& imblock,
                                          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 Matrix& r_geoid,
                                          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 Vector& mblock_za_grid,
                                          const Vector& mblock_aa_grid,
                                          const Index& antenna_dim,
                                          const Sparse& sensor_response,
                                          const Agenda& iy_clearsky_agenda,
                                          const String& y_unit,
                                          const Numeric& p_hse,
                                          const Numeric& z_hse_accuracy,
                                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                                          const ArrayOfArrayOfIndex& jacobian_indices,
                                          // Verbosity object:
                                          const Verbosity& verbosity);
 
 
void jacobianClose(// Workspace reference:
                   Workspace& ws,
                   // WS Output:
                   Index& jacobian_do,
                   Matrix& jacobian,
                   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,
                  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 MatrixCBR(// WS Generic Output:
               Matrix& m,
               // WS Input:
               const Index& stokes_dim,
               // WS Generic Input:
               const Vector& f,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MatrixMatrixMultiply(// WS Generic Output:
                          Matrix& gout1,
                          // WS Generic Input:
                          const Matrix& gin1,
                          const Matrix& gin2,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void MatrixPlanck(// WS Generic Output:
                  Matrix& m,
                  // WS Input:
                  const Index& stokes_dim,
                  // WS Generic Input:
                  const Vector& gin1,
                  const Numeric& gin2,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void MatrixScale(// WS Generic Output:
                 Matrix& mout,
                 // WS Generic Input:
                 const Matrix& min,
                 const Numeric& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void MatrixSetConstant(// WS Generic Output:
                       Matrix& m,
                       // WS Input:
                       const Index& nrows,
                       const Index& ncols,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void MatrixSet(// WS Generic Output:
               Matrix& gout1,
               // WS Generic Input:
               const Matrix& values,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MatrixUnitIntensity(// WS Generic Output:
                         Matrix& m,
                         // WS Input:
                         const Index& stokes_dim,
                         // WS Generic Input:
                         const Vector& f,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void Matrix1ColFromVector(// WS Generic Output:
                          Matrix& m,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void Matrix2ColFromVectors(// WS Generic Output:
                           Matrix& m,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Matrix3ColFromVectors(// WS Generic Output:
                           Matrix& m,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           const Vector& v3,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void MatrixCompare(// WS Generic Input:
                   const Matrix& matrix1,
                   const Matrix& matrix2,
                   const Numeric& maxabsdiff,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void Matrix1RowFromVector(// WS Generic Output:
                          Matrix& m,
                          // WS Generic Input:
                          const Vector& v,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void Matrix2RowFromVectors(// WS Generic Output:
                           Matrix& m,
                           // WS Generic Input:
                           const Vector& v1,
                           const Vector& v2,
                           // Verbosity object:
                           const Verbosity& verbosity);
 
 
void Matrix3RowFromVectors(// WS Generic Output:
                           Matrix& m,
                           // 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 mc_IWP_cloud_opt_pathCalc(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Numeric& mc_IWP,
                               Numeric& mc_cloud_opt_path,
                               Numeric& mc_IWP_error,
                               Numeric& mc_cloud_opt_path_error,
                               Index& mc_iteration_count,
                               // WS Input:
                               const MCAntenna& mc_antenna,
                               const Matrix& sensor_pos,
                               const Matrix& sensor_los,
                               const Agenda& ppath_step_agenda,
                               const Vector& p_grid,
                               const Vector& lat_grid,
                               const Vector& lon_grid,
                               const Matrix& r_geoid,
                               const Matrix& z_surface,
                               const Tensor3& z_field,
                               const Tensor3& t_field,
                               const Tensor4& vmr_field,
                               const ArrayOfIndex& cloudbox_limits,
                               const Tensor4& pnd_field,
                               const ArrayOfSingleScatteringData& scat_data_mono,
                               const Vector& particle_masses,
                               const Index& mc_seed,
                               // WS Generic Input:
                               const Index& max_iter,
                               // 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& iy_space_agenda,
               const Agenda& surface_prop_agenda,
               const Agenda& opt_prop_gas_agenda,
               const Agenda& abs_scalar_gas_agenda,
               const Vector& p_grid,
               const Vector& lat_grid,
               const Vector& lon_grid,
               const Tensor3& z_field,
               const Matrix& r_geoid,
               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_mono,
               const Index& basics_checked,
               const Index& cloudbox_checked,
               const Index& mc_seed,
               const String& y_unit,
               const Numeric& mc_std_err,
               const Index& mc_max_time,
               const Index& mc_max_iter,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void MCIPA(// 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& iy_space_agenda,
           const Agenda& surface_prop_agenda,
           const Agenda& opt_prop_gas_agenda,
           const Agenda& abs_scalar_gas_agenda,
           const Agenda& ppath_step_agenda,
           const Vector& p_grid,
           const Vector& lat_grid,
           const Vector& lon_grid,
           const Tensor3& z_field,
           const Matrix& r_geoid,
           const Matrix& z_surface,
           const Tensor3& t_field,
           const Tensor4& vmr_field,
           const ArrayOfIndex& cloudbox_limits,
           const Tensor4& pnd_field,
           const ArrayOfSingleScatteringData& scat_data_mono,
           const Index& mc_seed,
           const String& y_unit,
           const Numeric& mc_std_err,
           const Index& mc_max_time,
           const Index& mc_max_iter,
           const Index& mc_z_field_is_1D,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void MCSetSeedFromTime(// WS Output:
                       Index& mc_seed,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void NumericAdd(// WS Generic Output:
                Numeric& b,
                // WS Generic Input:
                const Numeric& a,
                const Numeric& v,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void NumericScale(// WS Generic Output:
                  Numeric& b,
                  // WS Generic Input:
                  const Numeric& a,
                  const Numeric& v,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void NumericSet(// WS Generic Output:
                Numeric& n,
                // 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_raw,
                          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& rte_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_mono,
                              const Vector& scat_za_grid,
                              const Vector& scat_aa_grid,
                              const Index& scat_za_index,
                              const Index& scat_aa_index,
                              const Numeric& rte_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 ParticleSpeciesInit(// WS Output:
                         ArrayOfString& part_species,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ParticleSpeciesSet(// WS Output:
                        ArrayOfString& part_species,
                        // WS Generic Input:
                        const ArrayOfString& names,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ParticleTypeAddAll(// WS Output:
                        ArrayOfSingleScatteringData& scat_data_raw,
                        ArrayOfGriddedField3& pnd_field_raw,
                        // WS Input:
                        const Index& atmosphere_dim,
                        const Vector& f_grid,
                        const Vector& p_grid,
                        const Vector& lat_grid,
                        const Vector& lon_grid,
                        const ArrayOfIndex& cloudbox_limits,
                        // WS Generic Input:
                        const String& filename_scat_data,
                        const String& filename_pnd_field,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void ParticleTypeAdd(// WS Output:
                     ArrayOfSingleScatteringData& scat_data_raw,
                     ArrayOfGriddedField3& pnd_field_raw,
                     // WS Input:
                     const Index& atmosphere_dim,
                     const Vector& f_grid,
                     const Vector& p_grid,
                     const Vector& lat_grid,
                     const Vector& lon_grid,
                     const ArrayOfIndex& cloudbox_limits,
                     // WS Generic Input:
                     const String& filename_scat_data,
                     const String& filename_pnd_field,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void ParticleTypeInit(// WS Output:
                      ArrayOfSingleScatteringData& scat_data_raw,
                      ArrayOfGriddedField3& pnd_field_raw,
                      // 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_matExtractManually(// WS Generic Output:
                            Matrix& pha_mat_single,
                            // WS Input:
                            const Vector& f_grid,
                            const Index& f_index,
                            const Index& stokes_dim,
                            const ArrayOfSingleScatteringData& scat_data_raw,
                            const Numeric& rte_temperature,
                            // WS Generic Input:
                            const Numeric& za_out,
                            const Numeric& aa_out,
                            const Numeric& za_in,
                            const Numeric& aa_in,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void pha_mat_sptFromData(// WS Output:
                         Tensor5& pha_mat_spt,
                         // WS Input:
                         const ArrayOfSingleScatteringData& scat_data_raw,
                         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& rte_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_mono,
                             const Index& doit_za_grid_size,
                             const Vector& scat_aa_grid,
                             const Index& scat_za_index,
                             const Index& scat_aa_index,
                             const Numeric& rte_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_mono,
                                const Index& doit_za_grid_size,
                                const Vector& scat_aa_grid,
                                const Index& scat_za_index,
                                const Index& scat_aa_index,
                                const Numeric& rte_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,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void pnd_fieldExpand1D(// WS Output:
                       Tensor4& pnd_field,
                       // WS Input:
                       const Index& atmosphere_dim,
                       const Index& cloudbox_checked,
                       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_data_meta_array,
                    const ArrayOfString& part_species,
                    const ArrayOfIndex& scat_data_nelem,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void pnd_fieldZero(// WS Output:
                   Tensor4& pnd_field,
                   ArrayOfSingleScatteringData& scat_data_raw,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   // Verbosity object:
                   const Verbosity& verbosity);
 
 
void ppathCalc(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Ppath& ppath,
               // WS Input:
               const Agenda& ppath_step_agenda,
               const Index& atmosphere_dim,
               const Vector& p_grid,
               const Vector& lat_grid,
               const Vector& lon_grid,
               const Tensor3& z_field,
               const Matrix& r_geoid,
               const Matrix& z_surface,
               const Index& cloudbox_on,
               const ArrayOfIndex& cloudbox_limits,
               const Vector& rte_pos,
               const Vector& rte_los,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void ppath_stepGeometric(// WS Output:
                         Ppath& ppath_step,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& p_grid,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Tensor3& z_field,
                         const Matrix& r_geoid,
                         const Matrix& z_surface,
                         const Numeric& ppath_lmax,
                         // Verbosity object:
                         const Verbosity& verbosity);
 
 
void ppath_stepRefractionEuler(// Workspace reference:
                               Workspace& ws,
                               // WS Output:
                               Ppath& ppath_step,
                               Numeric& rte_pressure,
                               Numeric& rte_temperature,
                               Vector& rte_vmr_list,
                               Numeric& refr_index,
                               // WS Input:
                               const Agenda& refr_index_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 Matrix& r_geoid,
                               const Matrix& z_surface,
                               const Numeric& ppath_lmax,
                               const Numeric& ppath_lraytrace,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void p_gridFromAtmRaw(// WS Output:
                      Vector& p_grid,
                      // WS Input:
                      const GriddedField3& z_field_raw,
                      // 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 refr_indexIR(// WS Output:
                  Numeric& refr_index,
                  // WS Input:
                  const Numeric& rte_pressure,
                  const Numeric& rte_temperature,
                  const Vector& rte_vmr_list,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void refr_indexThayer(// WS Output:
                      Numeric& refr_index,
                      // WS Input:
                      const Numeric& rte_pressure,
                      const Numeric& rte_temperature,
                      const Vector& rte_vmr_list,
                      const ArrayOfArrayOfSpeciesTag& abs_species,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void refr_indexUnit(// WS Output:
                    Numeric& refr_index,
                    // 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_posAddRgeoid(// WS Output:
                      Vector& rte_pos,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      const Matrix& r_geoid,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void rte_posSet(// WS Output:
                Vector& rte_pos,
                // WS Input:
                const Index& atmosphere_dim,
                // WS Generic Input:
                const Numeric& r_or_z,
                const Numeric& lat,
                const Numeric& lon,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void r_geoidSpherical(// WS Output:
                      Matrix& r_geoid,
                      // WS Input:
                      const Index& atmosphere_dim,
                      const Vector& lat_grid,
                      const Vector& lon_grid,
                      // WS Generic Input:
                      const Numeric& r,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void r_geoidWGS84(// WS Output:
                  Matrix& r_geoid,
                  // WS Input:
                  const Index& atmosphere_dim,
                  const Vector& lat_grid,
                  const Vector& lon_grid,
                  // 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_mono,
                      Tensor4& doit_i_field1D_spectrum,
                      // WS Input:
                      const ArrayOfIndex& cloudbox_limits,
                      const Index& stokes_dim,
                      const Agenda& opt_prop_part_agenda,
                      const Agenda& abs_scalar_gas_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_raw,
                      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& cloudbox_on,
                    const Vector& f_grid,
                    const Agenda& doit_mono_agenda,
                    const Index& doit_is_initialized,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void ScatteringParticleTypeAndMetaRead(// WS Output:
                                       ArrayOfSingleScatteringData& scat_data_raw,
                                       ArrayOfScatteringMetaData& scat_data_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_raw,
                               ArrayOfScatteringMetaData& scat_data_meta_array,
                               ArrayOfIndex& scat_data_nelem,
                               // WS Input:
                               const ArrayOfString& part_species,
                               // Verbosity object:
                               const Verbosity& verbosity);
 
 
void scat_data_monoCalc(// WS Output:
                        ArrayOfSingleScatteringData& scat_data_mono,
                        // WS Input:
                        const ArrayOfSingleScatteringData& scat_data_raw,
                        const Vector& f_grid,
                        const Index& f_index,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void scat_data_rawCheck(// WS Input:
                        const ArrayOfSingleScatteringData& scat_data_raw,
                        // 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& atmosphere_dim,
               const Index& stokes_dim,
               const Vector& f_grid,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void sensor_posAddRgeoid(// WS Output:
                         Matrix& sensor_pos,
                         // WS Input:
                         const Index& atmosphere_dim,
                         const Vector& lat_grid,
                         const Vector& lon_grid,
                         const Matrix& r_geoid,
                         // 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_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_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& df_1,
                                              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_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_responseFromArrayData(// WS Output:
                                  Sparse& sensor_response,
                                  Vector& sensor_response_f,
                                  ArrayOfIndex& sensor_response_pol,
                                  Vector& sensor_response_za,
                                  Vector& sensor_response_aa,
                                  // WS Input:
                                  const Index& imblock,
                                  const ArrayOfSparse& sensor_response_array,
                                  const ArrayOfVector& sensor_response_f_array,
                                  const ArrayOfArrayOfIndex& sensor_response_pol_array,
                                  const ArrayOfVector& sensor_response_za_array,
                                  const ArrayOfVector& sensor_response_aa_array,
                                  const ArrayOfIndex& sensor_response_index,
                                  // 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& y_unit,
                                 const ArrayOfIndex& sensor_pol,
                                 // 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_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 sensor_response_arraySingle(// WS Output:
                                 ArrayOfSparse& sensor_response_array,
                                 ArrayOfVector& sensor_response_f_array,
                                 ArrayOfArrayOfIndex& sensor_response_pol_array,
                                 ArrayOfVector& sensor_response_za_array,
                                 ArrayOfVector& sensor_response_aa_array,
                                 // WS Input:
                                 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 SparseSparseMultiply(// WS Generic Output:
                          Sparse& gout,
                          // WS Generic Input:
                          const Sparse& gin1,
                          const Sparse& gin2,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void SpeciesSet(// WS Generic Output:
                ArrayOfArrayOfSpeciesTag& gout1,
                // WS Generic Input:
                const ArrayOfString& species,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void StringSet(// WS Generic Output:
               String& s,
               // WS Generic Input:
               const String& text,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void surfaceBlackbody(// 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,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void surfaceFlatReflectivity(// WS Output:
                             Matrix& surface_los,
                             Tensor4& surface_rmatrix,
                             Matrix& surface_emission,
                             // WS Input:
                             const Vector& f_grid,
                             const Index& stokes_dim,
                             const Index& atmosphere_dim,
                             const Vector& rte_los,
                             const Numeric& surface_skin_t,
                             const Vector& surface_scalar_reflectivity,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void surfaceFlatRefractiveIndex(// WS Output:
                                Matrix& surface_los,
                                Tensor4& surface_rmatrix,
                                Matrix& surface_emission,
                                // WS Input:
                                const Vector& f_grid,
                                const Index& stokes_dim,
                                const Index& atmosphere_dim,
                                const Vector& rte_los,
                                const Numeric& surface_skin_t,
                                const Matrix& complex_n,
                                // Verbosity object:
                                const Verbosity& verbosity);
 
 
void surfaceFlatSingleEmissivity(// 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& rte_los,
                                 const Numeric& surface_skin_t,
                                 // WS Generic Input:
                                 const Numeric& surface_emissivity,
                                 // Verbosity object:
                                 const Verbosity& verbosity);
 
 
void surfaceFlatVaryingEmissivity(// 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& rte_los,
                                  const Numeric& surface_skin_t,
                                  // WS Generic Input:
                                  const Vector& surface_emissivity,
                                  // Verbosity object:
                                  const Verbosity& verbosity);
 
 
void surfaceLambertianSimple(// WS Output:
                             Matrix& surface_los,
                             Tensor4& surface_rmatrix,
                             Matrix& surface_emission,
                             // WS Input:
                             const Vector& f_grid,
                             const Index& stokes_dim,
                             const Index& atmosphere_dim,
                             const Vector& rte_los,
                             const Numeric& surface_skin_t,
                             const Vector& surface_scalar_reflectivity,
                             // WS Generic Input:
                             const Index& np,
                             const Numeric& za_pos,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void Tensor3AddScalar(// WS Generic Output:
                      Tensor3& tout,
                      // WS Generic Input:
                      const Tensor3& tin,
                      const Numeric& value,
                      // Verbosity object:
                      const Verbosity& verbosity);
 
 
void Tensor3Scale(// WS Generic Output:
                  Tensor3& tout,
                  // WS Generic Input:
                  const Tensor3& tin,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor3SetConstant(// WS Generic Output:
                        Tensor3& t,
                        // WS Input:
                        const Index& npages,
                        const Index& nrows,
                        const Index& ncols,
                        // WS Generic Input:
                        const Numeric& value,
                        // Verbosity object:
                        const Verbosity& verbosity);
 
 
void Tensor4Scale(// WS Generic Output:
                  Tensor4& tout,
                  // WS Generic Input:
                  const Tensor4& tin,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor4SetConstant(// WS Generic Output:
                        Tensor4& t,
                        // 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& tout,
                  // WS Generic Input:
                  const Tensor5& tin,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor5SetConstant(// WS Generic Output:
                        Tensor5& t,
                        // 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& tout,
                  // WS Generic Input:
                  const Tensor6& tin,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor6SetConstant(// WS Generic Output:
                        Tensor6& t,
                        // 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& tout,
                  // WS Generic Input:
                  const Tensor7& tin,
                  const Numeric& value,
                  // Verbosity object:
                  const Verbosity& verbosity);
 
 
void Tensor7SetConstant(// WS Generic Output:
                        Tensor7& t,
                        // 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 Input:
               const Timer& timer,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void VectorAddScalar(// WS Generic Output:
                     Vector& v1,
                     // WS Generic Input:
                     const Vector& v2,
                     const Numeric& value,
                     // Verbosity object:
                     const Verbosity& verbosity);
 
 
void VectorExtractFromMatrix(// WS Generic Output:
                             Vector& v,
                             // WS Generic Input:
                             const Matrix& m,
                             const Index& i,
                             const String& direction,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
void VectorFlip(// WS Generic Output:
                Vector& gout1,
                // WS Generic Input:
                const Vector& gin1,
                // Verbosity object:
                const Verbosity& verbosity);
 
 
void VectorInsertGridPoints(// WS Generic Output:
                            Vector& gout1,
                            // WS Generic Input:
                            const Vector& gin1,
                            const Vector& gin2,
                            // Verbosity object:
                            const Verbosity& verbosity);
 
 
void VectorLinSpace(// WS Generic Output:
                    Vector& v,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorLogSpace(// WS Generic Output:
                    Vector& gout1,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step,
                    // Verbosity object:
                    const Verbosity& verbosity);
 
 
void VectorMatrixMultiply(// WS Generic Output:
                          Vector& gout1,
                          // WS Generic Input:
                          const Matrix& gin1,
                          const Vector& gin2,
                          // Verbosity object:
                          const Verbosity& verbosity);
 
 
void VectorNLinSpace(// WS Generic Output:
                     Vector& v,
                     // 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& v,
                     // 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& gout1,
                 // WS Generic Input:
                 const Vector& gin1,
                 const Numeric& value,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void VectorSetConstant(// WS Generic Output:
                       Vector& v,
                       // WS Input:
                       const Index& nelem,
                       // WS Generic Input:
                       const Numeric& value,
                       // Verbosity object:
                       const Verbosity& verbosity);
 
 
void VectorSet(// WS Generic Output:
               Vector& gout1,
               // WS Generic Input:
               const Vector& values,
               // Verbosity object:
               const Verbosity& verbosity);
 
 
void VectorZtanToZaRefr1D(// Workspace reference:
                          Workspace& ws,
                          // WS Generic Output:
                          Vector& v_za,
                          // WS Input:
                          const Agenda& refr_index_agenda,
                          const Matrix& sensor_pos,
                          const Vector& p_grid,
                          const Tensor3& t_field,
                          const Tensor3& z_field,
                          const Tensor4& vmr_field,
                          const Matrix& r_geoid,
                          const Index& atmosphere_dim,
                          // 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 Matrix& r_geoid,
                      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 Tensor5& abs_field,
                 const Index& atmosphere_dim,
                 // WS Generic Input:
                 const String& filename,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void ybatchCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Matrix& ybatch,
                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:
                       Matrix& 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 Matrix& r_geoid,
                       const Vector& lat_grid,
                       const Vector& lon_grid,
                       const Index& atmosphere_dim,
                       const ArrayOfSingleScatteringData& scat_data_raw,
                       // 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:
                            Matrix& 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 Matrix& r_geoid,
                            // 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,
           Vector& y_error,
           Vector& y_aux,
           Matrix& jacobian,
           // WS Input:
           const Index& basics_checked,
           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 Index& cloudbox_on,
           const Index& cloudbox_checked,
           const Index& stokes_dim,
           const Vector& f_grid,
           const Matrix& sensor_pos,
           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_response_f,
           const ArrayOfIndex& sensor_response_pol,
           const Vector& sensor_response_za,
           const Vector& sensor_response_aa,
           const Agenda& iy_clearsky_agenda,
           const String& y_unit,
           const Agenda& jacobian_agenda,
           const Index& jacobian_do,
           const ArrayOfRetrievalQuantity& jacobian_quantities,
           const ArrayOfArrayOfIndex& jacobian_indices,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
void yCalc2(// Workspace reference:
            Workspace& ws,
            // WS Output:
            Vector& y,
            Vector& y_f,
            ArrayOfIndex& y_pol,
            Matrix& y_pos,
            Matrix& y_los,
            Vector& y_error,
            Vector& y_aux,
            Matrix& jacobian,
            // WS Input:
            const Index& basics_checked,
            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 Index& cloudbox_on,
            const Index& cloudbox_checked,
            const Index& stokes_dim,
            const Vector& f_grid,
            const Matrix& sensor_pos,
            const Matrix& sensor_los,
            const Vector& mblock_za_grid,
            const Vector& mblock_aa_grid,
            const Index& antenna_dim,
            const Agenda& sensor_response_agenda,
            const Agenda& iy_clearsky_agenda,
            const String& y_unit,
            const Agenda& jacobian_agenda,
            const Index& jacobian_do,
            const ArrayOfRetrievalQuantity& jacobian_quantities,
            const ArrayOfArrayOfIndex& jacobian_indices,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
void y_unitApply(// WS Output:
                 Vector& y,
                 Vector& y_error,
                 Matrix& jacobian,
                 // WS Input:
                 const Vector& y_f,
                 const ArrayOfIndex& y_pol,
                 const String& y_unit,
                 // Verbosity object:
                 const Verbosity& verbosity);
 
 
void z_fieldFromHSE(// WS Output:
                    Tensor3& z_field,
                    // 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 Matrix& r_geoid,
                    const Matrix& z_surface,
                    const Index& basics_checked,
                    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,
            // Verbosity object:
            const Verbosity& verbosity);
 
 
template <typename T>
void Copy(// WS Generic Output:
          T& gout1,
          // WS Generic Input:
          const T& gin1,
          // 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 FrequencyFromWavelength(// WS Generic Output:
                             T& frequency,
                             // WS Generic Input:
                             const T& wavelength,
                             // Verbosity object:
                             const Verbosity& verbosity);
 
 
template <typename T>
void Ignore(// WS Generic Input:
            const T& gin1,
            // 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& v,
           const Index& level,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
template <typename T>
void ReadNetCDF(// WS Generic Output:
                T& v,
                // WS Generic Output Names:
                const String& v_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& v,
             // WS Generic Output Names:
             const String& v_wsvname,
             // 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& gout1,
           // Verbosity object:
           const Verbosity& verbosity);
 
 
template <typename T>
void WriteNetCDF(// WS Generic Input:
                 const T& v,
                 const String& filename,
                 // WS Generic Input Names:
                 const String& v_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& v,
              const String& filename,
              // WS Generic Input Names:
              const String& v_wsvname,
              const String& filename_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& wsv,
                     const String& filename,
                     // WS Generic Input Names:
                     const String& wsv_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 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 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 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 ArrayOfArrayOfGriddedField3Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfRetrievalQuantityCreate_g(Workspace& ws, const MRecord& mr);
void MCAntennaCreate_g(Workspace& ws, const MRecord& mr);
void AbsInputFromAtmFields_g(Workspace& ws, const MRecord& mr);
void AbsInputFromRteScalars_g(Workspace& ws, const MRecord& mr);
void abs_coefCalc_g(Workspace& ws, const MRecord& mr);
void abs_coefCalcFromXsec_g(Workspace& ws, const MRecord& mr);
void abs_coefCalcSaveMemory_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_h2oSet_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_linesReadFromArts_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromSplitArtscat_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromHitran_g(Workspace& ws, const MRecord& mr);
void abs_linesReadFromHitran2004_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_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_lookupAdapt_g(Workspace& ws, const MRecord& mr);
void abs_lookupCreate_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_n2Set_g(Workspace& ws, const MRecord& mr);
void abs_scalar_gasCalcLBL_g(Workspace& ws, const MRecord& mr);
void abs_scalar_gasExtractFromLookup_g(Workspace& ws, const MRecord& mr);
void abs_scalar_gasFromAbsCoef_g(Workspace& ws, const MRecord& mr);
void abs_fieldCalc_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_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_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 AgendaExecute_g(Workspace& ws, const MRecord& mr);
void AgendaAppend_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 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_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_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_ArrayOfArrayOfGriddedField3ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Append_sg_VectorVector_g(Workspace& ws, const MRecord& mr);
void Append_sg_StringString_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 ArrayOfIndexSet_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexSetConstant_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringSet_g(Workspace& ws, const MRecord& mr);
void Arts_g(Workspace& ws, const MRecord& mr);
void Arts2_g(Workspace& ws, const MRecord& mr);
void 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 atm_fields_compactAddConstant_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactAddSpecies_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 atm_fields_compactFromMatrix_g(Workspace& ws, const MRecord& mr);
void atm_fields_compactFromMatrixChevalAll_g(Workspace& ws, const MRecord& mr);
void AtmFieldsFromCompact_g(Workspace& ws, const MRecord& mr);
void AtmFieldsFromCompactChevalAll_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 basics_checkedCalc_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactFromArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactFromArrayOfMatrixChevalAll_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 cloudboxSetDisort_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 complex_nWaterLiebe93_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_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_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_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_ArrayOfArrayOfGriddedField3_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 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_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_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_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_ArrayOfArrayOfGriddedField3_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 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_flagLsq_g(Workspace& ws, const MRecord& mr);
void doit_conv_flagAbsBT_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_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 emissionPlanck_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_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_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 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 FrequencyFromWavelength_sg_NumericNumeric_g(Workspace& ws, const MRecord& mr);
void FrequencyFromWavelength_sg_VectorVector_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 f_gridFromGasAbsLookup_g(Workspace& ws, const MRecord& mr);
void f_gridFromSensorAMSU_g(Workspace& ws, const MRecord& mr);
void f_gridFromSensorHIRS_g(Workspace& ws, const MRecord& mr);
void f_gridSelectFIndex_g(Workspace& ws, const MRecord& mr);
void Massdensity_cleanup_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_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_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_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_ArrayOfArrayOfGriddedField3_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 INCLUDE_g(Workspace& ws, const MRecord& mr);
void IndexSet_g(Workspace& ws, const MRecord& mr);
void IndexStep_g(Workspace& ws, const MRecord& mr);
void InterpAtmFieldToRteGps_g(Workspace& ws, const MRecord& mr);
void InterpSurfaceEmissivityFieldIncLatLon_g(Workspace& ws, const MRecord& mr);
void InterpSurfaceFieldToRteGps_g(Workspace& ws, const MRecord& mr);
void iyBeerLambertStandardClearsky_g(Workspace& ws, const MRecord& mr);
void iyBeerLambertStandardCloudbox_g(Workspace& ws, const MRecord& mr);
void iyEmissionStandardClearsky_g(Workspace& ws, const MRecord& mr);
void iyEmissionStandardClearskyBasic_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 jacobianAddAbsSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianAddFreqShiftAndStretch_g(Workspace& ws, const MRecord& mr);
void jacobianAddPointingZa_g(Workspace& ws, const MRecord& mr);
void jacobianAddPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianAddTemperature_g(Workspace& ws, const MRecord& mr);
void jacobianCalcAbsSpeciesAnalytical_g(Workspace& ws, const MRecord& mr);
void jacobianCalcAbsSpeciesPerturbations_g(Workspace& ws, const MRecord& mr);
void jacobianCalcFreqShiftAndStretchInterp_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 jacobianCalcTemperatureAnalytical_g(Workspace& ws, const MRecord& mr);
void jacobianCalcTemperaturePerturbations_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 MatrixCBR_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 MatrixSetConstant_g(Workspace& ws, const MRecord& mr);
void MatrixSet_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 MatrixCompare_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 mc_IWP_cloud_opt_pathCalc_g(Workspace& ws, const MRecord& mr);
void MCGeneral_g(Workspace& ws, const MRecord& mr);
void MCIPA_g(Workspace& ws, const MRecord& mr);
void MCSetSeedFromTime_g(Workspace& ws, const MRecord& mr);
void NumericAdd_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_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_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_ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfRetrievalQuantity_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 ParticleSpeciesInit_g(Workspace& ws, const MRecord& mr);
void ParticleSpeciesSet_g(Workspace& ws, const MRecord& mr);
void ParticleTypeAddAll_g(Workspace& ws, const MRecord& mr);
void ParticleTypeAdd_g(Workspace& ws, const MRecord& mr);
void ParticleTypeInit_g(Workspace& ws, const MRecord& mr);
void pha_matCalc_g(Workspace& ws, const MRecord& mr);
void pha_matExtractManually_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 ppathCalc_g(Workspace& ws, const MRecord& mr);
void ppath_stepGeometric_g(Workspace& ws, const MRecord& mr);
void ppath_stepRefractionEuler_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_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_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_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_ArrayOfArrayOfGriddedField3_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 PrintWorkspace_g(Workspace& ws, const MRecord& mr);
void p_gridFromAtmRaw_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 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_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_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_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_ArrayOfArrayOfGriddedField3_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 refr_indexIR_g(Workspace& ws, const MRecord& mr);
void refr_indexThayer_g(Workspace& ws, const MRecord& mr);
void refr_indexUnit_g(Workspace& ws, const MRecord& mr);
void rte_losSet_g(Workspace& ws, const MRecord& mr);
void rte_posAddRgeoid_g(Workspace& ws, const MRecord& mr);
void rte_posSet_g(Workspace& ws, const MRecord& mr);
void r_geoidSpherical_g(Workspace& ws, const MRecord& mr);
void r_geoidWGS84_g(Workspace& ws, const MRecord& mr);
void ScatteringDisort_g(Workspace& ws, const MRecord& mr);
void ScatteringDoit_g(Workspace& ws, const MRecord& mr);
void ScatteringParticleTypeAndMetaRead_g(Workspace& ws, const MRecord& mr);
void ScatteringParticlesSelect_g(Workspace& ws, const MRecord& mr);
void scat_data_monoCalc_g(Workspace& ws, const MRecord& mr);
void scat_data_rawCheck_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_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_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_ArrayOfArrayOfGriddedField3ArrayOfArrayOfGriddedField3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfRetrievalQuantityArrayOfRetrievalQuantity_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 sensorOff_g(Workspace& ws, const MRecord& mr);
void sensor_posAddRgeoid_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_responseFillFgrid_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_responseFrequencySwitching_g(Workspace& ws, const MRecord& mr);
void sensor_responseFromArrayData_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_responseSimpleAMSU_g(Workspace& ws, const MRecord& mr);
void sensor_responseWMRF_g(Workspace& ws, const MRecord& mr);
void sensor_response_arraySingle_g(Workspace& ws, const MRecord& mr);
void SparseSparseMultiply_g(Workspace& ws, const MRecord& mr);
void SpeciesSet_g(Workspace& ws, const MRecord& mr);
void StringSet_g(Workspace& ws, const MRecord& mr);
void surfaceBlackbody_g(Workspace& ws, const MRecord& mr);
void surfaceFlatReflectivity_g(Workspace& ws, const MRecord& mr);
void surfaceFlatRefractiveIndex_g(Workspace& ws, const MRecord& mr);
void surfaceFlatSingleEmissivity_g(Workspace& ws, const MRecord& mr);
void surfaceFlatVaryingEmissivity_g(Workspace& ws, const MRecord& mr);
void surfaceLambertianSimple_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 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 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_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_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_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_ArrayOfArrayOfGriddedField3_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 VectorAddScalar_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 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_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_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_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_ArrayOfArrayOfGriddedField3_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 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_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_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_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_ArrayOfArrayOfGriddedField3_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 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 yCalc2_g(Workspace& ws, const MRecord& mr);
void y_unitApply_g(Workspace& ws, const MRecord& mr);
void z_fieldFromHSE_g(Workspace& ws, const MRecord& mr);
 
void abs_scalar_gas_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& abs_scalar_gas,
        // Input
        const Index f_index,
        const Numeric rte_doppler,
        const Numeric rte_pressure,
        const Numeric rte_temperature,
        const Vector& rte_vmr_list,
        // 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_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_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 Index f_index,
        // 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 emission_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& emission,
        // Input
        const Numeric rte_temperature,
        // 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 iy_clearsky_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        Matrix& iy_error,
        Index& iy_error_type,
        Matrix& iy_aux,
        ArrayOfTensor3& diy_dx,
        // Input
        const Index iy_agenda_call1,
        const Tensor3& iy_transmission,
        const Vector& rte_pos,
        const Vector& rte_los,
        const Index cloudbox_on,
        const Index jacobian_do,
        const Vector& p_grid,
        const Vector& lat_grid,
        const Vector& lon_grid,
        const Tensor3& t_field,
        const Tensor3& z_field,
        const Tensor4& vmr_field,
        // Wrapper Input
        const Agenda& input_agenda);
 
void iy_clearsky_basic_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Vector& rte_pos,
        const Vector& rte_los,
        const Index cloudbox_on,
        // Wrapper Input
        const Agenda& input_agenda);
 
void iy_cloudbox_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        Matrix& iy_error,
        Index& iy_error_type,
        Matrix& iy_aux,
        ArrayOfTensor3& diy_dx,
        // Input
        const Tensor3& iy_transmission,
        const Vector& rte_pos,
        const Vector& rte_los,
        const GridPos& rte_gp_p,
        const GridPos& rte_gp_lat,
        const GridPos& rte_gp_lon,
        // Wrapper Input
        const Agenda& input_agenda);
 
void iy_space_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Vector& rte_pos,
        const Vector& rte_los,
        // Wrapper Input
        const Agenda& input_agenda);
 
void jacobian_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& jacobian,
        // Input
        const Index imblock,
        const Vector& iyb,
        const Vector& yb,
        // Wrapper Input
        const Agenda& input_agenda);
 
void jacobian_y_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& y,
        // Input
        const Vector& f_grid,
        const Tensor4& vmr_field,
        const Tensor3& t_field,
        const Matrix& sensor_los,
        // 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_gas_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Tensor3& ext_mat,
        Matrix& abs_vec,
        // Input
        const Index f_index,
        const Matrix& abs_scalar_gas,
        // 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 rte_temperature,
        // Wrapper Input
        const Agenda& input_agenda);
 
void ppath_step_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Ppath& ppath_step,
        // Input
        const Index atmosphere_dim,
        const Vector& p_grid,
        const Vector& lat_grid,
        const Vector& lon_grid,
        const Tensor3& z_field,
        const Matrix& r_geoid,
        const Matrix& z_surface,
        // Wrapper Input
        const Agenda& input_agenda);
 
void refr_index_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Numeric& refr_index,
        // Input
        const Numeric rte_pressure,
        const Numeric rte_temperature,
        const Vector& rte_vmr_list,
        // 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 imblock,
        // 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 rte_temperature,
        const Index scat_za_index,
        const Index scat_aa_index,
        // Wrapper Input
        const Agenda& input_agenda);
 
void surface_prop_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& surface_emission,
        Matrix& surface_los,
        Tensor4& surface_rmatrix,
        // Input
        const Vector& rte_pos,
        const Vector& rte_los,
        const GridPos& rte_gp_p,
        const GridPos& rte_gp_lat,
        const GridPos& rte_gp_lon,
        // Wrapper Input
        const Agenda& input_agenda);
 
void ybatch_calc_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& y,
        Matrix& jacobian,
        // Input
        const Index ybatch_index,
        // Wrapper Input
        const Agenda& input_agenda);
 
void test_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        // Input
        // Wrapper Input
        const Agenda& input_agenda);
 
 
#endif  // auto_md_h