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: Mar 23 2009, 14:03:12

#ifndef auto_md_h
#define auto_md_h

#include "matpackI.h"
#include "matpackII.h"
#include "abs_species_tags.h"
#include "gas_abs_lookup.h"
#include "gridded_fields.h"
#include "optproperties.h"
#include "jacobian.h"
#include "mc_antenna.h"
#include "m_general.h"
#include "parser.h"
#include "workspace_ng.h"

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

// Method function declarations:


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);


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);


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);


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);


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);


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);


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


void abs_h2oSet(// WS Output:
                Vector& abs_h2o,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                const Matrix& abs_vmrs);


void abs_lineshapeDefine(// WS Output:
                         ArrayOfLineshapeSpec& abs_lineshape,
                         // WS Generic Input:
                         const String& shape,
                         const String& normalizationfactor,
                         const Numeric& cutoff);


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);


void abs_linesReadFromArts(// WS Output:
                           ArrayOfLineRecord& abs_lines,
                           // WS Generic Input:
                           const String& filename,
                           const Numeric& fmin,
                           const Numeric& fmax);


void abs_linesReadFromArtsObsolete(// WS Output:
                                   ArrayOfLineRecord& abs_lines,
                                   // WS Generic Input:
                                   const String& filename,
                                   const Numeric& fmin,
                                   const Numeric& fmax);


void abs_linesReadFromHitran(// WS Output:
                             ArrayOfLineRecord& abs_lines,
                             // WS Generic Input:
                             const String& filename,
                             const Numeric& fmin,
                             const Numeric& fmax);


void abs_linesReadFromHitran2004(// WS Output:
                                 ArrayOfLineRecord& abs_lines,
                                 // WS Generic Input:
                                 const String& filename,
                                 const Numeric& fmin,
                                 const Numeric& fmax);


void abs_linesReadFromJpl(// WS Output:
                          ArrayOfLineRecord& abs_lines,
                          // WS Generic Input:
                          const String& filename,
                          const Numeric& fmin,
                          const Numeric& fmax);


void abs_linesReadFromMytran2(// WS Output:
                              ArrayOfLineRecord& abs_lines,
                              // WS Generic Input:
                              const String& filename,
                              const Numeric& fmin,
                              const Numeric& fmax);


void abs_lines_per_speciesAddMirrorLines(// WS Output:
                                         ArrayOfArrayOfLineRecord& abs_lines_per_species);


void abs_lines_per_speciesCompact(// WS Output:
                                  ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                  // WS Input:
                                  const ArrayOfLineshapeSpec& abs_lineshape,
                                  const Vector& f_grid);


void abs_lines_per_speciesCreateFromLines(// WS Output:
                                          ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                          // WS Input:
                                          const ArrayOfLineRecord& abs_lines,
                                          const ArrayOfArrayOfSpeciesTag& abs_species);


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);


void abs_lines_per_speciesSetEmpty(// WS Output:
                                   ArrayOfArrayOfLineRecord& abs_lines_per_species,
                                   // WS Input:
                                   const ArrayOfArrayOfSpeciesTag& abs_species);


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


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);


void abs_lookupInit(// WS Output:
                    GasAbsLookup& abs_lookup);


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);


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 ArrayOfGField4& 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);


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);


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);


void abs_n2Set(// WS Output:
               Vector& abs_n2,
               // WS Input:
               const ArrayOfArrayOfSpeciesTag& abs_species,
               const Matrix& abs_vmrs);


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);


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);


void abs_scalar_gasFromAbsCoef(// WS Output:
                               Matrix& abs_scalar_gas,
                               // WS Input:
                               const ArrayOfMatrix& abs_coef_per_species);


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);


void abs_speciesAdd(// WS Output:
                    ArrayOfArrayOfSpeciesTag& abs_species,
                    // WS Generic Input:
                    const ArrayOfString& species);


void abs_speciesAdd2(// Workspace reference:
                     Workspace& ws,
                     // WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species,
                     ArrayOfRetrievalQuantity& jacobian_quantities,
                     Agenda& jacobian_agenda,
                     // WS Input:
                     const Matrix& jacobian,
                     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);


void abs_speciesDefineAllInScenario(// WS Output:
                                    ArrayOfArrayOfSpeciesTag& abs_species,
                                    // WS Generic Input:
                                    const String& basename);


void abs_speciesInit(// WS Output:
                     ArrayOfArrayOfSpeciesTag& abs_species);


void SpeciesSet(// WS Generic Output:
                ArrayOfArrayOfSpeciesTag& gout1,
                // WS Generic Input:
                const ArrayOfString& species);


void abs_vecAddGas(// WS Output:
                   Matrix& abs_vec,
                   // WS Input:
                   const Matrix& abs_scalar_gas);


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);


void abs_vecInit(// WS Output:
                 Matrix& abs_vec,
                 // WS Input:
                 const Vector& f_grid,
                 const Index& stokes_dim,
                 const Index& f_index);


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);


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);


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);


void AgendaExecute(// Workspace reference:
                   Workspace& ws,
                   // WS Generic Input:
                   const Agenda& gin1);


void AgendaAppend(// Workspace reference:
                  Workspace& ws,
                  // WS Generic Output:
                  Agenda& gout1,
                  // WS Generic Output Names:
                  const String& gout1_wsvname,
                  // WS Generic Input:
                  const Agenda& gin1,
                  // WS Generic Input Names:
                  const String& gin1_wsvname,
                  // Agenda from controlfile:
                  const Agenda& input_agenda);


void AgendaSet(// Workspace reference:
               Workspace& ws,
               // WS Generic Output:
               Agenda& gout1,
               // WS Generic Output Names:
               const String& gout1_wsvname,
               // Agenda from controlfile:
               const Agenda& input_agenda);


void AntennaOff(// WS Output:
                Index& antenna_dim,
                Vector& mblock_za_grid,
                Vector& mblock_aa_grid);


void AntennaSet1D(// WS Output:
                  Index& antenna_dim,
                  Vector& mblock_aa_grid);


void AntennaSet2D(// WS Output:
                  Index& antenna_dim,
                  // WS Input:
                  const Index& atmosphere_dim);


void ArrayOfGField1Create(// WS Generic Output:
                          ArrayOfGField1& arrayofgfield1);


void ArrayOfIndexCreate(// WS Generic Output:
                        ArrayOfIndex& arrayofindex);


void ArrayOfIndexSet(// WS Generic Output:
                     ArrayOfIndex& arrayofindex,
                     // WS Generic Input:
                     const ArrayOfIndex& values);


void ArrayOfLineRecordCreate(// WS Generic Output:
                             ArrayOfLineRecord& gout1);


void ArrayOfLineshapeSpecCreate(// WS Generic Output:
                                ArrayOfLineshapeSpec& gout1);


void ArrayOfMatrixCreate(// WS Generic Output:
                         ArrayOfMatrix& gout1);


void ArrayOfMatrixInsert(// WS Generic Output:
                         ArrayOfMatrix& gout1,
                         // WS Generic Input:
                         const ArrayOfMatrix& gin1,
                         const Matrix& gin2,
                         const Index& element);


void ArrayOfStringCreate(// WS Generic Output:
                         ArrayOfString& gout1);


void ArrayOfStringSet(// WS Generic Output:
                      ArrayOfString& gout1,
                      // WS Generic Input:
                      const ArrayOfString& text);


void ArrayOfVectorCreate(// WS Generic Output:
                         ArrayOfVector& arrayofvector);


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


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 GField3& t_field_raw,
                   const GField3& z_field_raw,
                   const ArrayOfGField3& vmr_field_raw,
                   const Index& atmosphere_dim);


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 GField3& t_field_raw,
                           const GField3& z_field_raw,
                           const ArrayOfGField3& vmr_field_raw,
                           const Index& atmosphere_dim);


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);


void atm_fields_compactAddConstant(// WS Output:
                                   GField4& atm_fields_compact,
                                   // WS Generic Input:
                                   const String& name,
                                   const Numeric& value);


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


void batch_atm_fields_compactFromArrayOfMatrix(// WS Output:
                                               ArrayOfGField4& 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);


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 GField4& atm_fields_compact,
                          const Index& atmosphere_dim);


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


void AtmosphereSet2D(// WS Output:
                     Index& atmosphere_dim,
                     Vector& lon_grid,
                     Numeric& lat_1d,
                     Numeric& meridian_angle_1d);


void AtmosphereSet3D(// WS Output:
                     Index& atmosphere_dim,
                     Numeric& lat_1d,
                     Numeric& meridian_angle_1d);


void AtmRawRead(// WS Output:
                GField3& t_field_raw,
                GField3& z_field_raw,
                ArrayOfGField3& vmr_field_raw,
                // WS Input:
                const ArrayOfArrayOfSpeciesTag& abs_species,
                // WS Generic Input:
                const String& basename);


void CloudboxGetIncoming(// 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& ppath_step_agenda,
                         const Agenda& rte_agenda,
                         const Agenda& iy_space_agenda,
                         const Agenda& surface_prop_agenda,
                         const Agenda& iy_cloudbox_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 ArrayOfIndex& cloudbox_limits,
                         const Vector& f_grid,
                         const Index& stokes_dim,
                         const Vector& scat_za_grid,
                         const Vector& scat_aa_grid);


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& ppath_step_agenda,
                              const Agenda& rte_agenda,
                              const Agenda& iy_space_agenda,
                              const Agenda& surface_prop_agenda,
                              const Agenda& iy_cloudbox_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 ArrayOfIndex& cloudbox_limits,
                              const Vector& f_grid,
                              const Index& stokes_dim,
                              const Vector& scat_za_grid,
                              const Vector& scat_aa_grid);


void cloudboxOff(// WS Output:
                 Index& cloudbox_on,
                 ArrayOfIndex& cloudbox_limits,
                 Agenda& iy_cloudbox_agenda);


void cloudboxSetDisort(// WS Output:
                       Index& cloudbox_on,
                       ArrayOfIndex& cloudbox_limits,
                       // WS Input:
                       const Vector& p_grid);


void cloudboxSetEmpty(// WS Output:
                      Tensor4& pnd_field,
                      ArrayOfSingleScatteringData& scat_data_raw,
                      // WS Input:
                      const Vector& p_grid,
                      const Vector& lat_grid,
                      const Vector& lon_grid);


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);


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);


void complex_nWaterLiebe93(// WS Output:
                           Matrix& complex_n,
                           // WS Input:
                           const Vector& f_grid,
                           // WS Generic Input:
                           const Numeric& t);


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);


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);


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);


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);


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);


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);


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_za_interp,
              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 ArrayOfIndex& cloudbox_limits,
              const ArrayOfSingleScatteringData& scat_data_raw);


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);


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);


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);


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);


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);


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);


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);


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);


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);


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);


void DoitWriteIterationFields(// WS Input:
                              const Index& doit_iteration_counter,
                              const Tensor6& doit_i_field,
                              // WS Generic Input:
                              const ArrayOfIndex& iterations);


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);


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


void emissionPlanck(// WS Output:
                    Vector& emission,
                    // WS Input:
                    const Vector& f_grid,
                    const Numeric& rte_temperature);


void Error(// WS Generic Input:
           const String& msg);


void Exit();


void ext_matAddGas(// WS Output:
                   Tensor3& ext_mat,
                   // WS Input:
                   const Matrix& abs_scalar_gas);


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);


void ext_matInit(// WS Output:
                 Tensor3& ext_mat,
                 // WS Input:
                 const Vector& f_grid,
                 const Index& stokes_dim,
                 const Index& f_index);


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


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


void f_gridSelectFIndex(// WS Output:
                        Vector& f_grid,
                        // WS Input:
                        const Index& f_index);


void FlagOff(// WS Generic Output:
             Index& gout1);


void FlagOn(// WS Generic Output:
            Index& gout1);


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


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


void GField1Create(// WS Generic Output:
                   GField1& gfield);


void GField2Create(// WS Generic Output:
                   GField2& gfield);


void GField3Create(// WS Generic Output:
                   GField3& gfield);


void GField4Create(// WS Generic Output:
                   GField4& gfield);


void INCLUDE();


void IndexCreate(// WS Generic Output:
                 Index& gout1);


void IndexSet(// WS Generic Output:
              Index& gout1,
              // WS Generic Input:
              const Index& value);


void IndexStep(// WS Generic Output:
               Index& gout1,
               // WS Generic Input:
               const Index& gin1);


void InterpAtmFieldToRteGps(// WS Generic Output:
                            Numeric& gout1,
                            // WS Input:
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const GridPos& rte_gp_p,
                            const GridPos& rte_gp_lat,
                            const GridPos& rte_gp_lon,
                            // WS Generic Input:
                            const Tensor3& gin1);


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 GField3& gfield);


void InterpSurfaceFieldToRteGps(// WS Generic Output:
                                Numeric& gout1,
                                // WS Input:
                                const Index& atmosphere_dim,
                                const Vector& lat_grid,
                                const Vector& lon_grid,
                                const GridPos& rte_gp_lat,
                                const GridPos& rte_gp_lon,
                                // WS Generic Input:
                                const Matrix& gin1);


void iyInterpCloudboxField(// WS Output:
                           Matrix& iy,
                           // WS Input:
                           const Tensor7& scat_i_p,
                           const Tensor7& scat_i_lat,
                           const Tensor7& scat_i_lon,
                           const Tensor4& doit_i_field1D_spectrum,
                           const GridPos& rte_gp_p,
                           const GridPos& rte_gp_lat,
                           const GridPos& rte_gp_lon,
                           const Vector& rte_los,
                           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);


void iyInterpPolyCloudboxField(// WS Output:
                               Matrix& iy,
                               // WS Input:
                               const Tensor7& scat_i_p,
                               const Tensor7& scat_i_lat,
                               const Tensor7& scat_i_lon,
                               const Tensor4& doit_i_field1D_spectrum,
                               const GridPos& rte_gp_p,
                               const GridPos& rte_gp_lat,
                               const GridPos& rte_gp_lon,
                               const Vector& rte_los,
                               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);


void jacobianAddAbsSpecies(// Workspace reference:
                           Workspace& ws,
                           // WS Output:
                           ArrayOfRetrievalQuantity& jacobian_quantities,
                           Agenda& jacobian_agenda,
                           // WS Input:
                           const Matrix& jacobian,
                           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);


void jacobianAddPointing(// Workspace reference:
                         Workspace& ws,
                         // WS Output:
                         ArrayOfRetrievalQuantity& jacobian_quantities,
                         Agenda& jacobian_agenda,
                         // WS Input:
                         const Matrix& jacobian,
                         const Matrix& sensor_pos,
                         const Vector& sensor_time,
                         // WS Generic Input:
                         const Numeric& dza,
                         const Index& poly_order);


void jacobianAddPolyfit(// Workspace reference:
                        Workspace& ws,
                        // WS Output:
                        ArrayOfRetrievalQuantity& jacobian_quantities,
                        Agenda& jacobian_agenda,
                        // WS Input:
                        const Matrix& jacobian,
                        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_za_variation,
                        const Index& no_mblock_variation);


void jacobianAddTemperature(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            ArrayOfRetrievalQuantity& jacobian_quantities,
                            Agenda& jacobian_agenda,
                            // WS Input:
                            const Matrix& jacobian,
                            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& hse,
                            const String& method,
                            const Numeric& dx);


void jacobianCalc(// Workspace reference:
                  Workspace& ws,
                  // WS Output:
                  Matrix& jacobian,
                  // WS Input:
                  const Agenda& jacobian_agenda,
                  const ArrayOfArrayOfIndex& jacobian_indices);


void jacobianCalcAbsSpecies(// Workspace reference:
                            Workspace& ws,
                            // WS Output:
                            Matrix& jacobian,
                            // WS Input:
                            const Agenda& jacobian_y_agenda,
                            const ArrayOfRetrievalQuantity& jacobian_quantities,
                            const ArrayOfArrayOfIndex& jacobian_indices,
                            const Index& atmosphere_dim,
                            const Vector& p_grid,
                            const Vector& lat_grid,
                            const Vector& lon_grid,
                            const ArrayOfArrayOfSpeciesTag& abs_species,
                            const Tensor4& vmr_field,
                            const Tensor3& t_field,
                            const Tensor4& pnd_field,
                            const Matrix& sensor_los,
                            const Vector& y,
                            // WS Generic Input:
                            const String& species);


void jacobianCalcPointing(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Matrix& jacobian,
                          // WS Input:
                          const Agenda& jacobian_y_agenda,
                          const ArrayOfRetrievalQuantity& jacobian_quantities,
                          const ArrayOfArrayOfIndex& jacobian_indices,
                          const Tensor4& vmr_field,
                          const Tensor3& t_field,
                          const Tensor4& pnd_field,
                          const Matrix& sensor_los,
                          const Vector& sensor_time,
                          const Vector& y);


void jacobianCalcPolyfit(// WS Output:
                         Matrix& jacobian,
                         // WS Input:
                         const ArrayOfRetrievalQuantity& jacobian_quantities,
                         const ArrayOfArrayOfIndex& jacobian_indices,
                         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_coeff);


void jacobianCalcTemperature(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Matrix& jacobian,
                             // WS Input:
                             const Agenda& jacobian_y_agenda,
                             const ArrayOfRetrievalQuantity& jacobian_quantities,
                             const ArrayOfArrayOfIndex& jacobian_indices,
                             const Index& atmosphere_dim,
                             const Vector& p_grid,
                             const Vector& lat_grid,
                             const Vector& lon_grid,
                             const Tensor4& vmr_field,
                             const Tensor3& t_field,
                             const Tensor4& pnd_field,
                             const Matrix& sensor_los,
                             const Vector& y);


void jacobianClose(// WS Output:
                   Matrix& jacobian,
                   ArrayOfArrayOfIndex& jacobian_indices,
                   // WS Input:
                   const ArrayOfRetrievalQuantity& jacobian_quantities,
                   const Matrix& sensor_pos,
                   const Sparse& sensor_response);


void jacobianInit(// WS Output:
                  Matrix& jacobian,
                  ArrayOfRetrievalQuantity& jacobian_quantities,
                  ArrayOfArrayOfIndex& jacobian_indices,
                  Agenda& jacobian_agenda);


void jacobianOff(// WS Output:
                 Matrix& jacobian,
                 ArrayOfRetrievalQuantity& jacobian_quantities,
                 ArrayOfArrayOfIndex& jacobian_indices,
                 String& jacobian_unit);


void jacobianUnit(// WS Output:
                  Matrix& jacobian,
                  // WS Input:
                  const String& jacobian_unit,
                  const String& y_unit,
                  const Vector& y_f);


void MatrixCBR(// WS Generic Output:
               Matrix& gout1,
               // WS Input:
               const Index& stokes_dim,
               // WS Generic Input:
               const Vector& gin1);


void MatrixCreate(// WS Generic Output:
                  Matrix& gout1);


void MatrixMatrixMultiply(// WS Generic Output:
                          Matrix& gout1,
                          // WS Generic Input:
                          const Matrix& gin1,
                          const Matrix& gin2);


void Matrix1ColFromVector(// WS Generic Output:
                          Matrix& gout1,
                          // WS Generic Input:
                          const Vector& gin1);


void Matrix2ColFromVectors(// WS Generic Output:
                           Matrix& gout1,
                           // WS Generic Input:
                           const Vector& gin1,
                           const Vector& gin2);


void Matrix3ColFromVectors(// WS Generic Output:
                           Matrix& gout1,
                           // WS Generic Input:
                           const Vector& gin1,
                           const Vector& gin2,
                           const Vector& gin3);


void Matrix1RowFromVector(// WS Generic Output:
                          Matrix& gout1,
                          // WS Generic Input:
                          const Vector& gin1);


void Matrix2RowFromVectors(// WS Generic Output:
                           Matrix& gout1,
                           // WS Generic Input:
                           const Vector& gin1,
                           const Vector& gin2);


void Matrix3RowFromVectors(// WS Generic Output:
                           Matrix& gout1,
                           // WS Generic Input:
                           const Vector& gin1,
                           const Vector& gin2,
                           const Vector& gin3);


void MatrixPlanck(// WS Generic Output:
                  Matrix& gout1,
                  // WS Input:
                  const Index& stokes_dim,
                  // WS Generic Input:
                  const Vector& gin1,
                  const Numeric& gin2);


void MatrixScale(// WS Generic Output:
                 Matrix& gout1,
                 // WS Generic Input:
                 const Matrix& gin1,
                 const Numeric& value);


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


void MatrixUnitIntensity(// WS Generic Output:
                         Matrix& gout1,
                         // WS Input:
                         const Index& stokes_dim,
                         // WS Generic Input:
                         const Vector& gin1);


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


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


void mc_antennaSetPencilBeam(// WS Output:
                             MCAntenna& mc_antenna);


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);


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 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 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);


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 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);


void MCSetSeedFromTime(// WS Output:
                       Index& mc_seed);


void NumericCreate(// WS Generic Output:
                   Numeric& gout1);


void NumericSet(// WS Generic Output:
                Numeric& gout1,
                // WS Generic Input:
                const Numeric& value);


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);


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);


void output_file_formatSetAscii(// WS Output:
                                String& output_file_format);


void output_file_formatSetBinary(// WS Output:
                                 String& output_file_format);


void output_file_formatSetZippedAscii(// WS Output:
                                      String& output_file_format);


void ParticleTypeAddAll(// WS Output:
                        ArrayOfSingleScatteringData& scat_data_raw,
                        ArrayOfGField3& 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);


void ParticleTypeAdd(// WS Output:
                     ArrayOfSingleScatteringData& scat_data_raw,
                     ArrayOfGField3& 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);


void ParticleTypeInit(// WS Output:
                      ArrayOfSingleScatteringData& scat_data_raw,
                      ArrayOfGField3& pnd_field_raw);


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);


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);


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);


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);


void pnd_fieldCalc(// WS Output:
                   Tensor4& pnd_field,
                   // WS Input:
                   const Vector& p_grid,
                   const Vector& lat_grid,
                   const Vector& lon_grid,
                   const ArrayOfGField3& pnd_field_raw,
                   const Index& atmosphere_dim,
                   const ArrayOfIndex& cloudbox_limits);


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);


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);


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);


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


void refr_indexFieldAndGradients(// Workspace reference:
                                 Workspace& ws,
                                 // WS Output:
                                 Numeric& refr_index,
                                 Numeric& rte_pressure,
                                 Numeric& rte_temperature,
                                 Vector& rte_vmr_list,
                                 // WS Generic Output:
                                 Tensor4& gout1,
                                 // WS Input:
                                 const Agenda& refr_index_agenda,
                                 const Index& atmosphere_dim,
                                 const Vector& p_grid,
                                 const Vector& lat_grid,
                                 const Vector& lon_grid,
                                 const Matrix& r_geoid,
                                 const Tensor3& z_field,
                                 const Tensor3& t_field,
                                 const Tensor4& vmr_field,
                                 // WS Generic Input:
                                 const Vector& gin1,
                                 const Vector& gin2,
                                 const Vector& gin3);


void refr_indexIR(// WS Output:
                  Numeric& refr_index,
                  // WS Input:
                  const Numeric& rte_pressure,
                  const Numeric& rte_temperature,
                  const Vector& rte_vmr_list);


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);


void refr_indexUnit(// WS Output:
                    Numeric& refr_index);


void RteCalc(// Workspace reference:
             Workspace& ws,
             // WS Output:
             Vector& y,
             Vector& y_f,
             ArrayOfIndex& y_pol,
             Matrix& y_pos,
             Matrix& y_los,
             Matrix& jacobian,
             // WS Input:
             const Agenda& ppath_step_agenda,
             const Agenda& rte_agenda,
             const Agenda& iy_space_agenda,
             const Agenda& surface_prop_agenda,
             const Agenda& iy_cloudbox_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 ArrayOfArrayOfSpeciesTag& abs_species,
             const Matrix& r_geoid,
             const Matrix& z_surface,
             const Index& cloudbox_on,
             const ArrayOfIndex& cloudbox_limits,
             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 Matrix& sensor_pos,
             const Matrix& sensor_los,
             const Vector& f_grid,
             const Index& stokes_dim,
             const Index& antenna_dim,
             const Vector& mblock_za_grid,
             const Vector& mblock_aa_grid,
             const ArrayOfRetrievalQuantity& jacobian_quantities,
             const ArrayOfArrayOfIndex& jacobian_indices,
             const String& y_unit,
             const String& jacobian_unit);


void RteCalcMC(// Workspace reference:
               Workspace& ws,
               // WS Output:
               Vector& y,
               Vector& y_f,
               ArrayOfIndex& y_pol,
               Matrix& y_pos,
               Matrix& y_los,
               Vector& mc_error,
               // WS Input:
               const Agenda& iy_space_agenda,
               const Agenda& surface_prop_agenda,
               const Agenda& opt_prop_gas_agenda,
               const Agenda& abs_scalar_gas_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 Index& cloudbox_on,
               const ArrayOfIndex& cloudbox_limits,
               const Tensor4& pnd_field,
               const ArrayOfSingleScatteringData& scat_data_raw,
               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 Matrix& sensor_pos,
               const Matrix& sensor_los,
               const Vector& f_grid,
               const Index& stokes_dim,
               const Index& antenna_dim,
               const Vector& mblock_za_grid,
               const Vector& mblock_aa_grid,
               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);


void RteCalcNoJacobian(// Workspace reference:
                       Workspace& ws,
                       // WS Output:
                       Vector& y,
                       Vector& y_f,
                       ArrayOfIndex& y_pol,
                       Matrix& y_pos,
                       Matrix& y_los,
                       // WS Input:
                       const Agenda& ppath_step_agenda,
                       const Agenda& rte_agenda,
                       const Agenda& iy_space_agenda,
                       const Agenda& surface_prop_agenda,
                       const Agenda& iy_cloudbox_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 Index& cloudbox_on,
                       const ArrayOfIndex& cloudbox_limits,
                       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 Matrix& sensor_pos,
                       const Matrix& sensor_los,
                       const Vector& f_grid,
                       const Index& stokes_dim,
                       const Index& antenna_dim,
                       const Vector& mblock_za_grid,
                       const Vector& mblock_aa_grid,
                       const String& y_unit);


void RteStd(// Workspace reference:
            Workspace& ws,
            // WS Output:
            Matrix& iy,
            ArrayOfTensor4& diy_dvmr,
            ArrayOfTensor4& diy_dt,
            // WS Input:
            const Ppath& ppath,
            const ArrayOfPpath& ppath_array,
            const Index& ppath_array_index,
            const Vector& f_grid,
            const Index& stokes_dim,
            const Agenda& emission_agenda,
            const Agenda& abs_scalar_gas_agenda,
            const ArrayOfIndex& rte_do_vmr_jacs,
            const Index& rte_do_t_jacs);


void RteStdWithTransmissions(// Workspace reference:
                             Workspace& ws,
                             // WS Output:
                             Matrix& iy,
                             Tensor4& ppath_transmissions,
                             ArrayOfTensor4& diy_dvmr,
                             ArrayOfTensor4& diy_dt,
                             // WS Input:
                             const Ppath& ppath,
                             const ArrayOfPpath& ppath_array,
                             const Index& ppath_array_index,
                             const Vector& f_grid,
                             const Index& stokes_dim,
                             const Agenda& emission_agenda,
                             const Agenda& abs_scalar_gas_agenda,
                             const ArrayOfIndex& rte_do_vmr_jacs,
                             const Index& rte_do_t_jacs);


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


void rte_posAddGeoidWGS84(// WS Output:
                          Vector& rte_pos,
                          // WS Input:
                          const Index& atmosphere_dim,
                          const Numeric& lat_1d,
                          const Numeric& meridian_angle_1d);


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);


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);


void rte_posShift(// WS Output:
                  Vector& rte_pos,
                  Vector& rte_los,
                  GridPos& rte_gp_p,
                  GridPos& rte_gp_lat,
                  GridPos& rte_gp_lon,
                  // WS Input:
                  const Ppath& ppath,
                  const Index& atmosphere_dim);


void rte_pos_and_losFromTangentPressure(// Workspace reference:
                                        Workspace& ws,
                                        // WS Output:
                                        Vector& rte_pos,
                                        Vector& rte_los,
                                        Ppath& ppath,
                                        // WS Input:
                                        const Index& atmosphere_dim,
                                        const Vector& p_grid,
                                        const Tensor3& z_field,
                                        const Vector& lat_grid,
                                        const Vector& lon_grid,
                                        const Agenda& ppath_step_agenda,
                                        const Matrix& r_geoid,
                                        const Matrix& z_surface,
                                        // WS Generic Input:
                                        const Numeric& tan_p);


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);


void r_geoidWGS84(// WS Output:
                  Matrix& r_geoid,
                  // WS Input:
                  const Index& atmosphere_dim,
                  const Vector& lat_grid,
                  const Vector& lon_grid,
                  const Numeric& lat_1d,
                  const Numeric& meridian_angle_1d);


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 Vector& f_grid,
                    const Agenda& doit_mono_agenda,
                    const Index& doit_is_initialized);


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);


void scat_data_rawCheck(// WS Input:
                        const ArrayOfSingleScatteringData& scat_data_raw);


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);


void sensor_posAddGeoidWGS84(// WS Output:
                             Matrix& sensor_pos,
                             // WS Input:
                             const Index& atmosphere_dim,
                             const Numeric& lat_1d,
                             const Numeric& meridian_angle_1d);


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);


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 GField4& antenna_response,
                            const Index& sensor_norm);


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 ArrayOfGField1& backend_channel_response,
                            const Index& sensor_norm);


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);


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


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);


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 GField1& sideband_response,
                          const Index& sensor_norm);


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 ArrayOfGField1& sideband_response_multi,
                                      const ArrayOfString& sideband_mode_multi,
                                      const ArrayOfVector& f_backend_multi,
                                      const ArrayOfArrayOfGField1& backend_channel_response_multi,
                                      const Index& sensor_norm);


void SparseCreate(// WS Generic Output:
                  Sparse& gout1);


void StringCreate(// WS Generic Output:
                  String& gout1);


void StringSet(// WS Generic Output:
               String& gout1,
               // WS Generic Input:
               const String& text);


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);


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);


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);


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);


void Tensor3Create(// WS Generic Output:
                   Tensor3& gout1);


void Tensor3FillWithVector(// WS Generic Output:
                           Tensor3& gout1,
                           // WS Generic Input:
                           const Vector& gin1,
                           const Index& npages,
                           const Index& nrows,
                           const Index& ncols);


void Tensor3Scale(// WS Generic Output:
                  Tensor3& gout1,
                  // WS Generic Input:
                  const Tensor3& gin1,
                  const Numeric& value);


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


void Tensor4Create(// WS Generic Output:
                   Tensor4& gout1);


void Tensor4Scale(// WS Generic Output:
                  Tensor4& gout1,
                  // WS Generic Input:
                  const Tensor4& gin1,
                  const Numeric& value);


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


void Tensor5Create(// WS Generic Output:
                   Tensor5& gout1);


void Tensor5Scale(// WS Generic Output:
                  Tensor5& gout1,
                  // WS Generic Input:
                  const Tensor5& gin1,
                  const Numeric& value);


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


void Tensor6Create(// WS Generic Output:
                   Tensor6& gout1);


void Tensor6Scale(// WS Generic Output:
                  Tensor6& gout1,
                  // WS Generic Input:
                  const Tensor6& gin1,
                  const Numeric& value);


void Tensor6SetConstant(// WS Generic Output:
                        Tensor6& gout1,
                        // 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);


void Tensor6ToPlanckBT(// WS Generic Output:
                       Tensor6& gout1,
                       // WS Input:
                       const Index& f_index,
                       const Vector& f_grid,
                       // WS Generic Input:
                       const Tensor6& gin1);


void Tensor7Create(// WS Generic Output:
                   Tensor7& gout1);


void Tensor7Scale(// WS Generic Output:
                  Tensor7& gout1,
                  // WS Generic Input:
                  const Tensor7& gin1,
                  const Numeric& value);


void Tensor7SetConstant(// WS Generic Output:
                        Tensor7& gout1,
                        // 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);


void Test();


void timerStart(// WS Output:
                Timer& timer);


void timerStop(// WS Input:
               const Timer& timer);


void VectorAddScalar(// WS Generic Output:
                     Vector& gout1,
                     // WS Generic Input:
                     const Vector& gin1,
                     const Numeric& value);


void VectorCreate(// WS Generic Output:
                  Vector& gout1);


void VectorExtractFromMatrix(// WS Generic Output:
                             Vector& gout1,
                             // WS Generic Input:
                             const Matrix& gin1,
                             const Index& gin2,
                             const String& direction);


void VectorInsertGridPoints(// WS Generic Output:
                            Vector& gout1,
                            // WS Generic Input:
                            const Vector& gin1,
                            const Vector& gin2);


void VectorLinSpace(// WS Generic Output:
                    Vector& gout1,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step);


void VectorLogSpace(// WS Generic Output:
                    Vector& gout1,
                    // WS Generic Input:
                    const Numeric& start,
                    const Numeric& stop,
                    const Numeric& step);


void VectorMatrixMultiply(// WS Generic Output:
                          Vector& gout1,
                          // WS Generic Input:
                          const Matrix& gin1,
                          const Vector& gin2);


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


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


void VectorScale(// WS Generic Output:
                 Vector& gout1,
                 // WS Generic Input:
                 const Vector& gin1,
                 const Numeric& value);


void VectorSetConstant(// WS Generic Output:
                       Vector& gout1,
                       // WS Input:
                       const Index& nelem,
                       // WS Generic Input:
                       const Numeric& value);


void VectorSet(// WS Generic Output:
               Vector& gout1,
               // WS Generic Input:
               const Vector& values);


void VectorZtanToZaRefr1D(// Workspace reference:
                          Workspace& ws,
                          // WS Output:
                          Numeric& refr_index,
                          Numeric& rte_pressure,
                          Numeric& rte_temperature,
                          Vector& rte_vmr_list,
                          // WS Generic Output:
                          Vector& gout1,
                          // 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& gin1);


void VectorZtanToZa1D(// WS Generic Output:
                      Vector& gout1,
                      // WS Input:
                      const Matrix& sensor_pos,
                      const Matrix& r_geoid,
                      const Index& atmosphere_dim,
                      // WS Generic Input:
                      const Vector& gin1);


void ybatchCalc(// Workspace reference:
                Workspace& ws,
                // WS Output:
                Matrix& ybatch,
                // WS Input:
                const Index& ybatch_n,
                const Agenda& ybatch_calc_agenda,
                // WS Generic Input:
                const Index& robust);


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);


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);


void ybatchUnit(// WS Output:
                Matrix& ybatch,
                // WS Input:
                const String& y_unit,
                const Vector& y_f);


void yUnit(// WS Output:
           Vector& y,
           // WS Input:
           const String& y_unit,
           const Vector& y_f);


void ZaSatOccultation(// Workspace reference:
                      Workspace& ws,
                      // WS Generic Output:
                      Vector& gout1,
                      // 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,
                      // WS Generic Input:
                      const Numeric& z_recieve,
                      const Numeric& z_send,
                      const Numeric& t_sample,
                      const Numeric& z_scan_low,
                      const Numeric& z_scan_high);

// Supergeneric template function declarations:


template <typename T>
void Append(// WS Generic Output:
            T& out,
            // WS Generic Input:
            const T& in);


template <typename T>
void Copy(// WS Generic Output:
          T& gout1,
          // WS Generic Input:
          const T& gin1);


template <typename T>
void Delete(// Workspace reference:
            Workspace& ws,
            // WS Generic Input:
            const T& gin1,
            // WS Generic Input Names:
            const String& gin1_wsvname);


template <typename T>
void DoNothing(// WS Generic Output:
               T& gout1,
               // WS Generic Input:
               const T& gin1);


template <typename T>
void Extract(// WS Generic Output:
             T& needle,
             // WS Generic Input:
             const T& haystack,
             const Index& index);


template <typename T>
void Ignore(// WS Generic Input:
            const T& gin1);


template <typename T>
void nelemGet(// WS Output:
              Index& nelem,
              // WS Generic Input:
              const T& gin1);


template <typename T>
void ncolsGet(// WS Output:
              Index& ncols,
              // WS Generic Input:
              const T& gin1);


template <typename T>
void nrowsGet(// WS Output:
              Index& nrows,
              // WS Generic Input:
              const T& gin1);


template <typename T>
void npagesGet(// WS Output:
               Index& npages,
               // WS Generic Input:
               const T& gin1);


template <typename T>
void nbooksGet(// WS Output:
               Index& nbooks,
               // WS Generic Input:
               const T& gin1);


template <typename T>
void nshelvesGet(// WS Output:
                 Index& nshelves,
                 // WS Generic Input:
                 const T& gin1);


template <typename T>
void nvitrinesGet(// WS Output:
                  Index& nvitrines,
                  // WS Generic Input:
                  const T& gin1);


template <typename T>
void Print(// WS Generic Input:
           const T& gin1,
           const Index& level);


template <typename T>
void ReadNetCDF(// WS Generic Output:
                T& gout1,
                // WS Generic Output Names:
                const String& gout1_wsvname,
                // WS Generic Input:
                const String& filename,
                // WS Generic Input Names:
                const String& filename_wsvname);


template <typename T>
void ReadXML(// WS Generic Output:
             T& gout1,
             // WS Generic Output Names:
             const String& gout1_wsvname,
             // WS Generic Input:
             const String& filename,
             // WS Generic Input Names:
             const String& filename_wsvname);


template <typename T>
void Select(// WS Generic Output:
            T& needles,
            // WS Generic Input:
            const T& haystack,
            const ArrayOfIndex& needleindexes);


template <typename T>
void WriteNetCDF(// WS Generic Input:
                 const T& genericinput1,
                 const String& filename,
                 // WS Generic Input Names:
                 const String& genericinput1_wsvname,
                 const String& filename_wsvname);


template <typename T>
void WriteXML(// WS Input:
              const String& output_file_format,
              // WS Generic Input:
              const T& gin1,
              const String& filename,
              // WS Generic Input Names:
              const String& gin1_wsvname,
              const String& filename_wsvname);


template <typename T>
void WriteXMLIndexed(// WS Input:
                     const String& output_file_format,
                     const Index& file_index,
                     // WS Generic Input:
                     const T& gin1,
                     const String& filename,
                     // WS Generic Input Names:
                     const String& gin1_wsvname,
                     const String& filename_wsvname);

// Get-away function declarations:

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_linesReadFromArtsObsolete_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_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 SpeciesSet_g(Workspace& ws, const MRecord& mr);
void abs_vecAddGas_g(Workspace& ws, const MRecord& mr);
void abs_vecAddPart_g(Workspace& ws, const MRecord& mr);
void abs_vecInit_g(Workspace& ws, const MRecord& mr);
void abs_xsec_per_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 AntennaOff_g(Workspace& ws, const MRecord& mr);
void AntennaSet1D_g(Workspace& ws, const MRecord& mr);
void AntennaSet2D_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_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_ArrayOfPpathArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfArrayOfArrayOfGridPosArrayOfArrayOfArrayOfArrayOfGridPos_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGField1ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGField2ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGField3ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfGField4ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGField1ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Append_sg_ArrayOfArrayOfGField3ArrayOfArrayOfGField3_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 ArrayOfGField1Create_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfIndexSet_g(Workspace& ws, const MRecord& mr);
void ArrayOfLineRecordCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfLineshapeSpecCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfMatrixCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfMatrixInsert_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringCreate_g(Workspace& ws, const MRecord& mr);
void ArrayOfStringSet_g(Workspace& ws, const MRecord& mr);
void ArrayOfVectorCreate_g(Workspace& ws, const MRecord& mr);
void Arts_g(Workspace& ws, const MRecord& mr);
void AtmFieldsCalc_g(Workspace& ws, const MRecord& mr);
void AtmFieldsCalcExpand1D_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_compactFromMatrix_g(Workspace& ws, const MRecord& mr);
void batch_atm_fields_compactFromArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void AtmFieldsFromCompact_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet1D_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet2D_g(Workspace& ws, const MRecord& mr);
void AtmosphereSet3D_g(Workspace& ws, const MRecord& mr);
void AtmRawRead_g(Workspace& ws, const MRecord& mr);
void CloudboxGetIncoming_g(Workspace& ws, const MRecord& mr);
void CloudboxGetIncoming1DAtm_g(Workspace& ws, const MRecord& mr);
void cloudboxOff_g(Workspace& ws, const MRecord& mr);
void cloudboxSetDisort_g(Workspace& ws, const MRecord& mr);
void cloudboxSetEmpty_g(Workspace& ws, const MRecord& mr);
void cloudboxSetManually_g(Workspace& ws, const MRecord& mr);
void cloudboxSetManuallyAltitude_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GField2_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_GField4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Copy_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Copy_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Copy_sg_SLIData2_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GField2_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_GField4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Delete_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Delete_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Delete_sg_SLIData2_g(Workspace& ws, const MRecord& mr);
void ScatteringDisort_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 DoNothing_sg_Index_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Numeric_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_String_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Vector_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Matrix_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Sparse_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Tensor3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Tensor4_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Tensor5_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Tensor6_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Tensor7_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Timer_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfIndex_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfString_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfVector_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfMatrix_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfTensor3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfTensor4_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfTensor7_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfTensor6_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfLineRecord_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfLineshapeSpec_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfSpeciesTag_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Ppath_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_Agenda_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GridPos_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfArrayOfArrayOfGridPos_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GasAbsLookup_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_SingleScatteringData_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GField1_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GField2_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GField3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_GField4_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void DoNothing_sg_SLIData2_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_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_ArrayOfGField3ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Extract_sg_GField4ArrayOfGField4_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 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 FlagOff_g(Workspace& ws, const MRecord& mr);
void FlagOn_g(Workspace& ws, const MRecord& mr);
void f_gridFromGasAbsLookup_g(Workspace& ws, const MRecord& mr);
void ForLoop_g(Workspace& ws, const MRecord& mr);
void GField1Create_g(Workspace& ws, const MRecord& mr);
void GField2Create_g(Workspace& ws, const MRecord& mr);
void GField3Create_g(Workspace& ws, const MRecord& mr);
void GField4Create_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GField2_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_GField4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Ignore_sg_SLIData2_g(Workspace& ws, const MRecord& mr);
void INCLUDE_g(Workspace& ws, const MRecord& mr);
void IndexCreate_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 iyInterpCloudboxField_g(Workspace& ws, const MRecord& mr);
void iyInterpPolyCloudboxField_g(Workspace& ws, const MRecord& mr);
void jacobianAddAbsSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianAddPointing_g(Workspace& ws, const MRecord& mr);
void jacobianAddPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianAddTemperature_g(Workspace& ws, const MRecord& mr);
void jacobianCalc_g(Workspace& ws, const MRecord& mr);
void jacobianCalcAbsSpecies_g(Workspace& ws, const MRecord& mr);
void jacobianCalcPointing_g(Workspace& ws, const MRecord& mr);
void jacobianCalcPolyfit_g(Workspace& ws, const MRecord& mr);
void jacobianCalcTemperature_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 jacobianUnit_g(Workspace& ws, const MRecord& mr);
void MatrixCBR_g(Workspace& ws, const MRecord& mr);
void MatrixCreate_g(Workspace& ws, const MRecord& mr);
void MatrixMatrixMultiply_g(Workspace& ws, const MRecord& mr);
void Matrix1ColFromVector_g(Workspace& ws, const MRecord& mr);
void Matrix2ColFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix3ColFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix1RowFromVector_g(Workspace& ws, const MRecord& mr);
void Matrix2RowFromVectors_g(Workspace& ws, const MRecord& mr);
void Matrix3RowFromVectors_g(Workspace& ws, const MRecord& mr);
void MatrixPlanck_g(Workspace& ws, const MRecord& mr);
void MatrixScale_g(Workspace& ws, const MRecord& mr);
void MatrixSetConstant_g(Workspace& ws, const MRecord& mr);
void MatrixUnitIntensity_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 NumericCreate_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_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_ArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfArrayOfArrayOfGridPos_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void nelemGet_sg_ArrayOfArrayOfGField3_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_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_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 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_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 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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_GField2_g(Workspace& ws, const MRecord& mr);
void Print_sg_GField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_GField4_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Print_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void Print_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void Print_sg_SLIData2_g(Workspace& ws, const MRecord& mr);
void PrintWorkspace_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_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GField2_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_GField4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void ReadXML_sg_SLIData2_g(Workspace& ws, const MRecord& mr);
void refr_indexFieldAndGradients_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 RteCalc_g(Workspace& ws, const MRecord& mr);
void RteCalcMC_g(Workspace& ws, const MRecord& mr);
void RteCalcNoJacobian_g(Workspace& ws, const MRecord& mr);
void RteStd_g(Workspace& ws, const MRecord& mr);
void RteStdWithTransmissions_g(Workspace& ws, const MRecord& mr);
void rte_losSet_g(Workspace& ws, const MRecord& mr);
void rte_posAddGeoidWGS84_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 rte_posShift_g(Workspace& ws, const MRecord& mr);
void rte_pos_and_losFromTangentPressure_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 ScatteringDoit_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_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_ArrayOfPpathArrayOfPpath_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfArrayOfArrayOfGridPosArrayOfArrayOfArrayOfArrayOfGridPos_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfSingleScatteringDataArrayOfSingleScatteringData_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGField1ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGField2ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGField3ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfGField4ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfGField1ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void Select_sg_ArrayOfArrayOfGField3ArrayOfArrayOfGField3_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 sensorOff_g(Workspace& ws, const MRecord& mr);
void sensor_posAddGeoidWGS84_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_responseBeamSwitching_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 SparseCreate_g(Workspace& ws, const MRecord& mr);
void StringCreate_g(Workspace& ws, const MRecord& mr);
void StringSet_g(Workspace& ws, const MRecord& mr);
void surfaceBlackbody_g(Workspace& ws, const MRecord& mr);
void surfaceFlatRefractiveIndex_g(Workspace& ws, const MRecord& mr);
void surfaceFlatSingleEmissivity_g(Workspace& ws, const MRecord& mr);
void surfaceFlatVaryingEmissivity_g(Workspace& ws, const MRecord& mr);
void Tensor3Create_g(Workspace& ws, const MRecord& mr);
void Tensor3FillWithVector_g(Workspace& ws, const MRecord& mr);
void Tensor3Scale_g(Workspace& ws, const MRecord& mr);
void Tensor3SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor4Create_g(Workspace& ws, const MRecord& mr);
void Tensor4Scale_g(Workspace& ws, const MRecord& mr);
void Tensor4SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor5Create_g(Workspace& ws, const MRecord& mr);
void Tensor5Scale_g(Workspace& ws, const MRecord& mr);
void Tensor5SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor6Create_g(Workspace& ws, const MRecord& mr);
void Tensor6Scale_g(Workspace& ws, const MRecord& mr);
void Tensor6SetConstant_g(Workspace& ws, const MRecord& mr);
void Tensor6ToPlanckBT_g(Workspace& ws, const MRecord& mr);
void Tensor7Create_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 VectorAddScalar_g(Workspace& ws, const MRecord& mr);
void VectorCreate_g(Workspace& ws, const MRecord& mr);
void VectorExtractFromMatrix_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 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_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GField2_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_GField4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXML_sg_SLIData2_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_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_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_ArrayOfPpath_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_ArrayOfArrayOfArrayOfArrayOfGridPos_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_GField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GField2_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_GField4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGField2_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfGField4_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfGField1_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfArrayOfGField3_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_ArrayOfRetrievalQuantity_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_MCAntenna_g(Workspace& ws, const MRecord& mr);
void WriteXMLIndexed_sg_SLIData2_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 ybatchUnit_g(Workspace& ws, const MRecord& mr);
void yUnit_g(Workspace& ws, const MRecord& mr);
void ZaSatOccultation_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_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_cloudbox_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        // Input
        const Ppath& ppath,
        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
        // Wrapper Input
        const Agenda& input_agenda);

void jacobian_y_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Vector& y,
        // Input
        const Tensor4& vmr_field,
        const Tensor3& t_field,
        const Tensor4& pnd_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 GField3& t_field_raw,
        const ArrayOfGField3& vmr_field_raw,
        const GField3& z_field_raw,
        const ArrayOfGField3& 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 rte_agendaExecute(
        // Workspace
        Workspace& ws,
        // Output
        Matrix& iy,
        ArrayOfTensor4& diy_dvmr,
        ArrayOfTensor4& diy_dt,
        // Input
        const Ppath& ppath,
        const ArrayOfPpath& ppath_array,
        const Index ppath_array_index,
        const ArrayOfIndex& rte_do_vmr_jacs,
        const Index rte_do_t_jacs,
        const Index stokes_dim,
        const Vector& f_grid,
        // 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,
        // Input
        const Index ybatch_index,
        // Wrapper Input
        const Agenda& input_agenda);


#endif  // auto_md_h

---